Java 基于用户输入将人员平均分配到组 ReadFile randomGenerate=new ReadFile（）； Input userNum=新输入（）； 字符串classnum=userNum.fileToSelect（）； int lineNumber=randomGenerate.lineCounter（classnum）； //classnum.txt中的学生人数 ArrayList people=randomGenerate.readPeople（）； //名称字符串（每行的第一个单词） int userPut=userNum.numInput（）； int maxNum=行号/userPut；

对不对，我正在读取一个txt文件——每行的第一个字是一个人的名字。我想将这个ArrayList中的人分成偶数组，组的数量基于userinput

int[]number=不重复的随机数（0，行号，行号）；
//按顺序排列的数字数组
int[]randomNumbers=randomizarray（数字）；
//洗牌数组

我按顺序生成了一组数字，然后将它们洗牌，效果很好

---

但是，我的分组方法是基于ifelse条件的，这种条件不太适用。那么，有没有一种有效的方法将这个名称数组列表放入用户想要的组中呢？

我有

x

个学生

Students: 42, 27, 5, 26, 32, 30, 44, 10, 17, 29, 40, 52, 
    47, 38, 49, 18, 46, 24, 34, 12, 13, 53, 35, 20, 1, 
    2, 41, 23, 43, 28, 8, 11, 50, 37, 9, 7, 48, 3, 33, 
    25, 31, 15, 22, 21, 14, 45, 36, 16, 51, 19, 4, 6, 39
Group 1: 42, 27, 5, 26, 32, 30, 44, 10, 17, 29, 40, 52, 47, 38
Group 2: 49, 18, 46, 24, 34, 12, 13, 53, 35, 20, 1, 2, 41
Group 3: 23, 43, 28, 8, 11, 50, 37, 9, 7, 48, 3, 33, 25
Group 4: 31, 15, 22, 21, 14, 45, 36, 16, 51, 19, 4, 6, 39

我有

n

组数

我假设没有其他标准来划分学生分组

基本上，你把小组的数量分成学生的数量。是的，你必须处理一个余数。但这很简单

这是一项测试的结果。我创造了53名学生，并将他们洗牌。然后我把学生分成4组。我手动格式化输出以适应答案。第一组有14名学生，其余组有13名学生

Students: 42, 27, 5, 26, 32, 30, 44, 10, 17, 29, 40, 52, 
    47, 38, 49, 18, 46, 24, 34, 12, 13, 53, 35, 20, 1, 
    2, 41, 23, 43, 28, 8, 11, 50, 37, 9, 7, 48, 3, 33, 
    25, 31, 15, 22, 21, 14, 45, 36, 16, 51, 19, 4, 6, 39
Group 1: 42, 27, 5, 26, 32, 30, 44, 10, 17, 29, 40, 52, 47, 38
Group 2: 49, 18, 46, 24, 34, 12, 13, 53, 35, 20, 1, 2, 41
Group 3: 23, 43, 28, 8, 11, 50, 37, 9, 7, 48, 3, 33, 25
Group 4: 31, 15, 22, 21, 14, 45, 36, 16, 51, 19, 4, 6, 39

这是代码。

groupstudent

和

sortstudens

方法是完成这项工作的方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StudentGroups {

    public static void main(String[] args) {
        int numberOfGroups = 4;
        int numberOfStudents = 53;
        StudentGroups sg = new StudentGroups(numberOfStudents);
        sg.printStudents();
        List<List<Integer>> groups = sg.groupStudents(
                numberOfGroups);
        sg.printGroups(groups);
    }

    private List<Integer> students;

    public StudentGroups(int numberOfStudents) {
        students = new ArrayList<>(numberOfStudents);
        for (int i = 0; i < numberOfStudents; i++) {
            students.add(i + 1);
        }
        Collections.shuffle(students);
    }

    public void printStudents() {
        System.out.print("Students: ");
        for (int i = 0; i < students.size(); i++) {
            System.out.print(students.get(i));
            if (i < (students.size() - 1)) {
                System.out.print(", ");
            }
        }
        System.out.println();
    }

    public List<List<Integer>> groupStudents(int groups) {
        List<List<Integer>> output = new ArrayList<>();

        int size = students.size();
        int group = size / groups;
        int remainder = size % groups;
        sortStudents(output, size, group, remainder);

        return output;
    }

    private void sortStudents(List<List<Integer>> output, 
            int size, int group, int remainder) {
        List<Integer> list = new ArrayList<>();
        int count = 0;

        for (int i = 0; i < size; i++) {            
            list.add(students.get(i));

            if (count == 0 && remainder > 0) {
                if (group > 0) {
                    list.add(students.get(++i));
                }
                remainder--;
            }

            if (++count >= group) {
                addList(output, list);
                list = new ArrayList<>();
                count = 0;
            }
        }

        addList(output, list);
    }

    private void addList(List<List<Integer>> output, 
            List<Integer> list) {
        if (list.size() > 0) {
            output.add(list);
        }
    }

    public void printGroups(List<List<Integer>> groups) {
        for (int j = 0; j < groups.size(); j++) {
            System.out.print("Group ");
            System.out.print(j + 1);
            System.out.print(": ");
            List<Integer> students = groups.get(j);
            for (int i = 0; i < students.size(); i++) {
                System.out.print(students.get(i));
                if (i < (students.size() - 1)) {
                    System.out.print(", ");
                }
            }
            System.out.println();
        }
    }

}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公共班级学生小组{
公共静态void main（字符串[]args）{
int numberOfGroups=4；
国际学生人数=53；
学生组sg=新学生组（学生人数）；
sg.printStudents（）；
列表组=sg.groupStudents(
组数）；
sg.打印组（组）；
}
私人名单学生；
公共学生团体（国际学生人数）{
学生=新阵列列表（numberOfStudents）；
for（int i=0；i0）{
如果（组>0）{
list.add（students.get（++i））；
}
余数--；
}
如果（++计数>=组）{
addList（输出，列表）；
列表=新的ArrayList（）；
计数=0；
}
}
addList（输出，列表）；
}
私有void addList（列表输出，
（列表）{
如果（list.size（）>0）{
输出。添加（列表）；
}
}
公共组（列表组）{
对于（int j=0；j

我不确定一个小组的标准是什么，但是如果你有30名学生和5个小组，你不能把前6名学生放在第一个小组，然后6名学生放在下一个小组，依此类推吗？@GilbertLeBlanc是的，但有些数字有余数，我目前的方法不太有效