java容器

  • 时间:
  • 来源:互联网
  • 文章标签:

容器

目录

  • 容器
    • 1.Collection:存储着对象的集合
            • 1. Set接口:**集,无序,不可重复**
            • 2. List接口:**序列,排列有序,可重复**
            • 3. Queue接口
    • 2.Map:存储着键-值对的映射表,能够实现key快速查找value
    • 3. 泛型
    • 4. Collection.sort() 对序列中的元素进行排序
    • 5. 代码测试实现
          • 学生类
          • 课程类
          • Set接口的Test
          • Map接口的Test
          • List接口的Test
          • 泛型的Test
          • Collections接口的Test
      • 测试

在这里插入图片描述

1.Collection:存储着对象的集合

1. Set接口:集,无序,不可重复

继承了Collection接口和其所有方法

    SortedSet接口:
        TreeSet:基于红黑树实现
            二分查找——二叉查找树——红黑树
            红黑树的规则:
            1.结点是红色或黑色。
            2.根结点是黑色。
            3.每个叶子结点都是黑色的空结点(NIL结点)。
            4 每个红色结点的两个子结点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色结点)
            5.从任一结点到其每个叶子的所有路径都包含相同数目的黑色结点。

            红黑树从根到叶子的最长路径不会超过最短路径的2倍

存入TreeSet类竖线的Set集合必须实现Comparable接口

    HashSet:哈希表实现
    LinkedHashSet:双向链表
2. List接口:序列,排列有序,可重复
	定义的方法:
			get(int index) 获得指定索引位置的元素 
			set(int index, Object obj) 指定索引位置的对象修改为指定的对象 
    ① ArrayList:动态数组
    		优点:可变的数组
    		缺点:指定的索引位置插入对象、删除对象
    ② Vector:动态数组 + 线程安全
    ③  LinkedList:双向链表
    		优点:方便插入和删除对象
    		缺点:随机访问时效率低
3. Queue接口
        LinkedList:双向队列
        PriorityQueue:堆结构实现,可实现优先队列

2.Map:存储着键-值对的映射表,能够实现key快速查找value

SortedMap接口:
    TreeMap:红黑树实现
HashTable:
LinkedHashMap:
HashMap:哈希表实现

Map:
 1. Map中键值对以Entry类型的对象实例形式存在
 2. key值不能重复,value可以
 3. 每个键最多只能映射到一个值
 4. Map接口提供了分别返回key值集合、value值集合以及Entry(键值对)集合的方法
 5. Map支持泛型,Map<K,V>

HashMap类:
    HashMap是Map的实现类,基于哈希表实现的
    HashMap中的Entry对象是无序排列的
    Key值和value值都可以为null,但是一个HashMap只能有一个key值为null的映射(key值不可重复)

3. 泛型

   集合中的元素可以是任意类型的对象(对象的引用), 当把对象放入集合中,则会忽略他的类型,当做object处理
1. 泛型则是规定了集合只可以存放特定类型的对象
2. 泛型集合中,不能添加泛型规定的类型及其子类型以外的对象,否则会报错
3. 泛型集合可以添加泛型的子类型的对象实例

 泛型集合:泛型类型 泛型子类型
    1. 泛型集合中的限定类型不能使用基本的数据类型
    2. 可以使用包装类限定存入的基本数据类型
        int -> Integer

4. Collection.sort() 对序列中的元素进行排序

Comparable接口   定义默认的排序规则——可比较的
    1.  实现了该接口表示:这个类的实力可以比较大小,可以进行自然排序
    2   定义了默认的比较规则
    3.  其实现类需实现compareTo()方法
    4.  comparaTo()方法返回正数表示大,负数表示小,0表示相等

Comparator接口    定义临时比较规则
    1.  其实现类需要实现compare()方法
    2.  Comparator和Comparable都是Java集合框架的成员

5. 代码测试实现

学生类
package collection;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/8 16:31
 * version 1.0
 * Description: 测试
 */

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

/**
 *学生类
 */
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;
        //把所选课程进行初始化 不能直接实例化Set Set为一个接口
        this.courses = new HashSet<Course>();

    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    @Override
    public int compareTo(Student o) {


        return this.id.compareTo(o.id);
    }
}

课程类
package collection;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/8 16:29
 * version 1.0
 * Description: 创建课程类和学生类来理解 list 和 Arraylist
 * 课程类
 */

import java.util.Objects;

/**
 * 课程类
 * 由于只是测试 所以属性写成了公有属性
 */
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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        if (!(o instanceof Course))
            return false;
        Course course = (Course) o;
        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;
        }
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

Set接口的Test
package collection;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/8 22:06
 * version 1.0
 * Description: 测试
 */
/**
 * 功能说明:
 *  提供备选课程
 *  创建学生对象 并给学生添加三门课程(添加在学生的courses——Set类型的属性中)
 *      显示备选课程
 *      循环三次,每次输入课程ID
 *      往学生的course属性中添加与输入的ID匹配的课程
 *      输出学生选择的课程
 */

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

/**
 *
 */

public class SetTest {

    public List<Course> coursesToSelect;

    public Student student;

    public SetTest() {
        coursesToSelect = new ArrayList<Course>();
    }



    /**
     * 用于往coursesToSelect中添加备选课程
     */
    public void testAdd() {
        // 创建一个课程对象,并通过调用add方法,添加到备选课程List中
        Course cr1 = new Course("1", "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);

        Course cr2 = new Course("2", "C语言");
        coursesToSelect.add(0, cr2);
        Course temp2 = (Course) coursesToSelect.get(0);

        Course[] course = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);

        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);

    }

    /**
     * 通过for each方法访问集合元素
     *
     * @param
     */
    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(0);
        //打印输出coursesToSelect是否包含course对象
        System.out.println("取得课程:" + course.name);
        System.out.println("备选课程中是否包含课程:" + course.name +"; "+
                coursesToSelect.contains(course));

        System.out.println("请输入课程名称:");
        Scanner sc = new Scanner(System.in);
        String name = sc.next();
        //创建一个新的课程对象,ID和名称,与course对象完全一样
        Course course2 = new Course();
        course2.name = name;
        System.out.println("新创建课程:" + course2.name);
        System.out.println("备选课程中是否包含课程: " + course2.name + ", " +
                coursesToSelect.contains(course2));
        // 通过indexOf方法来取得某元素的索引位置
        if (coursesToSelect.contains(course2))
            System.out.println("课程:" + course2.name + "的索引位置为:" +
                    coursesToSelect.indexOf(course2));
    }

    /**
     * 创建学生对象并选课
     */
    public void createStudentAndSelectCourse(){
                // 创建一个学生对象
        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 : coursesToSelect) {
                if (cr.id.equals(courseId)) {
                    student.courses.add(cr);
                    /**
                     * Set中,添加某个对象,无论添加多少次, 最终只会保留一个该对象(的引用), 并且保留的是第一次添加的那一个
                     */
                    /**
                     * 可以添加空对象 但是无意义
                     */
                    // student.courses.add(null);
//                    student.courses.add(cr);
                }
            }
        }
    }

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


    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        SetTest st = new SetTest();
        st.testAdd();
        st.testListContains();
        st.testForEach();

//        st.testForEachForSet(student);
//
//
//        st.createStudentAndSelectCourse();
//        st.testSetContains();
    }

    /**
     * 遍历Set方法只能用for each方法和iterator方法,不能像List方法一样使用get()方法,
     * 因为Set是无序的没有get() set()方法
     *
     */
    public void testForEachForSet(Student student) {
        // 打印输出,学生所选的课程!
        System.out.println("共选择了:" + student.courses.size() + "门课程!");
        for (Course cr : student.courses) {
            System.out.println("选择了课程:" + cr.id + ":" + cr.name);
        }
    }

}

Map接口的Test
package collection;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/9 10:27
 * version 1.0
 * Description: 测试
 */

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

/**
 *通过Map<String,Student>进行学生信息管理,其中key为学生ID,value为学生对象
 * 通过键盘输入学生信息
 * 对集合中的学生信息进行增、删、改、查操作
 */
public class MapTest {
    /**
     * 用来承装学生类型对象
     *
     */
    public Map<String,Student> students;
    /**
     * 构造器中初始化students属性
     *
     */
    public MapTest() {
        this.students = new HashMap<String, Student>();
    }

    /**
     *测试添加:输入学生ID,判断是否被占用
     * 若未被占用,则输入姓名,创建新学生对象,并且添加到students中
     */
    public void testPut(){
        //创建一个Scanner对象,用来获取输入的学生ID和姓名
        Scanner sc = new Scanner(System.in);
        int i = 0;
        while (i<3){
            System.out.println("请输入学生ID:");
            String ID = sc.next();
            //判断该ID是否被占用
            Student st = students.get(ID);
            if (st == null){
                //提示输入学生姓名
                System.out.println("请输入学生姓名:");
                String name = sc.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字符串
        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<Map.Entry<String, Student>> entrySet = students.entrySet();
        for (Map.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字符串
        Scanner 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 newStudent = new Student(stuID, name);
            students.put(stuID, newStudent);
            System.out.println("修改成功!");
            break;
        }
    }
    /**
     * 测试Map中,是否包含某个Key值或者某个Value值
     */
    public void testContainsKeyOrValue() {
        // 提示输入学生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) {
        MapTest mt = new MapTest();
        mt.testPut();
        mt.testKeySet();
//        mt.testRemove();
//        mt.testEntrySet();
        mt.testModify();
        mt.testEntrySet();
    }
}

List接口的Test
package collection;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/8 16:36
 * version 1.0
 * Description: 测试
 */

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

/**
 *备选课程类
 */
public class ListTest {
    /**
     * 用于存放备选课程的list
     */
    public List coursesToSelect;

    public ListTest() {
        //通过构造函数对属性进行实例化
        this.coursesToSelect = new ArrayList();
    }

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

        //指定位置进行插入 会把之前添加的“数据结构”课程挤到第1个位置 新插入的在第0个位置
        Course cr2 = new Course("2", "电路基础");
        coursesToSelect.add(0,cr2);
        //当对象存入都变成object类型  取出时需要类型转换
        Course temp2 = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程:" + temp2.id + " : " + temp2.name);

        Course[] course = {new Course("3", "高等数学"),new Course("4", "英语")};
        //使用Arrays.asList()方法 把course数组转换成一个list集合
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);

        System.out.println("添加了两门课程:" + temp3.id + ": " + temp3.name + ";" +
                temp4.id + ": " + temp4.name);

        //进行插入到指定位置 插入到下标为2的位置
        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);

        //测试可重复添加
        coursesToSelect.add(cr2);
        //当对象存入都变成object类型  取出时需要类型转换
        Course temp0 = (Course) coursesToSelect.get(2);
        System.out.println("添加了课程:" + temp0.id + " : " + temp0.name);

    }

    /**
     * 取得list中元素的方法
     * list 中的size方法取得列表中元素的长度
     *
     */

    public void testGet(){
        int size = coursesToSelect.size();

        System.out.println("有如下课程待选");
        for (int i = 0; i <size;i++){
            Course cr = (Course) coursesToSelect.get(i);
            System.out.println("课程:" + cr.id + ":" + cr.name);
        }
    }

    /**
     * Iterator 返回在此collection的元素上进行迭代的迭代器
     * 迭代器就是会用来遍历集合中元素的 不具备存储元素的功能 依赖于集合存在 不能独立存在
     * 通过迭代器进行List遍历
     */
    public void testIterator(){
        //通过集合的iterator方法,取得迭代器的实例
        Iterator it = coursesToSelect.iterator();
        System.out.println("有如下课程待选(通过迭代器访问):");
        while (it.hasNext()) {
            Course cr = (Course)it.next();
            System.out.println("课程: " + cr.id + ": " + cr.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);
        }
    }


    public static void main(String[] args) {
        ListTest lt = new ListTest();
        lt.testAdd();
        lt.testGet();
        lt.testIterator();
        lt.testForEach();
    }
}

泛型的Test
package collection;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/8 21:47
 * version 1.0
 * Description: 测试
 */

/**
 *
 */
public class ChildCourse extends Course {
        //ChildCourse继承了Course类型 要调用父类的无参构造器
}



package collection;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/8 21:39
 * version 1.0
 * Description: 测试
 */

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

/**
 *
 */
public class TestGeneric {

    /**
     * 带有泛型——course的List类型属性
     */
    public List<Course> courses;

    public TestGeneric() {
        this.courses = new ArrayList<Course>();
    }

    /**
     * 测试添加
     * @param
     */
    public void testAdd(){
        Course cr1 = new Course("1","大学语文");
        courses.add(cr1);
        //泛型集合中,不能添加泛型规定的类型及其子类型以外的对象,否则会报错
        // courses.add("能否添加一些奇怪的东西呢");

        Course cr2 = new Course("2","大学英语");
        courses.add(cr2);
    }

    /**
     *测试循环遍历
     * @param
     */

    public void testForEach(){
        for (Course cr:courses) {
            System.out.println(cr.id + ":" +cr.name);
        }
    }

    /**
     *泛型集合可以添加泛型的子类型的对象实例
     * @param
     */
    public void testChild(){
        ChildCourse cc = new ChildCourse();
        cc.id = "3";
        cc.name = "我是子类型的课程对象实例";
        courses.add(cc);
    }

    public static void main(String[] args) {
        TestGeneric tg = new TestGeneric();
        tg.testAdd();
        tg.testForEach();
        tg.testChild();
        tg.testForEach();
    }
}

Collections接口的Test
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);
    }
}

package collection;

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

import static java.util.Collections.sort;

/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/9 17:28
 * version 1.0
 * Description:
 * 测试将要完成:
 *   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);
        }
        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);
        }
        sort(stringList);
        System.out.println("--------------排序后---------------");
        for (String string : stringList) {
            System.out.println("元素:" + string);
        }
    }

    /**
     * 3.对其他类型泛型的List进行排序,以Student为例。
     */

    public void testSort3() {
        List<Student> studentList = new ArrayList<Student>();
        Random random = new Random();
        studentList.add(new Student(random.nextInt(1000) + "", "Mike"));
        studentList.add(new Student(random.nextInt(1000) + "", "Angela"));
        studentList.add(new Student(random.nextInt(1000) + "", "Lucy"));
        studentList.add(new Student(10000 + "", "Beyonce"));
        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);
        }
        Collections.sort(studentList, new StudentComparator());
        System.out.println("----------------按照姓名排序后-----------------");
        for (Student student : studentList) {
            System.out.println("学生:" + student.id + ":" + student.name);
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        CollectionsTest ct = new CollectionsTest();
		ct.testSort1();
//		ct.testSort2();
//        ct.testSort3();
    }



}

测试

在这里插入图片描述

package org.example;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/6/8 16:18
 * version 1.0
 * Description:
 * 创建String泛型的List,放入10条随机的字符串
 * 每条字符串的长度为10以内的随机整数
 * 每条字符串的字符都是随机生成的字符,字符可以重复
 * 每条随机生成的字符串不可以重复
 */

import java.util.*;
public class sortTest {
    public List<String> ls = new ArrayList();
    public String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345678";
    Random randomInt = new Random();
    Integer k;



    public List<String> creatList(){
        for (int i=0; i<10; i++){
            StringBuffer sb = new StringBuffer();
            do {
                k = randomInt.nextInt(10);
                for (int j=0; j<k+1; j++){
                    sb.append(str.charAt(randomInt.nextInt(str.length())));
                }
            }while (ls.contains(sb));
            ls.add(sb.toString());
        }
        return ls;
    }

    public void sort(List ls){
        System.out.println("-----------排序前输出:-----------");
        for(Object str:ls){
            System.out.println(str);
        }

        Collections.sort(ls);

        System.out.println("-----------排序后输出:-----------");
        for(Object str:ls){
            System.out.println(str);
        }
    }

    public static void main(String[] args) {
        sortTest st = new sortTest();
        st.sort(st.creatList());
    }

}

说明:这是根据imooc上的java课程进行学习理解的 若有侵权联系作者

本文链接http://www.taodudu.cc/news/show-82867.html