• 学生选课系统基础版

    目录

    一.Java 中的集合框架（上）

            1.Java中的集合框架概述

            2.Collection接口&接口简介

            3.学生选课——创建学生类和课程类

            4.学生选课——添加课程Ⅰ

            5.学生选课——添加课程Ⅱ

            6.学生选课——课程查询

            7.学生选课——课程修改 

            8.学生选课——课程删除

            9.学生选课——应用泛型管理课程Ⅰ 

            10.学生选课——应用泛型管理课程Ⅱ

             

            11.学生选课——通过Set集合管理课程

    二. Java 中的集合框架（中）

            1.Map&HashMap简介

            2.学生选课——使用Map添加学生

             3.学生选课——删除Map中的学生

            4.学生选课——修改Map中的学生

    三.Java中的集合框架（下）

            1.学生选课——判断list中课程是否存在

            2.学生选课——判断Set中课程是否存在 

            3.学生选课——获取List中课程的位置 

            4.学生选课——判断Map中是否包含指定的key和value 

            5.应用Collections.sort()实现List排序

            6.学生选课——尝试对学生序列排序 

            7.Comparable&Comparator简介

            8.学生选课——实现学生序列排序

    一.Java 中的集合框架（上）
            1.Java中的集合框架概述


    JAVA集合框架体系结构：Collection与Map是两个根接口。
    Collection接口：内部存储的是一个个独立的对象。包含：
    1、List接口：序列，存储元素排列有序且可重复。实现类:ArrayList，数组序列。实现类：LinkedList，链表。
    2、Queue接口：队列，存储元素排列有序且可重复。实现类：LinkedList，链表。
    3、Set接口：集，存储元素无序且不可重复。实现类：HashSet，哈希集。

    Map接口：内部以两个对象（任意类型）为一个映射去存储数据，这一个映射就是Entry类（Map的内部类）的实例。包括：实现类：HashMap，哈希表。


            2.Collection接口&接口简介
    Collection接口是List、Set、Queue接口的父接口
    Collection接口定义了可用于操作List、Set和Queue的方法--增删改查
    List接口及其实现类--ArrayList
    List是元素有序并且可以重复的集合，被称为序列。
    List可以精确的控制每个元素的插入位置，或删除某个位置元素
    List有add()插入方法和get()获取方法
    ArrayList--数组序列，是List的一个重要实现类
    ArrayList底层是由数组实现的，这也是其名字的由来
            3.学生选课——创建学生类和课程类
    public class Student{
     
        public String id;
     
        public String name;
     
        public Set courses;
     
        public Student(String id,String name){
     
            this.id=id;
     
            this.name=name;
     
            this.courses=new HashSet();
     
        }
     
    }

    学生的可选择的课程信息 存放在Set类型的属性courses中 
    在构造器中 将courses进行初始化（实例化）this.courses=new HashSet()；因为Set是一个接口，所以不能直接实例化，通过HashSet这个实现类来进行实例化 ,需要导入包
    在实际开发中，应该把所有的属性都私有化，然后通过get 和 set 来访问属性。
    学生的可选择的课程信息 存放在Set类型的属性courses中 
    在构造器中 将courses进行初始化（实例化）this.courses=new HashSet()；因为Set是一个接口，所以不能直接实例化，通过HashSet这个实现类来进行实例化 ,需要导入包
    在实际开发中，应该把所有的属性都私有化，然后通过getter 和 setter 来访问属性。
    实际开发中，类的属性应该私有化
            4.学生选课——添加课程Ⅰ


    （1）
    对象被存入集合都变成object类型了 取出时需要类型强转
    例：Course temp = (Course)coursesToSelect.get(0);
    （2）
    添加进list中的位置（index）介于【0，length】之间；0代表插到队头，length代表插到队尾。
    （3）
    List是接口，所以在构造方法中不能直接实例化，而通过ArrayList()实例化！！！
    例：public List coursesToSelect = new ArrayList();
    （4）
    List、Set、Map都是接口 不可以直接对他实例化 要借助相应的实例化类 ArrayList(), HashSet(),HashMap();
    （5）
    调用Add()方法添加到List中。有两种方法：
    1. 直接添加，例：CoursesToSelect.add(cr1);
    2. 可以指定添加的位置，例：CoursesToSelect.add(0,cr1);
    （6）
    如果添加到List中的长度大于他目前的长度，则系统会出现异常，即数组下表越界异常

            5.学生选课——添加课程Ⅱ
    list中还有addAll(List list)
    就是将一个List里面的元素一股脑的全都加进去，
    一般定义一个数组，如何把一个数组转换成List？ 调用方法Arrays.asList(Object[] obs);
    //可以将一个数组转换为一个List，然后可以将这个元素传进addAll()里面
    当然还有addAll（index,List list）方法
    removeAll直接传入一个list，同理
    记得取出东西之后，要类型强转哦！！！因为取出来都是Object的。
    向List中添加元素的几种方法：
    新建List类
    public List courseToSelect;
    初始化List类
    public ListTest()
    {
    this.courseToSelect=new ArrayList();
    }
    向List中添加数据
    method_1
    courseToSelect.add(对象1);
    method_2
    courseToSelect.add(位置,对象2);
    method_3
    courseToSelect.addAll(Arrays.asList(数组_对象3));
    method_4
    courseToSelect.addAll(位置,Arrays.asList(数组_对象4));
    获取
    Course temp=(Course)courseToSelect.get(位置);

            6.学生选课——课程查询
    以下三种方法都是用来取出List中元素的方法：
    -----for循环-----
    public void testGet(){
    int size=coursesToSelect.size();
    for(int i=0;i
    Course cr=(Course) coursesToSelect.get(i);
    System.out.println("取出的课程："+cr.getId()+":"+cr.getName());
    }
    }
    -----迭代器-----
    Iterator是一个接口,依赖于集合存在的
    Iterator it=courseToSelect.iterator();
    while(it.hasNext()){
    Course cr=(Course) it.next();
    System.out.println("课程:" + cr.id + ":" + cr.name);
    }

    -----for each(增强for循环)-----

    凡是继承了Iterable接口的类所生成的对象都可以用for/each循环

    for(Object obj:coursesToSelect){//遍历集合中的每一个元素，作为每一个Object变量
    Course cr=(Course) obj;
    System.out.println("课程:" + cr.id + ":" + cr.name);
    }

            7.学生选课——课程修改 
    使用set（index,Object element）修改元素，index表示索引位置，element表示新对象。
    修改List的元素
    public void testModify(){
    coursesToSelect.set(4,new Course("7","毛概"));
    }
    public List a = new ArrayList();    //创建List
     
    a.add(index,object);                    //j将元素添加到List的第index+1位置
     
    a.get(index);                                //获取List的第index+1位置的元素
     
    a.set(index,object)                      //更新List的第index+1位置的元素
     
    a.remove(index,object)              //删除List的第index+1位置的元素
            8.学生选课——课程删除
    (删除元素)List中有remove(index),remove(对象值)和removeAll(Arrays.asList(对象数组名))方法来删除容器中元素的值(用法和add类似).
    Course是信息课程类，有id和name属性。courseToSelect是list的序列容器对象。
    1.remove(index);删除位置要大于0并且小于List(序列容器)的长度。如果要删除全部可以用for循环嵌套此方法。
    2.remove(object);先要获得删除的值，用法是先定义一个信息变量通过get()来存放要删除的值,然后用remove(删除的对象值);
    public void textdelect{
    Course cr=(Course)(courseToSelect.get(4));
    courseToSelect.remove(cr);//通过remove(对象值);
    或者 courseToSelect.remove(4);//通过remove(删除位置);  }
    3.removeAll(Arrays.asList());要删除指定的多个位置  Arrays.asLIst(对象数组名);作用是把数组转换为集合
    用法是先创建信息对象数组存放删除元素的值，然后再用removeAll(Arrays.asList(对象数组名))方法,删除集合数组的元素。
    public void textdelext2{
    Course []course={(Course)(courseToSelect.get(4)),(Course)(courseToSelect.get(5))};  // 定义数组存放要删除的值
    courseToSelect.removeAll(Arrays.asList(course));  // 删除4和5位置的值  }


            9.学生选课——应用泛型管理课程Ⅰ 
    泛型<>;规定List定义的容器只能存储某种类型的元素。不用泛型的话是什么类型的元素都可以插入，因为插入集合是忽略其类型，把它看成为Object类型，取出时需要强行转换对应的类型。
    编写带有泛型的集合
    List courseToSelect;  
    在构造方法中(实例化的时候也可以不在构造方法，直接实例就可以)
    this.courseToSelect=new ArrayList();   //带有泛型-Course的List类型属性就创建了
    泛型集合中，不能添加泛型规定的类型以及其子类型以外的对象，否则会报错。
    运用了泛型的话，用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),不必再用Object取出再强转，因为已经规定容器里装的都是Course类型。


            10.学生选课——应用泛型管理课程Ⅱ
    子类要调用父类的隐式构造器，但父类如果有含参构造器，则不会自动生成一个无参构造器，需要手动添加无参构造器。


             
    总结关于list类型的一下用法：
    1.创建对象
    List list = new ArrayList();
    2.向list对象中添加数据
    （1）Course crre = new Course("1","数据结构");//一个类的对象
    list.add(crre);//将对象添加到list中
    （2）Course[] crre = {new Course("",""),new Course("","");//对象的数组
    list.addAll(0,Arrays.asList(course));//切记Arrays.asList方法
    3.获取集合中的元素
    （1）Course temp = (Course)list.get(0);//注意强转
    （2）Iterator it = list.iterator();
    while(it.hasNext()){
    Course cr = (Course)it.next();//迭代遍历，使用iterator方法
    }
    （3）for(Object obj:list){
    Course cr = (Course)obj;
    }//foreach方法 ，注意Object的使用
    4.集合中参数的修改
    list.set(2,new Course("",""));
    5.集合中数据的删除
    (1)list.remove(位置）;
    (2)Course[] crr = {(Course)list.get(位置）(Course)list.get(位置）}；
    list.removeAll(Arrays.asList(crr));//参考addAll
    6.带有泛型的list
    List course = new ArrayList();//相当于添加进去的元素有了具体类型，不再是Object
    7.list可以添加子类型的对象
    8.list不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类

            11.学生选课——通过Set集合管理课程
    Set接口及其实现类——HashSet

    Set是元素无序并且不可以重复的集合，被称为集；

    HashSet——哈希集，是Set的一个重要实现类。

    1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。

    2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。

    3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。

    4、Set还可以添加null；无序演示（如图）


    二. Java 中的集合框架（中）
            1.Map&HashMap简介
    1. Map接口提供了一中映射关系，其中的元素是键值对（key-value）的形式存储的，能够实现根据Key快速查找value。Key-value可以是任何对象，是以Entry类型的对象实例存在的。
    2.Key是不可以重复的，Value是可以重复的。Key-value都可以为null，不过只能有一个key是null。
    3.map支持泛型，Map
    4.每个键最多只能映射到一个值
    5.Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
    6.通过put,remove操作数据
    7.HashMap中的Entry对象是无序排列的，HashMap是Map的一个重要实现类，也是最常用的


            2.学生选课——使用Map添加学生
    Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
    Map支持泛型，形式如：Map
    HashMap类
    HashMap是Map中的一个重要的实现类，也是最常用的，给予哈希表实现
    HashMap中的Entry对象是无序排列的
    Key值和Value值都可以为Null，但是一个HashMap只能有一个key值为Null的映射（key值不可重复）

    student.get(ID)是采用Map的get（）方法，检测是否存在值为ID的学生，如果没有，则返回null.

    keySet()方法，返回所有键的Set集合。
    取得Map的容量可用size()方法。

    keyset()返回Map中所有的key以集合的形式可用Set集合接收，HashMap当中的映射是无序的。
    students.get(ID)是采用Map的get()方法
    import java.util.Map;
    public class MapTest{
    //用来承装学生类型对象
    public Map students;
    //构造器中初始化students；
    public MapTest(){
    this.students=new HashMap();}
    /**测试添加：输入学生ID，判断是否被占用
    若有被占用，则输入姓名，创建心学生对象，并且
    添加到student中*/
    public void tsetPut(){
    //创建一个Scanner对象，用来获取输入的学生ID和姓名
    Scanner console=new Scanner(System.in);
    int i=0;
    while(i<3){
    System.out.println("请输入学生ID");
    String ID=console.next();
    //判断该ID是否被占用
    Student st=student.get(ID);
    if(st==null){
    //提示输入学生姓名
    System.out.println("请输入学生姓名");
    String name=console.next();
    //创建新的学生对象
    Student newStudent=new Student(ID,name);
    //通过调用students的put方法，添加ID-学生映射
    student.put(ID,newStudent);
    System.out.println("成功添加学生："+students.get(ID).name);
    i++;
    else{
    System.out.println("该学生ID已被占用！");
    continue;}}}}
    //测试Map的keySet方法
    public void testKeySet(){
    //通过keySet方法，返回Map中的所有“键”的Set集合
    Set keySet=students.keySet();
    //取得students的容量
    System.out.pritnln("总共有："+students.size()+"个体学生");
    //遍历keySet，取得每一个键，再调用get（）方法取得每个键对应的value
    for(String stuId:keySet){
    Student st=students.get(stuId);
    if(st!=null)
    System.out.println("学生："+st.name);
    }
    }
    public static void main(String args){
    MapTest mt=new MapTest();
    mt.testPut();
    mt.testKeySet();
    }}

             3.学生选课——删除Map中的学生
    Map增删改查：
    增：map的put(key,value)方法添加。
    查：1.利用keyset()方法获得Map中key的集合，再遍历key的集合，利用Map的get(key)方法得到key对应的value值。
    2.利用EntrySet方法获取May中Entry对象集：然后用foreach遍历集，再用Entry集的getkay()和getvalue()方法得到每一个key值和value值。
    删：remove(object key)
    改：put(原有的key,新的value)
    通过entrySet可以返回Map中的所有键值对
    Set>entrySet = students.entrySet();
    //测试删除Map中的映射
    public void testRemove(){
    //获取从键盘输入的待删除学生ID字符串
    Scanner console=new Scanner(System.in);
    while(true){
    //提示输入待删除的学生ID
    System.out.println("请输入要删除的学生ID！");
    String ID=console.next();
    //判断该ID是否有对应的学生对象
    Student st=students.get(ID);
    if(st==null){
    //提示输入的ID并不存在
    System.out.println("该ID不存在！");
    continue;}
    students.remove(ID);
    System.out.println("成功删除学生："+st.name);
    break;}}
    //通过entrySet方法遍历Map
    public void testEntrySet(){
    //通过entrySet方法，返回Map中的所有键值对
    Set >entrySet=students.entrySet();
    for(Entryentry:entrySet){
    System.out.println("取得键："+entry.getKey());
    System.out.println("对应的值为："+entry.getValue().name);}
    }
    //main方法中调用
    mt.testRemove();
    mt.testEntrySet();

            4.学生选课——修改Map中的学生
    关于Map:
    1.初始化变量
    Mapstudents = new HashMap()
    //初始化key值为String,存放的数据类型为student的students集合
    2.put()增加对象
    Student newStu = new Student(ID,name);
    students.put(ID,newStudent);//以ID作为key值
    3.查找对象
    （1）SetkeySet = students.keySet();
    for(String stuId：keySet){
    Student st =students.get(stuId);
    }//先用keySet()获取所有的key,再遍历获取每一个对象
    （2）Set>entrySet = students.entrySet();//由于每个键值对都以entry类型存放，yongentrySet（）方法获取所有键值对
    for(Entryentry:entrySet) {//遍历获取键值对
    entry.getKey();//获取key
    entry.getValue();//获取value
    }
    4.删除
    students.remove(ID);//根据key的值删除
    5.修改
    Student stu = students.get(ID);
    Student newStudent =new Student(ID,newname);
    students.put(ID,newStudent);
    /*Map中没有直接修改的方法，所以采用先找出对象，然后不修改key值，只修改value的方法进行修改*/

    //利用put方法修改Map中的已有映射
    public void testModify(){
    //提示要输入要修改的学生ID
    System.out.println("请输入要修改的学生ID：");
    //创建一个Scanner对象，去获取从键盘上输入的学生ID字符串
    Scanner console=new Scanner(System.in);
            

    三.Java中的集合框架（下）
            1.学生选课——判断list中课程是否存在
    "=="和equals()的区别：
    　1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
    　　　　如果作用于引用类型的变量，则比较的是所指向的对象的地址
    　　2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量
    　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
    　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
    @Override
    public boolean equals(Object obj){
       //如果obj与比较对象的位置相同，说明obj是从集合中取出再与该位置的元素比较，所以肯定相同
         if(this==obj)
        return true;
         if(obj==null){//若字符串为空，则不能进行字符串比较，所以返回false
        return false;
         if(!(obj instanceof Course)){//若果obj当前类型不是Course，则当前两个对象肯定不相同
          //instanceof 它的作用是判断其左边对象是否为其右边类的实例
            return false;
            //若上述均通过，则说明obj为Course对象，且当前对象不为空
        Course course=(Course)obj;
        if(this.name==null){
        if(course.name==null)
           return true;
        else
           return false;
       }else{
        if(this.name.equals(course.name))
           return true;
        else
           return false;
        }
    }

            2.学生选课——判断Set中课程是否存在 
    使用set中的contains方法，set中调用contains（obj）方法，contains方法的实现机制：先调用object中的hashcode方法，再调用object中的equals方法。所以要对对象的hashcode（）方法和equals方法重写，可以使用eclipse中的source>GENARATE hashcode（），在对象的类中，实现方法的重写。
    @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((id == null) ? 0 : id.hashCode());
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
     
    public void testsetcontains(){
            System.out.println("请输入课程名称：");
            Scanner nnew = new Scanner(System.in);
            String name = nnew.next();
            Course course2 = new Course();
            course2.name = name;（此时只定义了name属性，id属性没有定义！！所以重写hashCode（）时候不能把id选住）
            System.out.println("创建新课程："+ course2.name);
            System.out.println("备选课程中是否包括上面的课程" + course2.name+","+ student.courses
                    .contains(course2));
        }

            3.学生选课——获取List中课程的位置 
    indexOf()方法与lastIndexOf()方法实现原理：
    1、遍历调用每个元素的equals()方法，如果返回true则将次元素的索引返回；
    2、如果有多个相同元素，则只返回第一个元素的索引；
    3、lastIndexOf()方法则从最后一个元素开始遍历；


            4.学生选课——判断Map中是否包含指定的key和value 
    Map中通过containsKey()方法和containsValue()方法来判断键和值是否存在
    Map 中对对象进行了 Key 标记，通过 get（Key）可以取得对应的对象
    Map 的containsValue（）方法的参数是 Object 对象，因为Map 的 Value 值是对象元素
    Map 的containsKey（）方法取得 Map 映射的 Key 值
    List中的contains()方法借Map中的containsValue()方法调用equals()方法来进行比较。所以要重写Hashcode和equals方法
    跟 List 的 contains（）方法一样，Map 中的 containsValue（）方法也会调用每个 Value 值的 equals（）方法去和参数对象比较

    id 是string类型 contains方法使用equals方法 来比较，所以值相等就返回ture
    Value 是Student类型，自己定义的，默认的contains方法中的equals方法，比较的是两个引用是否一样，所以要重写equals方法
    由于是比较两student类型是否相同，所以要做Student类中重写equals方法
    public static void main(String[] args){
    MapTest mt = new MapTest();
    mt.testPut();
    mt.testKeySet();
    mt.testModify();
    mt.testEntrySet();
    }
    public void testContainsKeyOrValue(){
    System.out.println("请输入要查询的学生ID");
    Scanner console = new Scanner(System.in);
    String id = console.next();
    System.out.println("您输入的学生ID为："+id+"，在学生映射表中是否存在："+students.containsKey(id));
    if(students.containsKey(id))
    System.out.println("对应的学生为："+students.get(id).name);
    }

            5.应用Collections.sort()实现List排序
    public String testRandomString(){
            StringBuilder stringBuilder = new StringBuilder();
            //存放所包含字符62位
            String container = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            Random random = new Random();
            int num = 0;
            while(num == 0){
                num = random.nextInt(10);
            }
            for(int i = 0; i < num; i++){
                int index = random.nextInt(61);
                stringBuilder.append(container.charAt(index));
            }
            return stringBuilder.toString();
        }

            6.学生选课——尝试对学生序列排序 
    collection.sort（）方法对元素进行排序，列表中的元素都必需实现 Comparable 接口，否则不能使用 sort（）方法排序


    package com.imooc_b;
     
     
     
    import java.util.ArrayList;
     
    import java.util.Collections;
     
    import java.util.List;
     
    import java.util.Random;
     
     
     
    public class CollectionsTset {
     
    public void Sort() {
     
    List listTset = new ArrayList();
     
    Random random = new Random();
     
    // 生成十条不重复的字符串(由数字和字母组成)
     
    for (int i = 0; i < 10; i++) {
     
    StringBuffer buffer = new StringBuffer();
     
    do {
     
    // 字符串长度为10以内的整数,nextInt()范围为(0,9)，字符串长度不想设置为空就加1
     
    int k = random.nextInt(9) + 1;
     
    // 随机生成字符串
     
    for (int j = 0; j < k; j++) {
     
    int b;
     
    do {
     
    // 随机生成0到122的数字，0到9表示数字字符，65到90表示'A'到'Z'
     
    // 97到122表示'a'到'z'
     
    b = (int) (Math.random() * 123);
     
    }
     
    // 当生成的字符为'0'到'9'或'a'到'z'或'A'到'Z'时跳出
     
    while (!((b >= 0 && b <= 9) || (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')));
     
    if (b >= 0 && b <= 9) {
     
    String in = Integer.toString(b);
     
    buffer.append(in);
     
    } else {
     
    char ch = (char) b;
     
    String in = String.valueOf(ch);
     
    buffer.append(in);
     
    }
     
    }
     
    } while (listTset.contains(buffer.toString()));
     
    // 如果list没有该字符串就加入
     
    listTset.add(buffer.toString());
     
    }
     
     
     
    System.out.println("-------排序前----------");
     
    for (String string : listTset) {
     
    System.out.println("元素：" + string);
     
    }
     
    Collections.sort(listTset);
     
    System.out.println("---------排序后---------");
     
    for (String string : listTset) {
     
    System.out.println("元素：" + string);
     
    }
     
     
     
    }
     
     
     
    public static void main(String[] args) {
     
    CollectionsTset ct = new CollectionsTset();
     
    ct.Sort();
     
     
     
    }
     
     
     
    }
     

            7.Comparable&Comparator简介
    一、compareable 是默认比较规则， comparator是临时比较规则
    1.Comparable接口------可比较的
    实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
    定义了默认的比较规则
    其实现类需实现compareTo()方法
    comparaTo()方法返回正数表示大，负数表示小，0表示相等
    2.Comparator接口-----比较工具接口
    用于定义临时比较规则，而不是默认比较规则
    其实现类需要实现compare()方法
    Comparator和Comparable都是Java集合框架的成员

    compareable 需要实现compare to方法， comparator需要实现 compare方法

    三、Java集合框架：
    Collection接口，Map接口，Collections工具类，Comparable接口，Comparator接口
            8.学生选课——实现学生序列排序
    让没有默认比较规则的类进行比较的方法
    一、让该类实现Comparable接口：
    1、在该类中加上implements Comparable<类名>。
    2、实现.compareTo(类名 对象名)方法，若this较大则返回正值，若相等则返回0，若this较小则返回负值。（各种类都包含.compareTo()方法）
    3、调用Collections.sort（对象名）进行排序。
    二、让该类实现Comparator接口：
    1、新建一个类加上implements Comparator<类名>
    2、实现.compare(类名 对象名1，类名，对象名2)方法，若this较大则返回正值，若相等则返回0，若this较小则返回负值。
    3、调用Collections.sort（对象名，实现Comparator<类名>接口的对象名）方法。（因此要重建一个类来实现Comparator接口！！）

    字符串大小比较方式：分别将每一个字符串的每一位进行比较，0-9>A-Z>a-z。
    public class CollectionSort { 
     public void sort3(){
             
          List studentList = new ArrayList();
          List i = new ArrayList();
          Random r = new Random();
          int n;
           
          for(int j=0;j<3;j++){
              
              do{
                  n = r.nextInt(1000);
              }while(i.contains(n));
              i.add(n);
               
          }
           
           
          studentList.add(new Student(i.get(0).toString(),"小明"));
          studentList.add(new Student(i.get(1).toString(),"小红"));
          studentList.add(new Student(i.get(2).toString(),"小刚"));
          System.out.println("---------排序前----------");
          for (Student student : studentList) {
            System.out.println("学生："+student.id+"."+student.name);
        } 
          Collections.sort(studentList);
          System.out.println("---------排序后----------");
         for (Student student : studentList) {
               System.out.println("学生："+student.id+"."+student.name);
           }
       }
          
     
    }

  • 相关阅读:
    Java单例模式的完整实现，从0到1带你一步步优化
    OpenSSH升级版本（7.4升级到8.9）
    C#/.Net的多播委托到底是啥？彻底剖析下
    论文解读（CosFace）《CosFace: Large Margin Cosine Loss for Deep Face Recognition》
    Spring面试题19：说一说Spring注解？什么是基于Java的Spring注解配置？什么是基于注解的容器配置？
    [python 刷题] 242 Valid Anagram
    torchvision.transforms 数据预处理：ToTensor()
    0时区格林威治时间转换手机当地时间-Android
    mybatis配置文件模板及常用标签介绍说明
    ES报错 Unable to parse response body for Response
  • 原文地址：https://blog.csdn.net/m0_74422518/article/details/133247272