java自学笔记12：java中的集合框架（下）List

最新推荐文章于 2022-09-06 18:33:31 发布

众拾达人

最新推荐文章于 2022-09-06 18:33:31 发布

阅读量210

点赞数

分类专栏： java基础文章标签： java List 框架

本文链接：https://blog.csdn.net/wtdask/article/details/78739186

版权

java基础专栏收录该内容

30 篇文章 0 订阅

订阅专栏

一.学生选课—判断List中课程是否存在

这里写图片描述

思考
：在课程序列中，如何判断是否包含某门或者某几门课程？
：如果课程序列包含某门课程，如何判断该课程的索引位置？
：在学生映射表中，如何判断是否包含某个学生ID？
：又该如何判断是否包含某个学生对象？
：如果想把课程或者学生对象，按照课程名称或者学生姓名排序又该怎么办？按照ID排序呢？
这里写图片描述

SetTest类代码示例：

package com.vishuo.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class SetTest {

    public List<Course> coursesToSelect;

    private Scanner console;

    public SetTest(){
        coursesToSelect = new ArrayList<Course>();
        console = new Scanner(System.in);
    }


    public void testAdd() {
        // 创建一个课程对象，并通过调用add方法，添加到备选课程List中
        Course cr1 = new Course("1", "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);// 对象存入集合都变成object类型，取出时需要类型转换
        ;
//      System.out.println("添加了课程：" + temp.id + ":" + temp.name);

        Course cr2 = new Course("2", "C语言");
        coursesToSelect.add(0, cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
//      System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);

//      coursesToSelect.add(cr1);
//      Course temp0 = (Course) coursesToSelect.get(2);// 对象存入集合都变成object类型，取出时需要类型转换
//      ;
//      System.out.println("添加了课程：" + temp0.id + ":" + temp0.name);

        /**
         * Course cr3 = new Course("3", "test"); coursesToSelect.add(4,cr3);
         * 会报数组下标越界异常
         * 
         * 添加了课程：1:数据结构Exception in thread "main" 添加了课程：2:C语音
         * java.lang.IndexOutOfBoundsException: Index: 4, Size: 2 at
         * java.util.ArrayList.rangeCheckForAdd(ArrayList.java:661) at
         * java.util.ArrayList.add(ArrayList.java:473) at
         * com.vishuo.collection.ListTest.testAdd(ListTest.java:35) at
         * com.vishuo.collection.ListTest.main(ListTest.java:41)
         */

        Course[] coures = { new Course("3", "离散数学"), new Course("4", "汇编语音") };
        coursesToSelect.addAll(Arrays.asList(coures));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
//      System.out.println("添加了两门课程：" + temp3.id + ":" + temp3.name + ";" + temp4.id + ":" + temp4.name);

        Course[] course2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
        coursesToSelect.addAll(2, Arrays.asList(course2));

        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
//      System.out.println("添加了两门课程：" + temp5.id + ":" + temp5.name + ";" + temp6.id + ":" + temp6.name);

    }

    /*
     * 通过for each 方法访问集合元素
     */
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问):");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }

    /*
     * 测试List的contains方法
     * */
    public void testListContains(){
        //取得备选课程序列的第0个元素
        Course course = coursesToSelect.get(1);
        //打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程："+course.name);
        System.out.println("备选课程中是否包含课程："+course.name+","+coursesToSelect.contains(course));
        //提示输入课程名称
        System.out.println("请输入课程名称：");
        String name = console.next();
        //创建一个新的课程对象，ID和名称，与course对象完全一样
        Course course2 = new Course();
        course2.name = name;

        System.out.println("新创建课程："+course2.name);
        System.out.println("备选课程中是否包含课程："+course2.name+","+coursesToSelect.contains(course2));
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SetTest st = new SetTest();
        st.testAdd();
        st.testListContains();
//        st.testForEach();
//        //创建一个学生对象
//        Student student = new Student("1","小敏");
//        System.out.println("欢迎学生："+student.name+"选课！");
//        //创建一个Scanner对象，用来接收从键盘输入的课程ID
//        Scanner console = new Scanner(System.in);
//        
//        for(int i = 0;i<3;i++){
//          System.out.println("请输入课程ID");
//          String courseId = console.next();
//          for(Course cr: st.coursesToSelect){
//              if(cr.id.equals(courseId)){
//                  student.courses.add(cr);
//                  /*
//                   * Set中，添加某个对象，无论添加多少次
//                   * 最终只会保留一个该对象（的引用）
//                   * 并且，保留的是第一次添加的哪一个
//                   */
                    student.courses.add(cr);
//              }
//          }
//        }
//        st.testForEachForsET(student);
    }

    public void testForEachForsET(Student student){
        //打印输出，学生所选的课程！
        System.out.println("共选择了：" + student.courses.size() +"门课程");
        for(Course cr:student.courses){
            System.out.println("选择了课程：" +cr.id +":"+cr.name);
        }
    }
}

这里写图片描述

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

Course类重写hashCode和equals方法，可通过编辑器直接生成
这里写图片描述

package com.vishuo.collection;

/*
 * 课程类：在实际开发中，要实现属性的私有化，通过setter和getter方法进行访问
 * */
public class Course {

    public String id;
    public String name;

    public Course(String id, String name) {
        this.id = id;

        this.name = name;
    }

    public Course() {

    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Course))
            return false;
        Course other = (Course) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

SetTest类修改如下：

package com.vishuo.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class SetTest {

    public List<Course> coursesToSelect;

    private Scanner console;

    public Student student;

    public SetTest() {
        coursesToSelect = new ArrayList<Course>();
        console = new Scanner(System.in);
    }

    public void testAdd() {
        // 创建一个课程对象，并通过调用add方法，添加到备选课程List中
        Course cr1 = new Course("1", "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);// 对象存入集合都变成object类型，取出时需要类型转换
        ;
        // System.out.println("添加了课程：" + temp.id + ":" + temp.name);

        Course cr2 = new Course("2", "C语言");
        coursesToSelect.add(0, cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        // System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);

        // coursesToSelect.add(cr1);
        // Course temp0 = (Course) coursesToSelect.get(2);//
        // 对象存入集合都变成object类型，取出时需要类型转换
        // ;
        // System.out.println("添加了课程：" + temp0.id + ":" + temp0.name);

        /**
         * Course cr3 = new Course("3", "test"); coursesToSelect.add(4,cr3);
         * 会报数组下标越界异常
         * 
         * 添加了课程：1:数据结构Exception in thread "main" 添加了课程：2:C语音
         * java.lang.IndexOutOfBoundsException: Index: 4, Size: 2 at
         * java.util.ArrayList.rangeCheckForAdd(ArrayList.java:661) at
         * java.util.ArrayList.add(ArrayList.java:473) at
         * com.vishuo.collection.ListTest.testAdd(ListTest.java:35) at
         * com.vishuo.collection.ListTest.main(ListTest.java:41)
         */

        Course[] coures = { new Course("3", "离散数学"), new Course("4", "汇编语音") };
        coursesToSelect.addAll(Arrays.asList(coures));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        // System.out.println("添加了两门课程：" + temp3.id + ":" + temp3.name + ";" +
        // temp4.id + ":" + temp4.name);

        Course[] course2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
        coursesToSelect.addAll(2, Arrays.asList(course2));

        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        // System.out.println("添加了两门课程：" + temp5.id + ":" + temp5.name + ";" +
        // temp6.id + ":" + temp6.name);

    }

    /*
     * 通过for each 方法访问集合元素
     */
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问):");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }

    /*
     * 测试List的contains方法
     */
    public void testListContains() {
        // 取得备选课程序列的第0个元素
        Course course = coursesToSelect.get(1);
        // 打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程：" + course.name);
        System.out.println("备选课程中是否包含课程：" + course.name + "," + coursesToSelect.contains(course));
        // 提示输入课程名称
        System.out.println("请输入课程名称：");
        String name = console.next();
        // 创建一个新的课程对象，ID和名称，与course对象完全一样
        Course course2 = new Course();
        course2.name = name;

        System.out.println("新创建课程：" + course2.name);
        System.out.println("备选课程中是否包含课程：" + course2.name + "," + coursesToSelect.contains(course2));
    }

    // 创建学生对象并选课
    public void createStudentAndSelectCours() {
        // 创建一个学生对象
        student = new Student("1", "小敏");
        System.out.println("欢迎学生：" + student.name + "选课！");
        // 创建一个Scanner对象，用来接收从键盘输入的课程ID
        Scanner console = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            System.out.println("请输入课程ID");
            String courseId = console.next();
            for (Course cr : coursesToSelect) {
                if (cr.id.equals(courseId)) {
                    student.courses.add(cr);
                    /*
                     * Set中，添加某个对象，无论添加多少次 最终只会保留一个该对象（的引用） 并且，保留的是第一次添加的哪一个
                     */
                    // student.courses.add(cr);
                }
            }
        }
    }

    /*
     * 测试Set的contains方法
     */
    public void testSetContains() {
        // 提示输入课程名称
        System.out.println("请输入学生已选的课程名称：");
        String name = console.next();
        // 创建一个新的课程对象，ID和名称，与course对象完全一样
        Course course2 = new Course();
        course2.name = name; 
        System.out.println("新创建课程：" + course2.name);
        System.out.println("备选课程中是否包含课程：" + course2.name + "," + student.courses.contains(course2));
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SetTest st = new SetTest();
        st.testAdd();
//      st.testListContains();
         st.testForEach();
        // st.testForEachForsET(student);

        st.createStudentAndSelectCours();
        st.testSetContains();
    }

    public void testForEachForsET(Student student) {
        // 打印输出，学生所选的课程！
        System.out.println("共选择了：" + student.courses.size() + "门课程");
        for (Course cr : student.courses) {
            System.out.println("选择了课程：" + cr.id + ":" + cr.name);
        }
    }
}

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

如果课程序列包含某门课程，如何判断该课程的索引位置？

这里写图片描述

//通过indexOf方法来取得某元素的索引位置
        if(coursesToSelect.contains(course2))
            System.out.println("课程："+course2.name+"的索引位置为："+coursesToSelect.indexOf(course2));

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

使用MapTest类进行示例：

package com.vishuo.collection;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class MapTest {

    /*
     * 用来承装学生类型对象
     */
    public Map<String, Student> students;
    private Scanner console;

    /*
     * 在构造器中初始化students属性
     */
    public MapTest() {
        this.students = new HashMap<String, Student>();
    }

    /*
     * 测试添加：输入学生ID，判断是否被占用 若未被占用，则输入姓名，创建新学生对象，并且添加到student中
     */
    public void testPut() {
        console = new Scanner(System.in);

        int i = 0;
        while (i < 3) {
            System.out.println("请输入学生ID：");
            String ID = console.next();
            // 判断该ID是否被占用
            Student st = students.get(ID);
            if (st == null) {
                // 提示输入学生姓名
                System.out.println("请输入学生姓名：");
                String name = console.next();
                // 创建新的学生对象
                Student newStudent = new Student(ID, name);
                // 通过调用students的put方法，添加ID-学生映射
                students.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<String> keySet = students.keySet();
        //取得students的容量
        System.out.println("总共有："+students.size()+"个学生");
        //遍历keySet，取得每一个键，再调用get方法取得每个键对应的value
        for(String stuId:keySet){
            Student st = students.get(stuId);
            if(st != null){
                System.out.println("学生:"+st.name);
            }
        }
    }

    /*
     * 测试删除Map中的映射
     */
    public void testRemove() {

        // 获取从键盘上输入的待删除学生ID字符串
        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<Entry<String,Student>> entrySet  =students.entrySet();
        for(Entry<String,Student> entry:entrySet){
            System.out.println("取得键:"+entry.getKey());
            System.out.println("对应的值为："+entry.getValue().name);
        }
    }

    /*
     * 利用put方法修改Map中的映射
     */
    public void testModify(){
      //提示输入要修改的学生ID
        System.out.println("请输入要修改的学生ID：");
        //创建一个Scanner对象，去获取从键盘上输入的学生ID字符串
        console = new Scanner(System.in);
        while(true){
            //取得从键盘输入的学生ID
            String stuID = console.next();
            //从students中查找该学生ID对应的学生对象
            Student student = students.get(stuID);
            if(student ==null){
                System.out.println("该ID不存在！请重新输入");
                continue;
            }
            //提示当前对应的学生对象的姓名
            System.out.println("当前该学生ID,所对应的学生为:"+student.name);
            //提示输入新的学生姓名，来修改已有的映射
            System.out.println("请输入新的学生姓名：");
            String name = console.next();
            Student newSudent = new Student(stuID,name);
            students.put(stuID, newSudent);
            System.out.println("修改成功！");
            break;
        }
    }

    /*
     * 测试Map中，是否包含某个key值或某个Value值
     * 
     * */
    public void testContainsKeyOarValue(){
        //提示输入学生id
        System.out.println("请输入要查询的学生ID：");
        Scanner console = new Scanner(System.in);
        String id =console.next();

        //在Map中，用containsKey（）方法，来判断是否包含某个key值
        System.out.println("您输入的学生ID为："+id+",在学生映射表中是否存在:"+students.containsKey(id));
        if(students.containsKey(id))
            System.out.println("对应的学生为："+students.get(id).name);

        //提示输入学生姓名
        System.out.println("请输入要查询的学生姓名");
        String name = console.next();
        //用containsValue（）方法，来判断是否包含某个Value值
        if(students.containsValue(new Student(null, name)))
            System.out.println("在学生映射表中，确实包含学生："+name);
        else
            System.out.println("在学生映射表中不存在该学生的！");
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
         MapTest mt =new MapTest();
         mt.testPut();
         mt.testKeySet();
//         mt.testRemove();
//         mt.testEntrySet();
//         mt.testModify();
//         mt.testEntrySet();
         mt.testContainsKeyOarValue();
    }

}

注意，也同时需要在Student学生类当中，重写equals和hashCode

package com.vishuo.collection;

import java.util.HashSet;
import java.util.Set;//Set和List一样，都是Collection的子接口

/*
 * 学生类
 * 
 * */
public class Student {
  public String id;
  public String name;

  public Set<Course> courses;

  public Student(String id,String name){
      this.id = id;
      this.name = name;
      //实例化
      this.courses  =new HashSet<Course>();
  }

/* (non-Javadoc)
 * @see java.lang.Object#hashCode()
 */
@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}

/* (non-Javadoc)
 * @see java.lang.Object#equals(java.lang.Object)
 */
@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (!(obj instanceof Student))
        return false;
    Student other = (Student) obj;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}
}

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

Arrays类
java.util.Arrays:包含操作数组的各种静态方法

Collections工具类：
java.util.Collections:是java集合框架中，用来操作集合对象的工具类，也是java集合框架的成员
sort()(排序)方法

这里写图片描述

练习：利用Collections.sort（）方法对泛型为String的List进行排序版本2：
1.创建完List之后，往其中添加十条随机字符串
2.每条字符串的长度为10以内的随机整数
3.每条字符串的每个字符都为随机生成的字符，字符可以重复
4.每条随机字符串不可重复

package com.vishuo.collection;

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

/*
 * 将要完成：
 * 1.通过Collections.sort()方法，对Integer泛型的List进行排序;
 * 2.对String泛型的List进行排序；
 * 3.对其他类型泛型的List进行排序，以Student为例。
 */
public class CollectionsTest {

    /*
     * 1.通过Collections.sort()方法，对Integer泛型的List进行排序;
     * 创建一个Integer泛型的List，插入十个100以内的不重复的随机整数 调用Collections.sort（）方法对其进行排序
     */
    public void testSort1() {
        List<Integer> integerList = new ArrayList<Integer>();
        // 插入十个100以内的不重复随机整数
        Random random = new Random();
        Integer k;
        for (int i = 0; i < 10; i++) {
            do {
                k = random.nextInt(100);
            } while (integerList.contains(k));
            integerList.add(k);
            System.out.println("成功添加整数：" + k);
        }
        System.out.println("————————————排序前—————————————");
        for (Integer integer : integerList) {
            System.out.println("元素:" + integer);
        }
        Collections.sort(integerList);
        System.out.println("----------——排序后-------------");
        for (Integer integer : integerList) {
            System.out.println("元素:" + integer);
        }
    }

    /*
     * 2.对String泛型的List进行排序； 创建String泛型的list，添加三个乱序的String元素，
     * 调用sort方法，再次输出排序后的顺序
     */
    public void testSort2() {
        List<String> stringList = new ArrayList<String>();
        stringList.add("microsoft");
        stringList.add("google");
        stringList.add("lenovo");
        System.out.println("____________排序前————————————————");
        for (String string : stringList) {
            System.out.println("元素:" + string);
        }
        Collections.sort(stringList);
        System.out.println("————————————排序后———————————————");
        for (String string : stringList) {
            System.out.println("元素:" + string);
        }
    }

    /*
     * Exercise: 1.创建完List<String>之后，往其中添加十条随机字符串 2.每条字符串的长度为10以内的随机整数
     * 3.每条字符串的每个字符都为随机生成的字符，字符可以重复 4.每条随机字符串不可重复
     */
    public void exercise() {

        List<String> stringList = new ArrayList<String>();
        for (int i = 0; i < 10; i++) {// 1.创建完List<String>之后，往其中添加十条随机字符串

            StringBuilder tempString = new StringBuilder();
            Random random = new Random();
            Character[] ku = { '0', 'A', 'a' };
            do {
                int k = (int) (Math.random() * 10);// 2.每条字符串的长度为10以内的随机整数
                for (int j = 0; j <= k; j++) {
                    int t = random.nextInt(3);
                    if (t == 0) {
                        tempString.append((char) (ku[t].charValue() + random.nextInt(10)));
                    } else {
                        tempString.append((char) (ku[t].charValue() + random.nextInt(26)));
                    }
                }
            } while (stringList.contains(tempString.toString()));
            stringList.add(tempString.toString());
        }
        System.out.println("-------------排序前-------------");
        for (String st : stringList) {
            System.out.println("元素：" + st);
        }
        Collections.sort(stringList);
        System.out.println("-------------排序后-------------");
        for (String st : stringList) {
            System.out.println("元素：" + st);
        }

        StringBuilder st = new StringBuilder();// 构建StringBuilder类
        List<String> stringlist = new ArrayList<String>();
        String str = "0123456789abcdefghijklmnobqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        for (int i = 0; i < 10; i++) {// 10条字符串
            Random random = new Random();
            do {
                for (int j = 0; j < random.nextInt(9) + 1; j++) {// 建立10长度以内的字符串
                    int k = random.nextInt(61);
                    st.append(str.charAt(k));
                } // 防止字符串重复，并且把st转化为String类，使其满足泛型，被contains方法调用
            } while (stringlist.contains(st.toString()));
            stringlist.add(st.toString());
            st = new StringBuilder();// 重新构造st，防止其接着加字符，起到让st字符串"清零"的作用
        }
        System.out.println("------排序前------");
        for (String string : stringlist) {
            System.out.println("元素：" + string);
        }
        Collections.sort(stringlist);
        System.out.println("------排序后------");
        for (String string : stringlist) {
            System.out.println("元素：" + string);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CollectionsTest ct = new CollectionsTest();
        ct.testSort1();
        ct.testSort2();
        ct.exercise();
    }

}

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

这里写图片描述

Comparable&Comparator简介
这里写图片描述

这里写图片描述

Comparable____默认比较规则:
Comparable接口—可比较的，实现该接口表示：这个类的实例可以比较大小，可以进行自然排序，定义了默认的比较规则，其实现类需要实现compareTo()方法
compareTo()方法返回正数表示大，负数表示小，0表示相等。

Comparator_____临时比较规则:
comparator接口—比较工具接口，用于定义临时比较规则，而不是默认比较规则，其实现类需要实现compare()方法，Comparator和Comparable都是java集合框架的成员

这里写图片描述

修改Student类
实现Comparable接口，按照学生id进行比较注意实现compareTo方法

package com.vishuo.collection;

import java.util.HashSet;
import java.util.Set;//Set和List一样，都是Collection的子接口

/*
 * 学生类
 * 实现Comparable接口，按照学生id进行比较 注意实现compareTo方法
 * */
public class Student implements Comparable<Student> {
    public String id;
    public String name;

    public Set<Course> courses;

    public Student(String id, String name) {
        this.id = id;
        this.name = name;
        // 实例化
        this.courses = new HashSet<Course>();
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Student))
            return false;
        Student other = (Student) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public int compareTo(Student o){
        return this.id.compareTo(o.id);
    }
}

CollectionsTest类中，实现代码示例：

package com.vishuo.collection;

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

/*
 * 3.对其他类型泛型的List进行排序，以Student为例。
 */
public class CollectionsTest {
    /*
     * 3.对其他类型泛型的List进行排序，以Student为例。
     */
    public void testSort3(){
        List<Student>studentList = new ArrayList<Student>();

        String[]names = {"Mike","Angela","Lucy","nice"};
        Random random = new Random();
        Integer k = null;
        for(int i=0;i<4;i++){
            do{

                if(i==3){
                    studentList.add(new Student(10000+"",names[i]));
                }else{
                    k=random.nextInt(1000);
                    studentList.add(new Student(k+"",names[i]));
                }
            }while(studentList.contains(k));
        }

        System.out.println("______________排序前————————————————");
        for(Student student:studentList){
            System.out.println("学生："+student.id+":"+student.name);
        }
        //按照字符串的排序规则进行排序 先数字后字母，数字0-9，字母A-Z，a-z的顺序
        Collections.sort(studentList);
        System.out.println("____________排序后——————————————");
        for(Student student:studentList){
            System.out.println("学生："+student.id+":"+student.name);
        }

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CollectionsTest ct = new CollectionsTest();
        ct.testSort3();
    }

}

然后演示Comparator接口实现
新建类StudentComparator，实现Comparator接口implements Comparator泛型指定Student

package com.vishuo.collection;

import java.util.Comparator;

public class StudentComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        return o1.name.compareTo(o2.name);
    }

}

CollectionsTest代码修改如下

package com.vishuo.collection;

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

/*
 * 3.对其他类型泛型的List进行排序，以Student为例。
 */
public class CollectionsTest {
    /*
     * 3.对其他类型泛型的List进行排序，以Student为例。
     */
    public void testSort3(){
        List<Student>studentList = new ArrayList<Student>();

        String[]names = {"Mike","Angela","Lucy","nice"};
        Random random = new Random();
        Integer k = null;
        for(int i=0;i<4;i++){
            do{

                if(i==3){
                    studentList.add(new Student(10000+"",names[i]));
                }else{
                    k=random.nextInt(1000);
                    studentList.add(new Student(k+"",names[i]));
                }
            }while(studentList.contains(k));
        }

        System.out.println("______________排序前————————————————");
        for(Student student:studentList){
            System.out.println("学生："+student.id+":"+student.name);
        }
        //按照字符串的排序规则进行排序 先数字后字母，数字0-9，字母A-Z，a-z的顺序
        Collections.sort(studentList);
        System.out.println("____________排序后——————————————");
        for(Student student:studentList){
            System.out.println("学生："+student.id+":"+student.name);
        }
        Collections.sort(studentList,new StudentComparator());
        System.out.println("___________按照姓名排序后——————————————");
        for(Student student:studentList){
            System.out.println("学生："+student.id+":"+student.name);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CollectionsTest ct = new CollectionsTest();
        ct.testSort3();
    }

}

众拾达人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java自学笔记12：java中的集合框架（下）List

一.学生选课—判断List中课程是否存在思考：在课程序列中，如何判断是否包含某门或者某几门课程？：如果课程序列包含某门课程，如何判断该课程的索引位置？：在学生映射表中，如何判断是否包含某个学生ID？：又该如何判断是否包含某个学生对象？：如果想把课程或者学生对象，按照课程名称或者学生姓名排序又该怎么办？按照ID排序呢？ SetTest类代码示例：package com.vishu
复制链接

扫一扫