Java集合进阶-Collection单列集合list集合set集合以及源码分析

最新推荐文章于 2024-07-06 13:51:47 发布

weixin_45170723

最新推荐文章于 2024-07-06 13:51:47 发布

阅读量136

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_45170723/article/details/131491451

版权

数组和集合的区别

相同点
- 都是容器，可以储存多个数据
不同点
- 数组的长度是不可变的，集合的长度是可变的
- 数组可以存基本数据类型和引用数据类型
- 集合只能存引用数据类型，如果要存基本数据类型，需要存对应的包装类

ps：基本数据类型是常见的int，String，float等等...，一共有八种；引用数据类型是类，接口类型，数组类型等等...

集合大致分为两种

Collection单列集合
- List集合--可重复
- Set集合--不可重复
Map双列集合
- HashMap集合
- TreeMap集合

Collection 集合概述和使用

是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

创建Collection集合的对象

使用多态的方式或者具体实现类ArrayList

常见Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

package A01_Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;

public class Collection集合 {
    public static void main(String[] args) {
        //多态新建一个ArrayList子类集合
        Collection<String> coll = new ArrayList<>();

        //添加元素
        coll.add("c");
        coll.add("s");
        coll.add("d");
        coll.add("n");
        System.out.println(coll);//输出[c, s, d, n]

        //移除指定的元素
        coll.remove("c");
        System.out.println(coll);//输出[s, d, n]

        Collection<Integer> numbers = new ArrayList<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(3);
        numbers.add(8);
        numbers.add(1);

        // 使用removeIf()方法删除小于5的元素
        numbers.removeIf(n -> n < 5);

        // 打印删除后的集合
        System.out.println(numbers); // 输出: [5, 8]

        //判断里面是否包含这个元素，有则返回true，无返回false
        Boolean result = coll.contains("s");//true
        System.out.println(result);

        //判断是否为空，集合是空则true,不为空则false
        Boolean result1 = coll.isEmpty();
        System.out.println(result1);//false

        //输出数组长度
        System.out.println(coll.size());//3

        //清空数组
        coll.clear();
    }
}

Collection集合的遍历

迭代器遍历

迭代器是集合专用的遍历方式
literator<E> iteration()返回此集合中元素的迭代器，通过集合对象的iterator()方法得到

Iterator中的常用方法

boolean hasNext(): 判断当前位置是否有元素可以被取出
E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

Collection集合的遍历

public class IteratorDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

it.hasNext()方法和it.next()用完不会复原，如果想再次遍历集合，得新建一个Iterartor迭代器

public class A04_CollectionDemo4 {
    public static void main(String[] args) {
      /*
        迭代器的细节注意点：
            1.报错NoSuchElementException
            2.迭代器遍历完毕，指针不会复位
            3.循环中只能用一次next方法
            4.迭代器遍历时，不能用集合的方法进行增加或者删除
            	暂时当做一个结论先行记忆，在今天我们会讲解源码详细的再来分析。
                如果我实在要删除：那么可以用迭代器提供的remove方法进行删除。
                如果我要添加，暂时没有办法。(只是暂时)
       */

        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //2.获取迭代器对象
        //迭代器就好比是一个箭头，默认指向集合的0索引处
        Iterator<String> it = coll.iterator();
        //3.利用循环不断的去获取集合中的每一个元素
        while(it.hasNext()){
            //4.next方法的两件事情：获取元素并移动指针
            String str = it.next();
            System.out.println(str);
        }

        //当上面循环结束之后，迭代器的指针已经指向了最后没有元素的位置
        //System.out.println(it.next());//NoSuchElementException

        //迭代器遍历完毕，指针不会复位
        System.out.println(it.hasNext());

        //如果我们要继续第二次遍历集合，只能再次获取一个新的迭代器对象
        Iterator<String> it2 = coll.iterator();
        while(it2.hasNext()){
            String str = it2.next();
            System.out.println(str);
        }
    }
}

在迭代器里面，不能用c.remove方法删除集合中的元素，如果想删除得用迭代器里面的remove

迭代器中删除的方法

void remove(): 删除迭代器对象当前指向的元素

public class IteratorDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if("b".equals(s)){
                //指向谁,那么此时就删除谁.
                it.remove();
            }
        }
        System.out.println(list);
    }
}

增强for

介绍
- - 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
- - 实现Iterable接口的类才可以使用迭代器和增强for
- - 简化数组和Collection集合的遍历

格式

for(集合/数组中元素的数据类型变量名 : 集合/数组名) {

// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

}
代码

public class MyCollectonDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组
        for(String str : list){
            System.out.println(str);
        }
    }
}

lambda表达式

利用forEach方法，再结合lambda表达式的方式进行遍历

public class A07_CollectionDemo7 {
    public static void main(String[] args) {
       /* 
        lambda表达式遍历：
                default void forEach(Consumer<? super T> action):
        */

        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");
        //2.利用匿名内部类的形式
        //底层原理：
        //其实也会自己遍历集合，依次得到每一个元素
        //把得到的每一个元素，传递给下面的accept方法
        //s依次表示集合中的每一个数据
       /* coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //lambda表达式
        coll.forEach(s -> System.out.println(s));
    }
}

List集合

list集合的概述
- 有序集合，这里的有序指的是存取有序
- 用户可以精度控制列表中每一个元素插入的位置，用户可以通过整数索引来访问元素，并搜索列表中的元素
- 与set集合不同，列表通常允许重复元素
list集合的特点
- 存取有序
- 可重复
- 有索引

List集合的特有方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

public class MyListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //method1(list);
        //method2(list);
        //method3(list);
        //method4(list);
    }

    private static void method4(List<String> list) {
        //        E get(int index)		返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);
    }

    private static void method3(List<String> list) {
        //        E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
        String result = list.set(0, "qqq");
        System.out.println(result);
        System.out.println(list);
    }

    private static void method2(List<String> list) {
        //        E remove(int index)		删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
        String s = list.remove(0);
        System.out.println(s);
        System.out.println(list);
    }

    private static void method1(List<String> list) {
        //        void add(int index,E element)	在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0,"qqq");
        System.out.println(list);
    }
}

List集合的五种遍历方式

迭代器
列表迭代器
增强for
Lambda表达式
普通for循环

代码示例：

//创建集合并添加元素
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");

//1.迭代器
/*Iterator<String> it = list.iterator();
     while(it.hasNext()){
        String str = it.next();
        System.out.println(str);
}*/


//2.增强for
//下面的变量s，其实就是一个第三方的变量而已。
//在循环的过程中，依次表示集合中的每一个元素
/* for (String s : list) {
       System.out.println(s);
   }*/

//3.Lambda表达式
//forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素
//并把每一个元素传递给下面的accept方法
//accept方法的形参s，依次表示集合中的每一个元素
//list.forEach(s->System.out.println(s) );


//4.普通for循环
//size方法跟get方法还有循环结合的方式，利用索引获取到集合中的每一个元素
/*for (int i = 0; i < list.size(); i++) {
            //i:依次表示集合中的每一个索引
            String s = list.get(i);
            System.out.println(s);
        }*/

// 5.列表迭代器
//获取一个列表迭代器的对象，里面的指针默认也是指向0索引的

//额外添加了一个方法：在遍历的过程中，可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()){
    String str = it.next();
    if("bbb".equals(str)){
        //qqq
        it.add("qqq");
    }
}
System.out.println(list);

List系列集合中的两个删除的方法

1.直接删除元素
2.通过索引进行删除

代码示例:

//List系列集合中的两个删除的方法
//1.直接删除元素
//2.通过索引进行删除

//1.创建集合并添加元素
List<Integer> list = new ArrayList<>();

list.add(1);
list.add(2);
list.add(3);


//2.删除元素
//请问：此时删除的是1这个元素，还是1索引上的元素？
//为什么？
//因为在调用方法的时候，如果方法出现了重载现象
//优先调用，实参跟形参类型一致的那个方法。

//list.remove(1);


//手动装箱，手动把基本数据类型的1，变成Integer类型
Integer i = Integer.valueOf(1);

list.remove(i);

System.out.println(list);

List集合的实现类

List集合子类的特点

ArrayList集合
- 底层是数据结构实现，查询快，增删慢
LinkedList集合
- 底层是链表结构实现的，查询慢，增删快

特有方法

public class MyLinkedListDemo4 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
//        public void addFirst(E e)	在该列表开头插入指定的元素
        //method1(list);

//        public void addLast(E e)	将指定的元素追加到此列表的末尾
        //method2(list);

//        public E getFirst()		返回此列表中的第一个元素
//        public E getLast()		返回此列表中的最后一个元素
        //method3(list);

//        public E removeFirst()		从此列表中删除并返回第一个元素
//        public E removeLast()		从此列表中删除并返回最后一个元素
        //method4(list);
      
    }

    private static void method4(LinkedList<String> list) {
        String first = list.removeFirst();
        System.out.println(first);

        String last = list.removeLast();
        System.out.println(last);

        System.out.println(list);
    }

    private static void method3(LinkedList<String> list) {
        String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first);
        System.out.println(last);
    }

    private static void method2(LinkedList<String> list) {
        list.addLast("www");
        System.out.println(list);
    }

    private static void method1(LinkedList<String> list) {
        list.addFirst("qqq");
        System.out.println(list);
    }
}

源码分析

ArrayList

核心步骤：

1. 创建ArrayList对象的时候，他在底层先创建了一个长度为0的数组。

数组名字：elementDate，定义变量size。

size这个变量有两层含义：
①：元素的个数，也就是集合的长度
②：下一个元素的存入位置

2. 添加元素，添加完毕后，size++

扩容时机一：

3. 当存满时候，会创建一个新的数组，新数组的长度，是原来的1.5倍，也就是长度为15.再把所有的元素，全拷贝到新数组中。如果继续添加数据，这个长度为15的数组也满了，那么下次还会继续扩容，还是1.5倍。

扩容时机二：

4. 一次性添加多个数据，扩容1.5倍不够，怎么办呀？

如果一次添加多个元素，1.5倍放不下，那么新创建数组的长度以实际为准。

举个例子：
在一开始，如果默认的长度为10的数组已经装满了，在装满的情况下，我一次性要添加100个数据很显然，10扩容1.5倍，变成15，还是不够，

怎么办？

此时新数组的长度，就以实际情况为准，就是110

添加一个元素时的扩容：

添加多个元素时的扩容：

LinkedList源码分析：

底层是双向链表结构

核心步骤如下：

刚开始创建的时候，底层创建了两个变量：一个记录头结点first，一个记录尾结点last，默认为null
添加第一个元素时，底层创建一个结点对象，first和last都记录这个结点的地址值
添加第二个元素时，底层创建一个结点对象，第一个结点会记录第二个结点的地址值，last会记录新结点的地址值

迭代器源码分析：

迭代器遍历相关的三个方法：

* Iterator<E> iterator() ：获取一个迭代器对象

* boolean hasNext() ：判断当前指向的位置是否有元素

* E next() ：获取当前指向的元素并移动指针

泛型概述

- 泛型的介绍
- 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制
- 泛型的好处
- 1. 把运行时期的问题提前到了编译期间
- 2. 避免了强制类型转换
- 泛型的定义格式
- - <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <E> <T>
- - <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>

泛型就是限制集合存储的类型

如果没有泛型限制那就可以存储任意类型

泛型接口

定义了一个泛型接口

类型是String，意味着你只能用String数据类型存储

在新建对象的时候也可以不用写<>

如果写E的话新建对象就得指定类型

泛型不具备继承性，但数据具备继承性

package GenericsDemo5;

import java.util.ArrayList;

public class Generics {
    public static void main(String[] args) {
        /* 泛型不具备继承性，但是数据具备继承性 */

        //创建集合的对象
        ArrayList<YE> list1 = new ArrayList<YE>();
        ArrayList<FU> list2 = new ArrayList<FU>();
        ArrayList<ZI> list3 = new ArrayList<ZI>();

        //调用method方法
        method(list1);
        method(list2);//报错
        method(list3);//报错
    }

    //此时泛型里面写的是什么类型的，就只能接受什么类型的
    public static void method(ArrayList<YE> list){
    }
}
class YE{}
class FU extends YE{}
class ZI extends FU{}

解决方法：

可以使用泛型的通配符：

？也表示不确定类型，但是他可以对类型限定
？ extends E : 表示可以传递E或者E所有的子类类型
？ super E : 表示可以传递E或者E所有的父类类型

package GenericsDemo5;

import java.util.ArrayList;

public class Generics {
    public static void main(String[] args) {
        /* 泛型不具备继承性，但是数据具备继承性 */

        //创建集合的对象
        ArrayList<YE> list1 = new ArrayList<YE>();
        ArrayList<FU> list2 = new ArrayList<FU>();
        ArrayList<ZI> list3 = new ArrayList<ZI>();
        ArrayList<student> list4 = new ArrayList<student>();
        //调用method方法
        //method(list1);
        //method(list2);
        //method(list3);
        //method(list4);//报错 
        
    }

    //表示只能是继承了YE或者YE传递才没有问题;
    //public static void method(ArrayList<? extends YE> list){}
    
    //表示只能是FU的父类或者FU传递才没有问题;
    //public static void method(ArrayList<? super FU> list){}
}
class YE{}
class FU extends YE{}
class ZI extends FU{}
class student{}

Set集合
每个集合实现的原理

Set集合的特点：

不可以存储重复元素
没有索引,不能使用普通for循环遍历

Set集合的使用

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Set集合 {
    public static void main(String[] args) {
        //创建Set集合对象
        Set<String> s = new HashSet<>();

        //2.添加元素
        //如果当前元素是第一次添加，则可以添加成功，返回的是true
        //如果当前元素是第二次添加，则不可以添加成功，返回的是false
        s.add("张三");
        s.add("李四");
        s.add("王五");
        s.add("老六");

        //3.打印集合
        //无序
        System.out.println(s);//[李四, 张三, 老六, 王五]

        //迭代器遍历
        /*Iterator<String> it = s.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }*/

        //增强for
        /*for (String s1 : s) {
            System.out.println(s);
        }*/

        //lambda表达式
        //s.forEach(s1 -> System.out.println(s1));
    }
}

HashSet类

HashSet底层原理

HasHset问题：

HashSet集合的底层数据结构是什么样的？
- 答: HashSet的底层数据结构在JDK8之前是数组+链表，在JDK8以后是数组+链表+红黑树
HashSet添加元素的过程？
- 答: HashSet添加元素是计算出哈希值，然后通过哈希值公式计算出数组下标的索引来存储元素
HashSet为什么存和取的顺序不一样？
- 答：因为HashSet存是通过计算哈希值来存储的,有可能会发生哈希碰撞,发生哈希碰撞的值会挂在数组下面,就导致存取的顺序不一样
HashSet为什么没有索引？
- 答：因为HashSet是通过数组链表加红黑树来实现的，就导致没办法设置索引下标
HashSet是利用什么机制保证去重的？
- 答：通过hashcode和equsla来去重，计算出哈希值发现一样，然后再用equsla来比较，如果一样则不存储，如果不一样则通过链表的形势挂在数组下面

HashSet练习

import text18.Calculator;

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

public class HashSet练习 {
    public static void main(String[] args) {
        //1.创建三个学生对象
        Student s1 = new Student("张三",19);
        Student s2 = new Student("老六",12);
        Student s3 = new Student("李四",22);
        Student s4 = new Student("张三",19);

        //2.创建集合
        HashSet<Student> Stu = new HashSet<Student>();

        //3.添加学生
        //必须重写Student类的hashcode和equals才能去重
        //如果不重写，则equals默认比较的是地址值，因为但是new出来的地址肯定不一样
        System.out.println(Stu.add(s1));//true
        System.out.println(Stu.add(s2));//true
        System.out.println(Stu.add(s3));//true
        System.out.println(Stu.add(s4));//false

        //4.打印集合
        System.out.println(Stu);
        //[Student{name='李四', age=22}, Student{name='张三', age=19}, Student{name='老六', age=12}]
    }
}
class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

LinkedHashSet集合

增加了双向链表机制

import text18.Calculator;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Objects;

public class HashSet练习 {
    public static void main(String[] args) {
        //1.创建三个学生对象
        Student s1 = new Student("张三",19);
        Student s2 = new Student("老六",12);
        Student s3 = new Student("李四",22);
        Student s4 = new Student("张三",19);

        //2.创建集合
        LinkedHashSet<Student> Stu = new LinkedHashSet<Student>();

        //3.添加学生
        //必须重写Student类的hashcode和equals才能去重
        //如果不重写，则equals默认比较的是地址值，因为但是new出来的地址肯定不一样
        System.out.println(Stu.add(s1));//true
        System.out.println(Stu.add(s2));//true
        System.out.println(Stu.add(s3));//true
        System.out.println(Stu.add(s4));//false

        //4.打印集合
        System.out.println(Stu);
        //[Student{name='张三', age=19}, Student{name='老六', age=12}, Student{name='李四', age=22}]
    }
}
class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

TreeSet集合

package 泛型练习;

import java.util.TreeSet;
public class TreeSet使用 {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();

        ts.add(1);
        ts.add(3);
        ts.add(2);
        ts.add(5);

        //默认升序
        System.out.println(ts);//[1, 2, 3, 5]
    }
}

多个字符比较是第一个字母比较，如果第一个字母比较相等则比较第二个，以此类推，知直到比较不相等，就会按照ASCII码排序

自定义排序规则：

案例需求
- 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
1. 使用空参构造创建TreeSet集合
  - 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
2. 自定义的Student类实现Comparable接口
  - 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
3. 重写接口中的compareTo方法
  - 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现

学生类

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照对象的年龄进行排序
        //主要判断条件: 按照年龄从小到大排序
        int result = this.age - o.age;
        //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}

测试类

public class MyTreeSet2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();
	    //创建学生对象
        Student s1 = new Student("zhangsan",28);
        Student s2 = new Student("lisi",27);
        Student s3 = new Student("wangwu",29);
        Student s4 = new Student("zhaoliu",28);
        Student s5 = new Student("qianqi",30);
		//把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
		//遍历集合
        for (Student student : ts) {
            System.out.println(student);
        }
    }
}

比较器排序

- 案例需求
- - 存储老师对象并遍历，创建TreeSet集合使用带参构造方法
- - 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
- 实现步骤
- - 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
- - 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
- - 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

- 代码实现

老师类

public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

public class MyTreeSet4 {
    public static void main(String[] args) {
      	//创建集合对象
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
              
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
		//创建老师对象
        Teacher t1 = new Teacher("zhangsan",23);
        Teacher t2 = new Teacher("lisi",22);
        Teacher t3 = new Teacher("wangwu",24);
        Teacher t4 = new Teacher("zhaoliu",24);
		//把老师添加到集合
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
		//遍历集合
        for (Teacher teacher : ts) {
            System.out.println(teacher);
        }
    }
}

使用Comparator比较器对象，指定比较器规则

weixin_45170723

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java集合进阶-Collection单列集合list集合set集合以及源码分析

Java集合进阶-Collection单列集合，list集合，set集合，ArrayList集合，LinkedList集合LinkedHashSet集合，TreeSet集合，以及源码分析使用场景，练习。
复制链接

扫一扫