16.Map系列、集合排序、不可变集合

真滴book理喻

已于 2023-10-16 10:02:03 修改

阅读量494

点赞数

分类专栏： # Java SE 文章标签： java

于 2023-01-30 16:56:22 首次发布

本文链接：https://blog.csdn.net/m0_59749089/article/details/128805438

版权

Java SE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

一.Map

1.1 Map集合概述

Map集合是一种双列集合，每个元素包含二个数据。非常适合购物车这类业务场景。

1.2 Map集合体系

1.3 Map集合特点

Map集合体系特点

Map集合的特点都是由键决定的
Map集合的键是无序、不重复、无索引的、值不作要求。
Map集合后面重复的键对应的值会覆盖前面重复键的值。
Map集合的键值对都可以为null。

Map集合实现类特点

HashMap：元素是按照键无序、不重复、无索引，值不做要求。
LinKedHashMap：元素是按照键有序、不重复、无索引，值不做要求。
TreeMap：元素是按照键排序、不重复、无索引，值不做要求。

1.4 Map集合的API

Map集合是双列集合的祖宗接口，它的功能是全部双列集合都可以继承使用的。

1.5 Map集合的遍历方式

键找值的方式遍历

先获取Map集合的全部键的Set集合
遍历键的Set集合，然后通过键提取对应值。

键找值涉及到的API：

键值对的方式遍历

先把Map集合转换成Set集合，Set集合中的每个元素都是键值对实体类型了。
遍历Set集合，然后提取键以及提取值。

键值对遍历涉及到的API

Lambda表达式的方式

得益于JDK8开始的新技术Lambda表达式，提供了一种更简单更直接的遍历方式。Lambda表达式遍历涉及到的API

1.6 HashMap

1.7.1 HashMap的特点

无序、不重复、无索引。

1.7.2 底层原理

HashMap 的底层原理和 HashSet 是一样的，都是哈希表，所以元素的增删改查性能都很好。

1.7.3 注意事项

Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。
依赖equals和hashcode方法保证键的唯一。
如果键要存储的是自定义对象，需要在对象中重写equals和hashcode方法。

1.8 LinkedHashMap

1.8.1 特点

有序、不可重复、无索引。

1.8.2 原理

同LinkedHashSet一样，底层数据结构依然是哈希表，只是每个键值对元素又多了一个双链表的机制记录存储的顺序。元素的增删改查性能也很好。

1.8.3 注意事项

同HashMap

1.9 TreeMap

1.9.1 特点

排序，不可重复，无索引

1.9.2 排序规则

具有值特性的数据默认按照键升序排序。

自定义类型的对象有二种方式排序：

类实现Comparable接口，重写比较规则。
集合自定义Comparator比较器对象，重写比较规则。

1.9.3 底层原理

同HashSet一样，底层是红黑树，所以元素的增删改查性能很好。

1.9.4 注意事项

TreeMap集合是一定要排序的，可以默认排序，也可以将键按照指定的规则进行排序

二.集合排序

2.1 集合排序概述

Collections类

Collections类是集合的工具类，可以对List集合进行排序，无法直接对Set、Map类型的集合进行排序，在排序过程中依赖于Comparable、Compatator接口。该类除了排序还有许多其他功能，例如对集合元素：查找，排序，洗牌，转换，拷贝，查找最大值/最小值，集合反转，安全集合的获取等一系列静态方法。

Comparable<T>和Comparator<T>接口

Comparable<T>和Comparator<T>是Java用来对集合进行排序的二个接口。通过重写这二个接口中的方法，可以指定具体的排序规则对集合中的对象进行排序。Comparator 既可以让对象实现此接口实现定制排序，也可以通过匿名内部类的方式传入Collections、TreeSet、TreeMap等集合类中来实现定制排序。

Note：对于String、Integer等类已经默认实现了Comparable接口了

2.2 List类型集合的排序

2.1.1 Comparable：自然排序

第一步：创建实体类实现 Comparable 接口，实现其ComparaTo(T t)方法。

public class Student implements Comparable<Student>{
 
    private int sno;
    private String sname;
    private String sex;
    private String major;
    private Date birth;
    private double score;
 
    public Student(int sno, String sname, String sex, String major, Date birth, double score) {
        this.sno = sno;
        this.sname = sname;
        this.sex = sex;
        this.major = major;
        this.birth = birth;
        this.score = score;
    }
 
    /**
     *   自然排序的比较方法
     */
    @Override
    public int compareTo(Student s) {
        return this.sname.compareTo(s.getSname());
    }
 
	//setter/getter
    //toString
 
}

第二步：创建集合，实现排序

//基于数组生成List集合
List<Student> list = Arrays.asList(
    new Student(1002,"jack","男","挖掘机专修",new Date(),88),
    new Student(1005,"rose","女","挖掘机专修",new Date(),55),
    new Student(1006,"lily","男","挖掘机专修",new Date(),59),
    new Student(1001,"lucy","男","挖掘机专修",new Date(),44),
    new Student(1003,"jack","男","挖掘机专修",new Date(),39),
    new Student(1011,"tom","男","挖掘机专修",new Date(),59),
    new Student(1004,"bobo","男","挖掘机专修",new Date(),89),
    new Student(1008,"aricle","男","挖掘机专修",new Date(),59),
    new Student(1012,"admin","男","挖掘机专修",new Date(),99),
    new Student(1010,"softeem","男","挖掘机专修",new Date(),46),
    new Student(1007,"ase","男","挖掘机专修",new Date(),32),
    new Student(1009,"jojo","男","挖掘机专修",new Date(),10)
);

//默认自然排序规则排序（Comparable）
Collections.sort(list);

2.1.2 Comparator：定制排序

第一步：创建用于比较排序的实体类

public class Student{
 
    private int sno;
    private String sname;
    private String sex;
    private String major;
    private Date birth;
    private double score;
 
    //构造器
	//setter/getter
    //toString
 
}

第二步：创建排序比较器对象

1.直接通过匿名内部类实现

List<Student> list = Arrays.asList(
    new Student(1002,"jack","男","挖掘机专修",new Date(),88),
    new Student(1005,"rose","女","挖掘机专修",new Date(),55),
    new Student(1006,"lily","男","挖掘机专修",new Date(),59),
    new Student(1001,"lucy","男","挖掘机专修",new Date(),44),
    new Student(1003,"jack","男","挖掘机专修",new Date(),39),
    new Student(1011,"tom","男","挖掘机专修",new Date(),59),
    new Student(1004,"bobo","男","挖掘机专修",new Date(),89),
    new Student(1008,"aricle","男","挖掘机专修",new Date(),59),
    new Student(1012,"admin","男","挖掘机专修",new Date(),99),
    new Student(1010,"softeem","男","挖掘机专修",new Date(),46),
    new Student(1007,"ase","男","挖掘机专修",new Date(),32),
    new Student(1009,"jojo","男","挖掘机专修",new Date(),10)
);
//排序（使用匿名内部类）
Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.getSname().compareTo(s2.getSname());
    }
});
 
for (Student s : list) {
    System.out.println(s);
}

2.通过自定义排序类实现Comparator接口

该方式可以实现更好的排序扩展性，需要在上面Student实体类的基础上创建单独排序类：

public class StudentComparator implements Comparator<Student> {
    //用于排序的字段 sno,sname,score,birth
    private String field;
 
    public StudentComparator(String field) {
        this.field = field;
    }
 
    @Override
    public int compare(Student s1, Student s2) {
        switch (field){
            case "sno":
                //按学号排序
                return s1.getSno() - s2.getSno();
            case "sname":
                //按姓名排序
                return s1.getSname().compareTo(s2.getSname());
            case "score":
                //按学分排序
                return (int)(s2.getScore() - s1.getScore());
            case "birth":
                //按生日排序
                return s1.getBirth().compareTo(s2.getBirth());
            default:
                return 0;
        }
    }
 
}

排序实现

public class TestStu {
 
    public static void main(String[] args) {
 
        List<Student> list = Arrays.asList(
                new Student(1002,"jack","男","挖掘机专修",new Date(),88),
                new Student(1005,"rose","女","挖掘机专修",new Date(),55),
                new Student(1006,"lily","男","挖掘机专修",new Date(),59),
                new Student(1001,"lucy","男","挖掘机专修",new Date(),44),
                new Student(1003,"jack","男","挖掘机专修",new Date(),39),
                new Student(1011,"tom","男","挖掘机专修",new Date(),59),
                new Student(1004,"bobo","男","挖掘机专修",new Date(),89),
                new Student(1008,"aricle","男","挖掘机专修",new Date(),59),
                new Student(1012,"admin","男","挖掘机专修",new Date(),99),
                new Student(1010,"softeem","男","挖掘机专修",new Date(),46),
                new Student(1007,"ase","男","挖掘机专修",new Date(),32),
                new Student(1009,"jojo","男","挖掘机专修",new Date(),10)
        );
 
        //使用独立比较器
        Collections.sort(list,new StudentComparator("score"));
 
        for (Student s : list) {
            System.out.println(s);
        }
 
    }
}

2.3 Set和Map集合类型的排序

对于Set和Map类型的集合

可以使用TreeSet和TreeMap进行排序，TreeSet和TreeMap排序也有Camparable：自然排序和Comparator：定制排序
可以通过转换的方式，将Set、Map类型的集合转化成List类型的集合，再使用Collections.sort方法对其进行排序。

1.Set

自然排序

public class Student implements Comparable<Student>{
 
    private int sno;
    private String sname;
    private String sex;
    private String major;
    private Date birth;
    private double score;
 
    public Student(int sno, String sname, String sex, String major, Date birth, double score) {
        this.sno = sno;
        this.sname = sname;
        this.sex = sex;
        this.major = major;
        this.birth = birth;
        this.score = score;
    }
 
    /**
     *   自然排序的比较方法
     */
    @Override
    public int compareTo(Student s) {
        return this.sname.compareTo(s.getSname());
    }
 
	//setter/getter
    //toString
 
}

//基于数组生成List集合
List<Student> list = Arrays.asList(
    new Student(1002,"jack","男","挖掘机专修",new Date(),88),
    new Student(1005,"rose","女","挖掘机专修",new Date(),55),
    new Student(1006,"lily","男","挖掘机专修",new Date(),59),
    new Student(1001,"lucy","男","挖掘机专修",new Date(),44),
    new Student(1003,"jack","男","挖掘机专修",new Date(),39),
    new Student(1011,"tom","男","挖掘机专修",new Date(),59),
    new Student(1004,"bobo","男","挖掘机专修",new Date(),89),
    new Student(1008,"aricle","男","挖掘机专修",new Date(),59),
    new Student(1012,"admin","男","挖掘机专修",new Date(),99),
    new Student(1010,"softeem","男","挖掘机专修",new Date(),46),
    new Student(1007,"ase","男","挖掘机专修",new Date(),32),
    new Student(1009,"jojo","男","挖掘机专修",new Date(),10)
);
//将List集合转换为Set，利用TreeSet进行自然排序
Set<Student> set = new TreeSet<>(list);
for (Student s : set) {
    System.out.println(s);
}

定制排序

import java.util.TreeSet;

public class CustomSortingExample {
    public static void main(String[] args) {
        TreeSet<String> names = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });

        names.add("John");
        names.add("Alice");
        names.add("Robert");
        names.add("Michael");
        names.add("Alex");

        System.out.println("定制排序结果:");
        for (String name : names) {
            System.out.println(name);
        }
    }
}

定制排序结果:
John
Alex
Alice
Robert
Michael

2.Map