在Java中卷起来 - Java的集合进阶 - 《菜鸡的编程之路》

一、数组和集合的区别
二、集合类的体系结构
- Collection接口
三、集合对于泛型的支持
四、Collection接口常用API
五、Collection集合的遍历方式
六、Collection集合存储自定义类型对象
七、List集合
八、List集合遍历
九、LinkedList特点
十、集合的遍历删除
十一、Set集合
- 1、HashSet
  - （1）LinkedHashSet
- 2、TreeSet
拓展知识：可变参数
拓展知识：集合工具类Collections
十二、Map集合
十三、集合的嵌套
十四、不可变集合

一、数组和集合的区别

二、集合类的体系结构

Collection接口

package com.key.d15_packeg_01.Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
 * 明确Collection集合体系
 */
public class demo1 {
    public static void main(String[] args) {
        /**
         * Arraylist：有序，可重复，有索引
         */
        Collection list = new ArrayList();
        list.add("JAVA");
        list.add("C#");
        list.add(24);
        list.add("Python");
        System.out.println(list);
        /**
         * Hashset：无序，不重复，无索引
         */
        Collection list1 = new HashSet();
        list1.add("JAVA");
        list1.add("C#");
        list1.add("JAVA");
        list1.add("Python");
        list1.add(200);
        System.out.println(list1);
    }
}

三、集合对于泛型的支持

四、Collection接口常用API

package com.key.d15_packeg_01.Collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class api_demo {
    public static void main(String[] args) {
        //多态定义泛型集合
        Collection<String> test = new ArrayList<>();
        //1、增加元素，添加成功返回True
        test.add("JAVA#");
        test.add("Python");
        System.out.println(test);
        //2、清空集合
        test.clear();
        System.out.println(test);
        //3、判断结合是否为空，是空返回True，不是返回Flase
        System.out.println(test.isEmpty());
        //4、获取结合大小
        test.add("JAVA#");
        test.add("Python");
        System.out.println(test.size());
        //5、判断结合中是否包含某个元素
        System.out.println(test.contains("Python"));
        //6、删除某个元素，如果有多个重复的元素默认删除前面的第一个
        System.out.println(test.remove("Python"));
        System.out.println(test);
        //7、把集合转换成数组
        test.add("MySQL");
        test.add("MSSQL");
        test.add("Python");
        System.out.println(test);
        /**
         * 这里要将集合转换为Object类型的数组，因为要接收一切类型的数据
         */
        Object[] arrs = test.toArray();
        String result = Arrays.toString(arrs);    //打印数组内容
        System.out.println(result);
        System.out.println("-------------------拓展内容---------------------");
        /**
         * 创建两个集合，list1和list2
         */
        Collection<String> list1 = new ArrayList<>();
        list1.add("java1");
        list1.add("java2");
        Collection<String> list2 = new ArrayList<>();
        list2.add("python1");
        list2.add("python2");
        //把list2的元素拷贝到list1中去
        list1.addAll(list2);
        System.out.println(list1);
    }
}

五、Collection集合的遍历方式

1、迭代器（迭代器只能用来遍历数组）

package com.key.d15_packeg_01.Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class iterator_demo {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("Python");
        list.add("MySQL");
        list.add("MSSQL");
        list.add("TomCat");
        list.add("Shiro");
        System.out.println(list);
        System.out.println("----------------------");
        //得到当前集合的迭代器
        Iterator<String> iterator = list.iterator();
        /**
         * 一步步通过next()遍历集合
         */
        //String str = iterator.next();
        //System.out.println(str);    //输出JAVA
        //System.out.println(iterator.next());    //输出Python
        //System.out.println(iterator.next());    //输出MySQL
        //System.out.println(iterator.next());    //输出MSSQL
        //System.out.println(iterator.next());    //输出TomCat
        //System.out.println(iterator.next());    //输出Shiro
        //System.out.println(iterator.next());    //越界了，超出范围，这个就会报错
        /**
         * 通过循环遍历结合
         */
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

2、foreach遍历/增强for循环（即可以遍历数组也可以遍历集合）

package com.key.d15_packeg_01.Collection;
import java.util.ArrayList;
import java.util.Collection;
public class foreach_demo {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("Python");
        list.add("MySQL");
        list.add("MSSQL");
        list.add("TomCat");
        list.add("Shiro");
        System.out.println(list);
        System.out.println("----------------------");
        /**
         * foreach遍历集合
         */
        for (String str:list){
            System.out.println(str);
        }
        System.out.println("--------------");
        /**
         * foreach遍历数组
         */
        double[] scores = {99.0,90.5,85.9};
        for (double score : scores) {
            System.out.println(score);
        }
    }
}

3、lambda遍历（不常用）

package com.key.d15_packeg_01.Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
public class lambda_demo {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("Python");
        list.add("MySQL");
        list.add("MSSQL");
        list.add("TomCat");
        list.add("Shiro");
        System.out.println(list);
        System.out.println("----------------------");
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
    }
}

六、Collection集合存储自定义类型对象

举一个实例

package com.key.d15_packeg_01.Collection;
public class Movie {
    private String name;
    private String time;
    private double scores;
    public Movie(String name, String time, double scores) {
        this.name = name;
        this.time = time;
        this.scores = scores;
    }
    public Movie() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
    public double getScores() {
        return scores;
    }
    public void setScores(double scores) {
        this.scores = scores;
    }
}

package com.key.d15_packeg_01.Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class example {
    public static void main(String[] args) {
        Movie m1 = new Movie("复仇者联盟","2021-4",8.4);
        Movie m2 = new Movie("红海行动","2019-7",9.2);
        Movie m3 = new Movie("一条狗的使命","2016-12",7.0);
        Collection<Movie> movie_list = new ArrayList<>();
        movie_list.add(m1);
        movie_list.add(m2);
        movie_list.add(m3);
        /*    这样打印的是对象地址
        Iterator iterator = movie_list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
         */
        for (Movie movie : movie_list) {
            //System.out.println(movie.getName());
            System.out.println("片名：" + movie.getName() + "\t" + "上映时间：" + movie.getTime() + "\t" + "得分：" + movie.getScores());
        }
    }
}

七、List集合

package com.key.d15_packeg_02.List;
import java.util.ArrayList;
import java.util.List;
public class List_demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("Python");
        list.add("MySQL");
        list.add("MSSQL");
        System.out.println(list);
        //在指定位置插入元素
        list.add(2,"Shiro");
        System.out.println(list);
        //删除指定位置元素，并返回删除的元素
        System.out.println(list.remove(2));
        System.out.println(list);
        //修改指定位置的元素，并返回被修改的元素
        System.out.println(list.set(2, "mysql"));
        System.out.println(list);
        //返回指定位置元素
        System.out.println(list.get(0));
    }
}

八、List集合遍历

package com.key.d15_packeg_02.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
public class List_demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("Python");
        list.add("MySQL");
        list.add("MSSQL");
        //1、迭代器
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("--------------------------");
        //2、foreach
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("--------------------------");
        //3、Lambda表达式
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s); 
            }
        });
        System.out.println("--------------------------");
        //4、for循环
        for (int x = 0; x < list.size(); x++){
            System.out.println(list.get(x));
        }
    }
}

那么开发中具体要使用哪种方式遍历呢？
（1）如果只是遍历数据，那么四种方式都一样
（2）如果要知道遍历到哪里去了，就应该使用for循环

九、LinkedList特点

package com.key.d15_packeg_02.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class LinkedList_demo {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("JAVA");
        list.add("Python");
        list.add("MySQL");
        list.add("MSSQL");
        System.out.println(list);
        System.out.println("--------------");
        //在开头插入指定元素
        list.addFirst("Shiro");
        System.out.println(list);
        System.out.println("--------------");
        //在结尾插入指定元素
        list.addLast("WebLogic");
        System.out.println(list);
        System.out.println("--------------");
        //返回第一个元素
        System.out.println(list.getFirst());
        System.out.println("--------------");
        //返回最后一个元素
        System.out.println(list.getLast());
        System.out.println("--------------");
        //删除第一个元素，并返回删除的元素
        System.out.println(list.removeFirst());
        System.out.println(list);
        System.out.println("--------------");
        //删除最后一个元素，并返回删除的元素
        System.out.println(list.removeLast());
        System.out.println(list);
        System.out.println("--------------");
    }
}

十、集合的遍历删除

package com.key.d15_packeg_02.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
public class test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("Python");
        list.add("MySQL");
        list.add("MSSQL");
        list.add("JAVA");
        list.add("Shiro");
        System.out.println(list);
        //System.out.println("删除集合中所有JAVA元素");
        //1、迭代器遍历删除
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            if ("JAVA".equals(iterator.next())){
                //list.remove("JAVA");  //用list.remove()删除会报错，因为删除操作后，元素前移了
                iterator.remove();  //删除当前所在元素，并且删除后元素不会前移
            }
        }
        System.out.println(list);
        //2、foreach遍历删除（一定会出问题，不能用foreach遍历删除元素）
        /*
        for (String s : list) {
            if ("JAVA".equals(s)){
                list.remove(s);
            }
        }
         */
        //3、Lambda表达式遍历删除元素（一定会出问题，不能用foreach遍历删除元素）
        /*
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                if ("JAVA".equals(s)){
                    list.remove(s);
                }
            }
        });
         */
        //4、for循环遍历删除（不会弹Bug，但是会漏删除元素）
        /*
        for (int i = 0; i < list.size(); i++){
            if ("JAVA" == list.get(i)){
                list.remove("JAVA");
            }
        }
         */
        //for循环遍历删除的解决方法一：倒着删除，从后向前删除
        for (int i = list.size() - 1; i >= 0 ; i--){
            if ("JAVA" == list.get(i)){
                list.remove("JAVA");
            }
        }
        System.out.println(list);
        //for循环遍历删除的解决方法二：正着删除，手动i--
        for (int i = 0; i < list.size(); i++){
            if ("JAVA" == list.get(i)){
                list.remove("JAVA");
                i--;
            }
        }
        System.out.println(list);
    }
}

十一、Set集合

1、HashSet

HashSet特点：无序，不重复，无索引

（1）LinkedHashSet

LinkedHashSet特点：有序，不重复，无索引

2、TreeSet

如果想要用TreeSet存储自定义类型的对象，如Students类等，需要自己制定培训规则

如何自定义排序？？？？

举个例子：
用TreeSet定义Students类，并按照学生年龄升序排列

package com.key.d15_packeg_04.Set;
public class Students implements Comparable<Students>{
    private String name;
    private int age;
    private String sex;
    public Students(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public Students() {
    }
    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;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "姓名" + this.name + "\t\t\t" + "年龄：" + this.age + "\t\t\t" + "性别：" + this.sex + "\n";
    }
    /**
     * 通过compareTo自定义比较规则
     * student1.compareTo(student2)     student1与student2进行比较
     * @param o
     * @return
     */
    @Override
    public int compareTo(Students o) {
        //自定义比较规则，按照年龄比较
        return this.age - o.age;
    }
}

�

package com.key.d15_packeg_04.Set;
import java.util.Set;
import java.util.TreeSet;
public class TreeSetDemo {
    public static void main(String[] args) {
        Set<String> treesets = new TreeSet<>();
        treesets.add("JAVA");
        treesets.add("Python");
        treesets.add("MYSQL");
        treesets.add("JAVA");
        treesets.add("MSSQL");
        treesets.add("About");
        System.out.println(treesets);
        System.out.println("-------------------------");
        Set<Students> stu = new TreeSet<>();
        stu.add(new Students("0ss7key",25,"man"));
        stu.add(new Students("zhangsan",20,"man"));
        stu.add(new Students("张小花",18,"woman"));
        System.out.println(stu);
    }
}

拓展知识：可变参数

举个例子：

package com.key.d15_packeg_05.params;
import java.util.Arrays;
public class test {
    public static void main(String[] args) {
        sum(10);    //可以传输一个参数
        sum(20,30); //可以传输多个参数，也可以传输数组
        sum();      //可以不传参
        sum(new int[]{10,20,30,40});    //传输数组
    }
    /**
     * 1、一个形参列表中只能有一个可变参数
     * 2、可变阐述要放在形参的最后声明
     * @param numbers
     */
    public static void sum(int...numbers){
        //可变参数在方法内部其实就是一个数组
        System.out.println("数组个数为：" + numbers.length);
        System.out.println("数组内容：" + Arrays.toString(numbers));
    }
}

拓展知识：集合工具类Collections

举个例子：

package com.key.d15_packeg_04.Set;
public class Students implements Comparable<Students>{
    private String name;
    private int age;
    private String sex;
    public Students(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public Students() {
    }
    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;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "姓名" + this.name + "\t\t\t" + "年龄：" + this.age + "\t\t\t" + "性别：" + this.sex + "\n";
    }
    /**
     * 通过compareTo自定义比较规则
     * student1.compareTo(student2)     student1与student2进行比较
     * @param o
     * @return
     */
    @Override
    public int compareTo(Students o) {
        //自定义比较规则，按照年龄比较
        return this.age - o.age;
    }
}

package com.key.d15_packeg_06.Collections;
import java.util.*;
public class CollectionsDemo1 {
    public static void main(String[] args) {
        /**
         * 给集合对象批量添加数据
         */
        Collection<String> list1 = new ArrayList<>();
        System.out.println("批量添加元素：");
        //list1.add("java");
        //list1.add("python");
        //list1.add("c++");
        Collections.addAll(list1,"java","python","c++");
        System.out.println(list1);
        System.out.println("---------------");
        /**
         * 打乱集合的顺序（只能打乱List集合的顺序）
         */
        //Collections.shuffle(list1);
        List<String> list2 = new ArrayList<>();
        System.out.println("打乱集合的顺序（只能打乱List集合的顺序）：");
        Collections.addAll(list2,"java","python","c++","mysql");
        Collections.shuffle(list2);
        System.out.println(list2);
        System.out.println("---------------");
        /**
         * 对集合中的元素进行排序（只能对List集合进行排序）
         */
        //按照默认规则进行排序
        Collections.sort(list2);
        System.out.println(list2);
        //按照指定规则进行排序，对Students类按照年龄进行升序排列
        //方式一：
        List<Students> stu = new ArrayList<>();
        stu.add(new Students("0ss7key",25,"man"));
        stu.add(new Students("zhangsan",20,"man"));
        stu.add(new Students("张小花",18,"woman"));
        Collections.sort(stu);
        System.out.println(stu);
        /**
         * 与TreeSet排序相同，需要通过Comparable进行排序
         */
        //方式二：sort()方法自带Comparator比较器
        Collections.sort(stu, new Comparator<Students>() {
            @Override
            public int compare(Students o1, Students o2) {
                return o2.getAge() - o1.getAge();
            }
        });
        System.out.println("-----------");
        System.out.println(stu);
    }
}

十二、Map集合

1、Map集合概述

2、Map集合特点

Map集合的键是无需不重复的，Map集合的值可以重复，不作要求

3、Map集合常用API

package com.key.d15_packeg_07.Map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapAPIdemo {
    public static void main(String[] args) {
        /**
         * Map集合常用API整理
         */
        Map<String,Integer> maps = new HashMap<>();
        //增加元素，put()
        maps.put("苹果",5);
        maps.put("香蕉",9);
        maps.put("《零基础学JAVA》",1);
        maps.put("《渗透测试指南》",2);
        maps.put("玩具",100);
        System.out.println(maps);
        System.out.println("---------------------");
        //根据键值删除元素，remove()
        maps.remove("香蕉");
        System.out.println(maps);
        System.out.println("---------------------");
        //判断集合是否包含指定键值，如果存在则返回true，不存在返回false
        System.out.println(maps.containsKey("苹果"));
        System.out.println("---------------------");
        //判断集合是否包含指定内容值，如果存在则返回true，不存在返回false
        System.out.println(maps.containsValue(100));
        System.out.println("---------------------");
        //判断集合是否为空，集合为空则返回true，不为空返回false
        System.out.println(maps.isEmpty());
        System.out.println("---------------------");
        //返回集合中键值对的个数
        System.out.println(maps.size());
        System.out.println("---------------------");
        //获取集合的所有键值（很重要，为遍历Maps集合做准备），keySet()
        Set<String> keylist = maps.keySet();
        System.out.println(keylist);
        System.out.println("---------------------");
        //获取集合的所有内容值，values()
        Collection<Integer> valuelist = maps.values();
        System.out.println(valuelist);
        System.out.println("---------------------");
        //清空集合
        maps.clear();
        System.out.println(maps);
        System.out.println("---------------------");
    }
}

扩展：合并其他Map集合

package com.key.d15_packeg_07.Map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapAPIdemo {
    public static void main(String[] args) {
        /**
         * Map集合常用API整理
         */
        Map<String,Integer> maps = new HashMap<>();
        //增加元素，put()
        maps.put("苹果",5);
        maps.put("香蕉",9);
        maps.put("《零基础学JAVA》",1);
        maps.put("《渗透测试指南》",2);
        maps.put("玩具",100);
        //合并Map集合，putAll()
        Map<String,Integer> maps1 = new HashMap<>();
        maps1.put("枪",1);
        maps1.put("子弹",666);
        maps1.putAll(maps);     //将maps集合合并到maps1中去
        System.out.println(maps1);
    }
}

4、Map集合的遍历方式

（1）键找值

        Map<String,Integer> maps = new HashMap<>();
        maps.put("苹果",5);
        maps.put("香蕉",9);
        maps.put("《零基础学JAVA》",1);
        maps.put("《渗透测试指南》",2);
        maps.put("玩具",100);
        /**
         *  键找值遍历集合
         */
        //1、先提取键值
        Set<String> key = maps.keySet();
        //2、遍历每个键，根据建提取值
        for (String s : key) {
            int value = maps.get(s);
            System.out.println(s + " ==> " + value);
        }

（2）键值对

        /**
         * 键值对遍历集合
         */
        //1、把Map集合转换为Set集合
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();  //可以用ctrl+alt快捷键直接不全转换
        //System.out.println(maps);
        //2、开始遍历
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey() + "==>" + entry.getValue());
        }

（3）Lambda表达式

        /**
         * Lambda表达式遍历集合
         */
        maps.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String key, Integer value) {
                System.out.println(key + "==>" + value);
            }
        });
        //Lambda表达式简化后：
        maps.forEach((k, v) -> {
                System.out.println(k + "==>" + v);
            });

5、Map集合案例程序编写

package com.key.d15_packeg_07.Map;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
/**
 * 统计投票人数
 */
public class Map_test {
    public static void main(String[] args) {
        //1、把学生投票结果传入集合中
        String[] place = {"A","B","C","D"};
        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            sb.append(place[r.nextInt(place.length)]);
        }
        System.out.println(sb);
        //2、定义一个Map集合记录投票结果
        Map<Character ,Integer> result = new HashMap<>();
        //3、遍历投票结果
        for (int i = 0; i < sb.length(); i++) {
            //4、择当前投票结果
            char ch = sb.charAt(i);
            //5、判断Map集合中是否存在这个键
            if (result.containsKey(ch)){
                //计数+1
                result.put(ch,result.get(ch) + 1);
            }else {
                //说明这个投票结果第一次出现，要放到Map集合中
                 result.put(ch,1);
            }
        }
        //6、输出Map集合
        System.out.println(result);
    }
}

6、Map集合的实现类HashMap

7、Map集合的实现类LinkedHashMap

8、Map集合的实现类TreeMap

举例：将Students类加入集合中，按照Students类的特点进行排序

package com.key.d15_packeg_07.Map;
public class Students implements Comparable<Students>{
    private String name;
    private int age;
    private String sex;
    public Students(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public Students() {
    }
    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;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "姓名" + this.name + "\t\t\t" + "年龄：" + this.age + "\t\t\t" + "性别：" + this.sex + "\n";
    }
    /**
     * 通过compareTo自定义比较规则
     * student1.compareTo(student2)     student1与student2进行比较
     * @param o
     * @return
     */
    @Override
    public int compareTo(Students o) {
        //自定义比较规则，按照年龄比较
        return this.age - o.age;
    }
}

package com.key.d15_packeg_07.Map;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
public class TreeMapDemo {
    public static void main(String[] args) {
        //TreeMap集合自带排序
        Map<Integer,String> treemap1 = new TreeMap<>();
        treemap1.put(1,"0ss7key");
        treemap1.put(13,"bob");
        treemap1.put(5,"jack");
        treemap1.put(4,"davi");
        System.out.println(treemap1);
        //自定义排序方式一：通过Comparable接口重写比较规则，按照年龄升序排列
        Map<Students,String> treemaps = new TreeMap<>();
        treemaps.put(new Students("0ss7key",25,"man"),"DaLian");
        treemaps.put(new Students("wangwu",29,"man"),"WuHan");
        treemaps.put(new Students("zhangxiaohua",18,"woman"),"SiChuan");
        System.out.println(treemaps);
        System.out.println("-----------------");
        //自定义排序方式二：集合自定义Comparator比较器对象，重写比较规则，按照年龄降序排列
        Map<Students,String> treemaps1 = new TreeMap<>(new Comparator<Students>() {
            @Override
            public int compare(Students o1, Students o2) {
                //return o2.getAge() - o1.getAge();
                return Integer.compare(o2.getAge(),o1.getAge());
            }
        });
        treemaps1.put(new Students("0ss7key",25,"man"),"DaLian");
        treemaps1.put(new Students("wangwu",29,"man"),"WuHan");
        treemaps1.put(new Students("zhangxiaohua",18,"woman"),"SiChuan");
        System.out.println(treemaps1);
        System.out.println("-----------------");
    }
}

十三、集合的嵌套

package com.key.d15_packeg_07.Map;
import java.util.*;
public class Map_test2 {
    public static void main(String[] args) {
        //1、记录每个学生的选择记录，用Map集合来存储
        Map<String, List<String>> choose = new HashMap<>();     //集合嵌套，因为一个学生可能会选择多个景点，所以这里用List集合代替选择结果
        //2、把选择的数据存入进去
        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"A","D");
        choose.put("张三",list1);
        //System.out.println(choose);
        List<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"A","B","D");
        choose.put("李四",list2);
        List<String> list3 = new ArrayList<>();
        Collections.addAll(list3,"C","D");
        choose.put("王五",list3);
        List<String> list4 = new ArrayList<>();
        Collections.addAll(list4,"A","B","C");
        choose.put("张小花",list4);
        List<String> list5 = new ArrayList<>();
        Collections.addAll(list5,"A","B","C","D");
        choose.put("刘涛",list5);
        System.out.println(choose);
        //3、统计每个景点选择的人数
        Map<String,Integer> result = new HashMap<>();
        //4、提取所有人选择的景点信息
        Collection<List<String>> values = choose.values();
        //System.out.println(values);
        for (List<String> value : values) {
            for (String s : value) {
                if (result.containsKey(s)){
                    result.put(s,result.get(s) + 1);
                }else {
                    result.put(s,1);
                }
            }
        }
        System.out.println(result);
    }
}

十四、不可变集合

package com.key.d15_packeg_07.Map;
import java.util.List;
public class bukebian {
    public static void main(String[] args) {
        List<Double> list = List.of(600.0,550.5,490.5,535.0);   //定义不可变集合
        System.out.println(list);
        //list.add(599.0);
    }
}

Java的集合进阶