简单利用Arraylist实现班级分班

最新推荐文章于 2023-08-01 00:26:22 发布
最新推荐文章于 2023-08-01 00:26:22 发布
阅读量736 收藏 1
点赞数
文章标签： java 数据结构与算法
原文链接：https://segmentfault.com/a/1190000014215107
版权

学校希望根据同专业的同学们的绩点平均分班，你需要打印出每个班级的所有学生信息。

可以把这个问题分解成以下几个小任务：

  1. 创建一个名为Student的类，包含：

  2. 创建一个名为ClassInfo的类，包含：

    • 收集所有学生的个人信息，利用Arraylist实现
    • 对收集到的学生信息用冒泡排序法重新排序

    • 基于班级个数，用"S"型排序重新分班

      • 什么是"S"型排序呢？

        • 假设总共有三个班级，4位学生。我们将绩点由低到高的顺序，将第一位给1班，第二位给2班。如果班级人数不能整除学生人数也没关系，后面的排序方式依然由低到高，直到排完为止。如示意图所示：
          "S"型排序示意图
    • 通过绩点(调用Arraylist的方法)找到对应的学生信息
    • 打印各班学生信息

源码

Name类代码如下：

/**
 * @author Hephaest
 * @version  6/04/2018
 * @since jdk1.8.0_162
 */
public class Name
{
    //声明实例变量
    private String first;
    private String second;
    private String last;
    private String fullName;
    /**初始化构造方法，用 this 指向类中的实例变量，尤其是当调用的参数和内部声明参数一致时*/
    //当没有中间名时
    public Name(String first, String last)
    {
        this.first = first;
        this.last = last;
    }
    //当有中间名时
    public Name(String first, String second, String last)
    {
        this.first = first;
        this.second = second;
        this.last = last;
    }
    //判断是否有中间名，有的话注意是两个空格
    public String getFullName()
    {
         if(second==null)
         {
            fullName=first+" "+last;
            return fullName;
         }
         else
         {
            fullName=first+" "+second+" "+last;
            return fullName;
         }
      }
}

Grade类代码如下：

/**
 * @author Hephaest
 * @version  6/04/2018
 * @since jdk1.8.0_162
 */
import java.util.*;
public class Grade {
    private String rank;
    private double grade;
    private double xuefen;
    /**
     * 如果成绩是以等级形式给的，使用这个构造方法
     * @param rank 等级
     * @param xuefen 学分
     */
    public Grade(String rank,double xuefen)
    {
        this.rank=rank;
        this.xuefen=xuefen;
        this.grade=0.0;
    }
    /**
     * 如果成绩是以百分比或者直接就是绩点的形式，使用这个构造方法
     * @param grade 百分比的成绩或绩点
     * @param xuefen 学分
     */
    public Grade(double grade,double xuefen)
    {
        this.grade=grade;
        this.xuefen=xuefen;
        this.rank="";
    }
    /* 考虑成绩是以哪种形式输入的，进入对应的判断语句
     * 判断标准详见：http://www.bjtu.edu.cn/pub/xxgk/xxgksxqs/xsglfwxx/18999.htm
     */
    public double getgrade()
    {
        if(rank.equalsIgnoreCase(""))
        {
            if(grade>100||grade<0)
            {
                System.out.println("Wrong input!");
                grade=0.0;
                xuefen=0.0;
                return grade;
            }
            else if (grade>=96)
            {
                grade=5.0;
                return grade;
            }
            else if (grade>=91)
            {
                grade=4.5;
                return grade;
            }
            else if (grade>=86)
            {
                grade=4.0;
                return grade;
            }
            else if (grade>=81)
            {
                grade=3.5;
                return grade;
            }
            else if (grade>=76)
            {
                grade=3.0;
                return grade;
            }
            else if (grade>=71)
            {
                grade=2.5;
                return grade;
            }
            else if (grade>=66)
            {
                grade=2.0;
                return grade;
            }
            else if (grade>=61)
            {
                grade=1.5;
                return grade;
            }
            else if (grade>=60)
            {
                grade=1.0;
                return grade;
            }
            else if(grade>=00&&grade<=5)
            {
                return grade;
            }
            else
            {
                grade=0.0;
                return grade;
            }
        }
        else
        {   //因为输入的是一串字符串，所以要转换成一个个字符
            char[] array= rank.toCharArray();
            double grade=0.0;
            for(int i=0;i<array.length;i++)
            {
                switch(array[i])
                {
                    case 'A':
                        grade=4.0;
                        break;
                    case 'B':
                        grade=3.0;
                        break;
                    case 'C':
                        grade=2.0;
                        break;
                    case 'D':
                        grade=1.0;
                        break;
                    case 'F':
                        grade=0.0;
                        break;
                    case '+':
                        grade+=0.5;
                        break;
                    case '-':
                        if(grade<=0)
                        {
                            break;
                        }
                        else
                        {
                            grade-=0.5;
                            break;
                        }
                    default:
                        System.out.println("Your input is wrong!");
                }
            }
            return grade;
        }
    }
    public double getXuefen()
    {
        return xuefen;
    }
}

Student类代码如下：

/**
 * @author Hephaest
 * @version  6/04/2018
 * @since jdk1.8.0_162
 */
import java.text.DecimalFormat;
import java.util.ArrayList;

public class Student
{
    //用Name声明实例变量name，用ArrayList<grade> 声明grade
    private Name name;
    private int id;
    private ArrayList<Grade> grade;
    //如果没有中间名，使用这个构造方法进行实例化
    public Student(String first, String last,
                   int id)
    {
       this.name = new Name(first, last);//调用之前写好的Name类
       this.id = id;
       grade=new ArrayList<Grade>();//调用已经在package有的Arraylist类
    }
    //如果有中间名，使用这个构造方法进行实例化
    public Student(String first, String second, String last, 
                           int id)
    {
       this.name = new Name(first, second, last);
       this.id = id;
       grade=new ArrayList<Grade>();
    }
    //直接获取Name里的方法，避免重写
    public String getName()
    {
        return name.getFullName();
    }
    //一个学生可能有很多项成绩，链表的add方法就是在(单个)学生的成绩后面继续追加成绩，很实用的办法
    public void addGrade(Grade newGrade)
    {
        grade.add(newGrade); 
    }
   //把一个学生的所有成绩进行加权平均运算，得到最终的绩点
    public double averageGPA()
    {
        double sum1=0.0;
        double sum2=0.0;
        for(int i = 0;i < grade.size(); i++)
        {
            sum1+=grade.get(i).getgrade()*grade.get(i).getXuefen();
            sum2+=grade.get(i).getXuefen();
        }
        return sum1/sum2;
    }
    //获取学生学号
    public int getID()
    {
        return id; 
    }
    //对单个学生的所有信息进行打印，依次为：姓名-学号-平均绩点
    public void print()
    {
        DecimalFormat fm = new DecimalFormat("#.##");
        System.out.println("Name:\t " + getName()
                      + "\nID:\t " + getID()
                      + "\nGPA:\t" + fm.format(averageGPA()));
    }
}

ClassInfo类代码如下：

/**
 * @author Hephaest
 * @version  6/04/2018
 * @since jdk1.8.0_162
 */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class ClassInfo {
    private ArrayList<Student> students;
    // 用 Arraylist 声明students
    public ClassInfo()
    {
        students =new ArrayList<Student>();
    }
    /**
     * initialInfo 用来获取控制台中输入的所有学生信息
     * @param numberOfStudent 确定输入学生的个数
     * @param newclas 输入创造的对象
     */
    public void initialInfo(int numberOfStudent,Object newclas)
    {
        Scanner info=new Scanner (System.in);
        ClassInfo newclass=(ClassInfo)newclas;
        for(int i=0;i<numberOfStudent;i++)
            {
                System.out.println("Set the student's ID number:");
                int number=info.nextInt();
                System.out.println("Set the student's first name:");
                String space = info.nextLine();
                String first=info.nextLine();
                System.out.println("Does student has second name?");
                String answer=info.nextLine();
                if(answer.equalsIgnoreCase("y"))
                {
                    System.out.println("Set the student's second name:");
                    String second=info.nextLine();
                    System.out.println("Set the student's last name:");
                    String last=info.nextLine();
                    newclass.addStudent(new Student(first,second,last,number));
                }
                else
                {
                    System.out.println("Set the student's last name:");
                    String last=info.nextLine();
                    newclass.addStudent(new Student(first,last,number));
                }
                System.out.println("Which types of grades you want to input:\n"+
                                "\t1:rank\n"+
                                "\t2:score\n");
                int choice=info.nextInt();
                switch(choice)
                {
                   case 1:
                       System.out.println("Set the student's rank:");
                       space = info.nextLine();
                          String rank=info.nextLine();
                          System.out.println("Set the student's xuefen:");
                          double xuefen=info.nextDouble();
                       newclass.addNewRank(i,new Grade(rank,xuefen));
                       break;
                   case 2:
                       System.out.println("Set the student's score");
                          double score=info.nextDouble();
                          System.out.println("Set the student's xuefen");
                          double fen=info.nextDouble();
                       newclass.addNewScore(i,new Grade(score,fen));
                       break;
                }
                boolean flag=true;
                while(flag==true)
                {
                    System.out.println("Does any grade need to be added?");
                    space = info.nextLine();
                    answer=info.nextLine();
                    switch(answer)
                    {
                    case "Y":
                    case "y":
                        System.out.println("Which types of grades you"+
                                "want to input:\n"+
                                "\t1:rank\n"+
                                "\t2:score\n");
                        choice=info.nextInt();
                        space = info.nextLine();
                        switch(choice)
                        {
                           case 1:
                               System.out.println("Set the student's rank");
                                  String rank=info.nextLine();
                                  System.out.println("Set the student's xuefen");
                                  double xuefen=info.nextDouble();
                               newclass.addNewRank(i,new Grade(rank,xuefen));
                               break;
                           case 2:
                               System.out.println("Set the student's score");
                                  double score=info.nextDouble();
                                  System.out.println("Set the student's xuefen");
                                  double fen=info.nextDouble();
                               newclass.addNewScore(i,new Grade(score,fen));
                               break;
                        }
                        break;
                    case "n":
                    case "N":
                        flag=false;
                        break;
                    default:
                        System.out.println("Please answer \"yes\" or \"no\" !");
                    }
                }
            }
    }
    //students里追加学生(包括每个学生的所有信息)
    public void addStudent(Student newStudent)
    {
        students.add(newStudent); 
    }
    /**
     * 这个方法实现每位学生可以拥有多个成绩，通过追加的方法
     * @param index 代表学生链表中第几位学生
     * @param newGrade grade对象(创建新的成绩)
     */
    public void addNewScore(int index,Grade newGrade)
    {
        students.get(index).addGrade(newGrade);
    }
    /*
     * 本质上与上面的方法一样，名字不同为了好区分新输入的成绩的形式
     */
    public void addNewRank(int index,Grade newGrade)
    {
        students.get(index).addGrade(newGrade);
    }
    /*
     * 这里使用泡沫排序法对学生的成绩进行排序
     * 因为没有办法为Arraylist创建数组
     * 因此用新的数组拷贝students里所有的成绩
     * 注意：数组下表和students的下表并不是意义对应的关系
     */
    public double[] bubbleSortStudent()
    {
        double temp;
        int size = students.size();
        double[] array=new double[size];
        for (int i=0;i<size;i++)
        {
            array[i]=students.get(i).averageGPA();
        }
     
        for(int i = 0 ; i < size-1; i ++)
        {
            for(int j = 0 ;j < size-1-i ; j++)
            {
                if(array[j] > array[j+1])  
                {
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                }
            }
        }
        return array;
    } 

    /**
     * 经过上面一步，我们成功把students里所有学生的成绩拷贝给数组array[i]
     ** 现在我们要做的就是根据学生的成绩分配到不同的班级
     *  常用的方法是“S”型排法
     * @param num 班级的总数
     * @param array 泡沫排序完后的数组
     * @return 分班完后的二维数组结果
     */
    public double[][] allocateStudent(int num,double[] array)
    {
        int classNum=students.size()/num;
        int classrest=students.size()%num;
        classNum+=classrest;
        double[][] arr=new double[num][classNum];
        int k;
        for(int j=0;j<num;j++)
        {
            k=j;
           for(int i=0;i<classNum;i++)
           {
               if(k>=students.size())
               {
                   break;
               }
               else 
               {
                 arr[j][i]=array[k];
                 k+=num;
               }
                
                
            }    
        }
        return arr;
    }
    //找到需要删除的学生所在的students下标，调用remove方法即可
    public void removeStudent(int studentEntry)
    {
        students.remove(studentEntry);
    }
    /**
     * 打印每个班级的学生信息
     * @param num 班级的总数
     * @param arr 经过“S”型排列完的二维数组(可看作已经分班完的结果)
     *               调用的是 allocateStudent 方法里返回的数组
     * 注意：一般在公布分班情况的时候不会显示个体的成绩(确保隐私权)
     *         这里体现是为了验证分班结果的正确性
     */
    public void print(int num,double[][]arr)
    {
        for(int i=0;i<arr[0].length;i++)
        {
            System.out.println("Class"+(i+1)+" list:"+"\n");
            System.out.println("--------------------");
            for(int j=0;j<arr.length;j++)
            {
                 for(int k=0;k<students.size();k++)
                 {
                     if(arr[i][j]==students.get(k).averageGPA())
                     {    
                         students.get(k).print();
                         System.out.println("\n");
                         removeStudent(k);
                     }   
                 }
            }
        }
    }        
   //主方法
    public static void main(String [] args)
    {
        ClassInfo newclass=new ClassInfo();
        Scanner info=new Scanner (System.in);
        System.out.println("Set the number of students:");
        int numberOfStudent=info.nextInt(); 
        newclass.initialInfo(numberOfStudent,newclass);
        System.out.println("Set the number of classes:");
        int number=info.nextInt();
        newclass.print(number,newclass.allocateStudent(number,newclass.bubbleSortStudent()));
        info.close();
    }
}

输出结果：

Set the number of students:
3
Set the student's ID number:
20181201
Set the student's first name:
William
Does student has second name?
y
Set the student's second name:
Jefferson
Set the student's last name:
Smith
Which types of grades you want to input:
    1:rank
    2:score

1
Set the student's rank:
A+
Set the student's xuefen:
6
Does any grade need to be added?
Y
Which types of grades you want to input:
    1:rank
    2:score

2
Set the student's score
88
Set the student's xuefen
5
Does any grade need to be added?
N
Set the student's ID number:
20181145
Set the student's first name:
James
Does student has second name?
n
Set the student's last name:
Bush
Which types of grades you want to input:
    1:rank
    2:score

1
Set the student's rank:
B+
Set the student's xuefen:
5
Does any grade need to be added?
n
Set the student's ID number:
20181219
Set the student's first name:
Mary
Does student has second name?
n
Set the student's last name:
Clinton
Which types of grades you want to input:
    1:rank
    2:score

1
Set the student's rank:
C
Set the student's xuefen:
2
Does any grade need to be added?
n
Set the number of classes:
2
Class1 list:

--------------------
Name:     Mary Clinton
ID:     20181219
GPA:    2


Name:     William Jefferson Smith
ID:     20181201
GPA:    4.27


Class2 list:

--------------------
Name:     James Bush
ID:     20181145
GPA:    3.5

小结

写这篇博客有感于看到的一个知乎问题：一个学校分班的问题，使用Java如果实现？
我把问题简化了，主要利用Arraylist可以追加对象的办法，把所有需要的信息都封装在对象里，以达到分配和后续更改的目的。当然，我的代码并没有处理异常情况以及输入错误的提示(太懒)。面向对象的好处是当需要处理大量复杂个个体时能比较有效的更改所需的个体信息，这个代码还可以继续完善：比如允许更改学生姓名、继续追加单个学生的成绩等等。
Github 源码

weixin_34237596
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java ArrayList 实现实例讲解
09-01
ArrayList是Java集合框架中的一员，它是一个基于数组实现的动态列表。ArrayList的主要特点是其容量能够自动增长，以适应添加更多的元素。在Java中，ArrayList类位于`java.util`包下，它实现了`List`接口，同时也实现...
2.4 面向对象（接口和内部类）
Huonly
10-27 117
1.接口 1.1黑马信息管理系统集合改进 (应用) 使用数组容器的弊端 容器长度是固定的，不能根据添加功能自动增长 没有提供用于赠删改查的方法 优化步骤 创建新的StudentDao类，OtherStudentDao 创建ArrayList集合容器对象 OtherStudentDao中的方法声明，需要跟StudentDao保持一致 注意：如果不一致，StudentService中的代码就需要进行修改 完善方法（添加、删除、修改、查看） 替换StudentService中的Da
Java入门（ArrayList）
Li_CSDN_Li的博客
04-30 559
ArrayList 对象数组 数组：数组是容器，可以存放多个类型一致的数据。数组一旦定义长度不能变化。 特点：元素类型相同，长度不可变。 定义一个数组：类型 数组存储类型[] 数组名; 数组存储类型 数组名[]; 类型可以是任何的类型：基本数据类型，引用数据类型 如果是我们自己定义的类型当作数组的类型：例如Student类型， Student[] students; Student stud...
java 优解分班_java设计一个按班级的分组排序，班级 姓名 学号 成绩 ，再输出每个班90分以上的人数，占比多少。...
weixin_33642922的博客
02-24 908
展开全部一、先编排考场1.首先要做的就是先安排各个班级的每个学生所在的考场，尽量让同一考e69da5e6ba9062616964757a686964616f31333366303762场不能有同班同学。或者是，同一考场出现部分或极少的同班同学。2.比如，一个年级有20个班级，每个班级有50个学生，那么，学生总人数就是1000个人；如果一个考场安排30个学生，那么，每个考场就有30个座位，那么，总的...
java 分班_J 分班(class)(NYIST 2019年校赛)
weixin_31241561的博客
02-12 386
J 分班(class)(NYIST 2019年校赛)内存限制:256MB 时间限制:1s Special Judge: No题目描述:jsb 是 XX 市第一中学的校长。一轮模拟考试结束后，jsb 想让所有学生重新分班。XX 市第一中学共有 n 位学生，其中第 i 个学生的该次模拟考试的成绩为 bi。jsb 打算将所 有学生分配到 m 个班级里，第 i 个班级的人数为 ai，即需要将恰好 ai 个...
按成绩段随机分班算法
caizhong_946400的博客
09-07 4643
/**      * 获取所有学生列表      * @param request      * @author 才中      */     @RequestMapping("/fbUpdate")     public String fbUpdate(HttpServletRequest request){         Map map = new HashMap();   
Java实训之利用Arraylist实现学生管理系统
06-17
在这个实训项目中，“Java实训之利用ArrayList实现学生管理系统”旨在帮助初学者掌握ArrayList的基本操作，并将其应用于实际的管理系统中。 首先，我们需要了解ArrayList的基本特性。ArrayList是一个动态数组，它...
Java进阶--深入理解ArrayList实现原理
01-27
ArrayList是Java集合框架中常用的列表实现之一，它作为动态数组，允许我们在运行时根据需要增加或减少元素。ArrayList继承自AbstractList，并实现了List、RandomAccess、Cloneable和Serializable接口。这意味着...
java 中ArrayList迭代的两种实现方法
08-29
在Java编程语言中，ArrayList是ArrayList类的一个实例，它继承自AbstractList并实现了List接口。ArrayList主要用于存储可变大小的对象数组。当我们需要遍历ArrayList中的元素时，有两种主要的迭代方式：通过`...
ArrayList实现对产品CRUD
05-10
在这个“ArrayList实现对产品CRUD”的项目中，我们将探讨如何利用面向对象编程（OOP）的思想来操作ArrayList，进行创建、读取、更新和删除（通常称为CRUD操作）产品对象。对于初学者来说，这是一个很好的实践案例，...
智能分班系统源代码
08-11
智能分班系统源代码
自动分班源码
08-21
智能分班AutoArrangeClass 随机自动分班级排学号软件 一个朋友在中学教书，经常为排班级排学号头痛，于是做了这么一个小软件让朋友用用，反馈感觉上还不错。 本软件适用于小学升初中只有两科成绩,且成绩只有A,B,C三个标号. 说明一下:该随机自动分班级排学号软件, 不仅有有考虑到,成绩的均匀, 还考虑到生源地(即原毕业学校),性别,及班级学生个数的均匀. 一般来说,每个班级的总体都比较均匀 具体的说明，可以运行一下本软件，点一下生成源文件样本，然后参考一下即可。
java 分班_新生——S型分班算法
weixin_35281210的博客
02-16 1595
package org.zttc.service;public class DistributeClass {public static final Boolean order =true;public static void main(String[] args) {//把分班后数据存入二位数组int test[][] = divideByClass(64,8,order);String str...
基于 python 实现的中小学随机化分班算法（思路、实现、代码以及打包好的可执行文件）
热门推荐
jnxxhzz的博客
09-17 3万+
文章目录1. 代码运行情况2. 需要提供的excel格式3. 最终结果4. 算法实现5. 代码 1. 代码运行情况 ***************************************************** 代码会自动分配所有学生到每个班，并自动生成每个班级的表格 1. 每个班级男女生数量尽可能平均 2. 每个班级每个分段人数尽可能相等 3. 每个班级之间的所有科目平均分尽可能相近 4. 允许对每个人预设班级 * 分班采用
一个java方法根据班级分组_使用jdk1.8实现将list根据指定的值去分组的操作
weixin_31901801的博客
03-01 432
我就废话不多说了，大家还是直接看代码吧~Map> commentList = list.stream().collect(Collectors.groupingBy(CommentQuery::getNewsId));for (Map.Entry> entry : commentList.entrySet()) {String key = HOT_LIST_KEY + entry.ge...
如何做一个新生分班查询系统
yichafen999的博客
07-20 135
就是一个被不少老师选择的制作查分班网站，拿到学生分班情况的表格，然后把表格上传到易查分这个网站里，根据查询条件的设置，就能够智能开发一个分班查询网址，学生家长只需要输入老师设置的查询条件，比如姓名、手机号，就能查到孩子分在了哪个班级，还有的学生没入学，也没班级群，直接张贴纸质二维码，或者在学校官方平台放上个分班查询二维码，而且还能生成二维码，就都可以查询了。查询功能是指学生、家长可以通过系统查询自己所在的班级。在现代化的教育中，分班系统是非常必要的，因为它可以帮助我们更好地管理学生信息，提高教育质量。
java分派_Java基础之Java分派机制
weixin_42489917的博客
02-12 204
Java分派机制在Java中，符合“编译时可知，运行时不可变”这个要求的方法主要是静态方法和私有方法。这 两种方法都不能通过继承或别的方法重写，因此它们适合在类加载时进行解析。Java虚拟机中有四种方法调用指令：invokestatic：调用静态方法。invokespecial：调用实例构造器方法，私有方法和super。invokeinterface：调用接口方法。invokevirtual：调用...
【华为OD机试真题 Java语言】74、 分班问题 | 机试真题+思路参考+代码解析（C卷）（本题100%）
最新发布
KJ.JK，正在火热更新全网最新最全的华为OD题库
08-01 1347
幼儿园两个班的小朋友在排队时混在了一起,每位小朋友都知道自己是否与前面一位小朋友同班，请你帮忙把同班的小朋友找出来。 >  小朋友的编号是整数，与前一位小朋友同班用Y表示，不同班用N表示。 >  学生序号范围(0,999]， 如果输入不合法则打印ERROR。
java实现班级信息存储、删除、修改（使用list篇）
小海同学的博客
05-13 1652
改进一下之前不用list实现的班级信息的储存、删除、修改。 思路： 1.与上篇一样写好基本信息 2.利用list当中的add，remove等实现存储，删除，修改 step 1： 写好基本信息
使用java实现简易的arraylist
07-11
以下是一个简单的示例代码，展示如何使用 Java 实现一个简易的 ArrayList： ```java public class SimpleArrayList<T> { private static final int DEFAULT_CAPACITY = 10; private Object[] elements; private ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值