• Java基础 - 9 - 集合进阶（二）

    一. Collection的其他相关知识

    1.1 可变参数

    可变参数就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型…参数名称;

    可变参数的特点和好处

    特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它

    好处：常常用来灵活的接收数据

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         //可变参数特点
    5.         method();  //不传数据
    6.         method(10);  //传一个数据
    7.         method(10,20,30);  //传多个数据
    8.         method(new int[]{1,2,3,4,5});  //传一个数组给可变参数
    9.  
    10.     }
    11.     //注意事项1：一个形参列表中，只能有一个可变参数
    12.     //注意事项2：可变参数必须放在形参列表的最后面
    13.     public static void method(int...nums){
    14.         //可变参数在方法内部本质就是一个数组
    15.         System.out.println(nums.length);
    16.         System.out.println(Arrays.toString(nums));
    17.         System.out.println("====================");
    18.     }
    19. }

    1.2 Collections

            Collections是一个用来操作集合的工具类

    Collections提供的常用静态方法

    方法名称说明
    public static boolean addAll(Collectionc , T…elements)给集合批量添加元素
    public static void shuffle(List list)打乱List集合中的元素顺序
    public static void sort(List list)对List集合中的元素进行升序排序
    public static void sort(List list , Comparatorc)对List集合中元素，按照比较器对象指定的规则进行排序

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         // 接收子类及其父类的类型
    5.         //public static  boolean addAll(Collectionc , T…elements)	给集合批量添加元素
    6.         List names = new ArrayList<>();
    7.         Collections.addAll(names,"张三","李四","王五","二麻子");  //批量添加，不用再一个个add了
    8.         System.out.println(names); //[张三, 李四, 王五, 二麻子]
    9.  
    10.         //public static void shuffle(List list)	打乱List集合中的元素顺序（List是有序、可重复、有索引）
    11.         Collections.shuffle(names);
    12.         System.out.println(names); //[二麻子, 王五, 张三, 李四]
    13.  
    14.         //public static  void sort(List list)	对List集合中的元素进行升序排序
    15.         List nums = new ArrayList<>();
    16.         Collections.addAll(nums,1,3,7,5,2);
    17.         System.out.println(nums); //[1, 3, 7, 5, 2]
    18.         Collections.sort(nums);
    19.         System.out.println(nums); //[1, 2, 3, 5, 7]
    20.  
    21.         List cars = new ArrayList<>();
    22.         Car c1 = new Car("奔驰",12.8);
    23.         Car c2 = new Car("宝马",14.1);
    24.         Car c3 = new Car("大众",9.9);
    25.         Car c4 = new Car("未来",14.1);
    26.         Collections.addAll(cars,c1,c2,c3,c4);
    27.         System.out.println(cars); //[Car{name='奔驰', price=12.8}, Car{name='宝马', price=14.1}, Car{name='大众', price=9.9}, Car{name='未来', price=14.1}]
    28.         //编译时异常（标红报错）：因为sort不知道自定义对象按照什么规则排序
    29.         //修改方式：让Car类实现Comparable（比较规则）接口，然后重写compareTo方法来指定比较规则
    30.         //Collections.sort(cars);
    31.         //System.out.println(cars); //[Car{name='大众', price=9.9}, Car{name='奔驰', price=12.8}, Car{name='宝马', price=14.1}, Car{name='未来', price=14.1}]
    32.  
    33.         //public static  void sort(List list , Comparatorc) 对List集合中元素，按照比较器对象指定的规则进行排序
    34.         Collections.sort(cars, new Comparator() {
    35.             @Override
    36.             public int compare(Car o1, Car o2) {
    37.                 //return Double.compare(o1.getPrice(),o2.getPrice());  //升序
    38.                 return Double.compare(o2.getPrice(),o1.getPrice());  //降序
    39.             }
    40.         });
    41.         System.out.println(cars);
    42.     }
    43. }
    44.  
    45. //Car
    46. public class Car implements Comparable {
    47.     private String name;
    48.     private double price;
    49.  
    50.     //this代表主调   o是被调
    51.     @Override
    52.     public int compareTo(Car o) {
    53.         //如果认为左边对象大于右边对象返回正整数
    54.         //如果认为左边对象小于右边对象返回负整数
    55.         //如果认为左边对象等于右边对象返回0
    56.         //需求：按照价格升序排序
    57.  
    58.         //return (int)(this.price-o.price); //不能这样写，返回值是int类型，两个double类型相减之后强转可能会出bug
    59.  
    60.         //写法1
    61. //        if(this.price>o.price){
    62. //            return 1;
    63. //        }else if(this.price
    64. //            return -1;
    65. //        }else{
    66. //            return 0;
    67. //        }
    68.  
    69.         //写法2
    70.         return Double.compare(this.price,o.price);
    71.     }
    72.  
    73.     //右键->生成->equals()和hashCode()
    74.     @Override
    75.     public boolean equals(Object o) {
    76.         if (this == o) return true;
    77.         if (o == null || getClass() != o.getClass()) return false;
    78.         Car car = (Car) o;
    79.         return Double.compare(car.price, price) == 0 &&
    80.                 Objects.equals(name, car.name);
    81.     }
    82.  
    83.     @Override
    84.     public int hashCode() {
    85.         return Objects.hash(name, price);
    86.     }
    87.  
    88.     public Car() {
    89.     }
    90.  
    91.     public Car(String name, double price) {
    92.         this.name = name;
    93.         this.price = price;
    94.     }
    95.  
    96.     public String getName() {
    97.         return name;
    98.     }
    99.  
    100.     public void setName(String name) {
    101.         this.name = name;
    102.     }
    103.  
    104.     public double getPrice() {
    105.         return price;
    106.     }
    107.  
    108.     public void setPrice(double price) {
    109.         this.price = price;
    110.     }
    111.  
    112.     @Override
    113.     public String toString() {
    114.         return "Car{" +
    115.                 "name='" + name + '\'' +
    116.                 ", price=" + price +
    117.                 '}';
    118.     }
    119. }

    1.3 综合案例 

    1. //demo
    2. public class demo {
    3.     public static void main(String[] args) {
    4.         //创建房间
    5.         Room r = new Room();
    6.         //启动游戏
    7.         r.start();
    8.     }
    9. }
    10.  
    11. //Room
    12. public class Room {
    13.     //必须有一副牌
    14.     private List allCards = new ArrayList<>();
    15.  
    16.     public Room(){
    17.         //做出54张牌，存入到集合allCards中
    18.         //点数
    19.         String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    20.         //花色
    21.         String[] colors = {"♣","♦","♠","♥"};
    22.         //遍历点数后再遍历花色，组织成牌
    23.         for (int i = 0; i < numbers.length; i++) {  //i不仅仅是numbers数组的索引，因为点数是按升序放在里面，所以正好还可以代表牌的大小
    24.             for (int j = 0; j < colors.length; j++) {
    25.                 Card card = new Card(numbers[i],colors[j],i);  //创建牌对象
    26.                 allCards.add(card);  //存到集合中
    27.             }
    28.         }
    29.  
    30.         //单独存放大小王
    31.         Card c1 = new Card("","👨",14); //大王
    32.         Card c2 = new Card("","👩",13); //小王
    33.         Collections.addAll(allCards,c1,c2); //存到集合中
    34.  
    35.         System.out.println("一副新牌："+allCards);
    36.     }
    37.  
    38.     //启动游戏
    39.     public void start() {
    40.         //洗牌
    41.         Collections.shuffle(allCards);
    42.         //创建三个玩家的手牌集合
    43.         List user1 = new ArrayList<>();
    44.         List user2 = new ArrayList<>();
    45.         List user3 = new ArrayList<>();
    46.         //发牌
    47.         //最后要剩余三张
    48.         for (int i = 0; i < allCards.size() - 3; i++) {
    49.             if(i%3==0){
    50.                 user1.add(allCards.get(i));
    51.             }else if(i%3==1){
    52.                 user2.add(allCards.get(i));
    53.             }else{
    54.                 user3.add(allCards.get(i));
    55.             }
    56.         }
    57.         //给玩家的牌进行降序排序
    58.         sortCards(user1);
    59.         sortCards(user2);
    60.         sortCards(user3);
    61.  
    62.         //玩家手牌情况
    63.         sortCards(user1);
    64.         System.out.println("玩家1的手牌：" + user1);
    65.         System.out.println("玩家2的手牌：" + user2);
    66.         System.out.println("玩家3的手牌：" + user3);
    67.  
    68.         //底牌
    69.         //System.out.println("底牌：" + allCards.get(51) + allCards.get(52) + allCards.get(53));
    70.         List diPai = allCards.subList(allCards.size()-3,allCards.size()); //截取集合的最后三个元素
    71.         System.out.println("底牌：" + diPai);
    72.  
    73.         //抢地主(假设抢地主的规则是：随机生成0 1 2，匹配地主)
    74.         Random r = new Random();
    75.         int diZhu = r.nextInt(3); //随机生成0，1，2
    76.         if(diZhu==0){
    77.             user1.addAll(diPai);
    78.             sortCards(user1);
    79.             System.out.println("玩家1抢地主后的手牌是：" + user1);
    80.         }else if (diZhu==1){
    81.             user2.addAll(diPai);
    82.             sortCards(user2);
    83.             System.out.println("玩家2抢地主后的手牌是：" + user2);
    84.         }else{
    85.             user3.addAll(diPai);
    86.             sortCards(user3);
    87.             System.out.println("玩家3抢地主后的手牌是：" + user3);
    88.         }
    89.     }
    90.  
    91.     private void sortCards(List user) {
    92.         Collections.sort(user, new Comparator() {
    93.             @Override
    94.             public int compare(Card o1, Card o2) {
    95.                 //return o1.getSize() - o2.getSize(); //升序排列
    96.                 return o2.getSize() - o1.getSize(); //降序排列
    97.             }
    98.         });
    99.     }
    100. }
    101.  
    102. //Card
    103. public class Card {
    104.     private String number;
    105.     private String color;
    106.     //每张牌存在大小
    107.     private int size; //0,1,2……
    108.  
    109.     public Card() {
    110.     }
    111.  
    112.     public Card(String number, String color, int size) {
    113.         this.number = number;
    114.         this.color = color;
    115.         this.size = size;
    116.     }
    117.  
    118.     public String getNumber() {
    119.         return number;
    120.     }
    121.  
    122.     public void setNumber(String number) {
    123.         this.number = number;
    124.     }
    125.  
    126.     public String getColor() {
    127.         return color;
    128.     }
    129.  
    130.     public void setColor(String color) {
    131.         this.color = color;
    132.     }
    133.  
    134.     public int getSize() {
    135.         return size;
    136.     }
    137.  
    138.     public void setSize(int size) {
    139.         this.size = size;
    140.     }
    141.  
    142.     @Override
    143.     public String toString() {
    144.         return color + number;
    145.     }
    146. }

    二. Map集合

    · Map集合称为双列集合，格式：{key1=value1,key2=value2,key3=value3,…}，一次需要存一对数据作为一个元素

    · Map集合的每个元素“key=value”称为一个键值对/键值对对象/一个Entry对象，Map集合也被叫做“键值对集合”

    · Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

    Map集合的应用场景

            需要存储一一对应的数据时，就可以考虑使用Map集合来做

    Map集合体系

    Map集合体系的特点

    注意：Map系列集合的特点都是由键决定的，值知识一个附属品，值是不做要求的

    · HashMap（由键决定特点）：无序、不重复、无索引（用的最多）

    · LinkedHashMap（由键决定特点）：有序、不重复、无索引

    · TreeMap（由键决定特点）：按照键的大小默认升序排序、不重复、无索引

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         Map map = new HashMap<>(); //多态
    5.         map.put("哇哈哈",3);
    6.         map.put("哇哈哈",2);  //重复数据（键重复），后加的数据会覆盖前加的
    7.         map.put("冰红茶",3);
    8.         map.put("农夫山泉",2);
    9.         map.put(null,null);
    10.         System.out.println(map);  //{null=null, 农夫山泉=2, 冰红茶=3, 哇哈哈=2} 无序，不重复，无索引
    11.  
    12.         Map map2 = new LinkedHashMap<>(); //多态
    13.         map2.put("哇哈哈",3);
    14.         map2.put("哇哈哈",2);  //重复数据（键重复），后加的数据会覆盖前加的
    15.         map2.put("冰红茶",3);
    16.         map2.put("农夫山泉",2);
    17.         map2.put(null,null);
    18.         System.out.println(map2);  //{哇哈哈=2, 冰红茶=3, 农夫山泉=2, null=null} 有序，不重复，无索引
    19.  
    20.         Map map3 = new TreeMap<>(); //多态
    21.         map3.put(1,"哇哈哈");
    22.         map3.put(2,"哇哈哈");  //重复数据（键重复），后加的数据会覆盖前加的
    23.         map3.put(3,"冰红茶");
    24.         map3.put(4,"农夫山泉");
    25.         System.out.println(map3);  //{1=哇哈哈, 2=哇哈哈, 3=冰红茶, 4=农夫山泉} 按照大小默认升序排序、不重复、无索引
    26.     }
    27. }

    2.1 Map集合常用方法 

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

    方法名称说明
    public V put(K key,V value)添加元素
    public int size()获取集合的大小
    public void clear()清空集合
    public boolean isEmpty()判断集合是否为空，为空返回true，反之返回false
    public V get(Object key)根据键获取对应值
    public V remove(Object key)根据键删除整个元素（删除键会返回键的值）
    public boolean containsKey(Object key)判断是否包含某个键，包含返回true，反之返回false
    public boolean containsValue(Object value)判断是否包含某个值

    public Set keySet()

    		获取Map集合的全部键
    public Collection values()获取Map集合的全部值
    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         Map map = new HashMap<>(); //多态
    5.         //1.添加元素
    6.         map.put("哇哈哈",3);
    7.         map.put("哇哈哈",2);  //重复数据（键重复），后加的数据会覆盖前加的
    8.         map.put("冰红茶",3);
    9.         map.put("农夫山泉",2);
    10.         map.put(null,null);
    11.         System.out.println(map);  //{null=null, 农夫山泉=2, 冰红茶=3, 哇哈哈=2} 无序，不重复，无索引
    12.  
    13.         //2.public int size() 获取集合的大小
    14.         System.out.println(map.size()); //4
    15.  
    16.         //3.public void clear()	清空集合
    17. //        map.clear();
    18. //        System.out.println(map); //{}
    19.  
    20.         //4.public boolean isEmpty()	判断集合是否为空，为空返回true，反之返回false
    21. //        System.out.println(map.isEmpty()); //true
    22.  
    23.         //5.public V get(Object key)	根据键获取对应值
    24.         System.out.println(map.get("哇哈哈")); //2
    25.         System.out.println(map.get("冰红茶")); //3
    26.         System.out.println(map.get(null)); //null
    27.         System.out.println(map.get("怡宝")); //null  根据键获取值的时候，如果键不存在，返回值也是null
    28.  
    29.         //6.public V remove(Object key)	根据键删除整个元素（删除键会返回键的值）
    30.         System.out.println(map.remove(null)); //null
    31.         System.out.println(map); //{农夫山泉=2, 冰红茶=3, 哇哈哈=2}
    32.  
    33.         //7.public boolean containsKey(Object key)	判断是否包含某个键，包含返回true，反之返回false
    34.         System.out.println(map.containsKey("农夫山泉")); //true
    35.         System.out.println(map.containsKey("怡宝")); //false
    36.  
    37.         //8.public boolean containsValue(Object value)	判断是否包含某个值
    38.         System.out.println(map.containsValue(2)); //true
    39.         System.out.println(map.containsValue(5)); //false
    40.         System.out.println(map.containsValue("2")); //false 要精确类型，整型2包含，字符2不包含
    41.  
    42.         //9.public Set keySet()	获取Map集合的全部键  返回是set集合（无序 不重复 无索引）
    43.         System.out.println(map.keySet()); //[农夫山泉, 冰红茶, 哇哈哈]
    44.  
    45.         //10.public Collection values()	获取Map集合的全部值 返回是Collection集合（因为键值对的值是可重复）
    46.         System.out.println(map.values()); //[2, 3, 2]
    47.  
    48.         //11.把其他Map集合的数据倒入到自己集合中来
    49.         Map map1 = new HashMap<>();
    50.         map1.put("绿茶",3);
    51.         map1.put("元气森林",5);
    52.         Map map2 = new HashMap<>();
    53.         map2.put("脉动",5);
    54.         map2.put("绿茶",4);
    55.         System.out.println(map1); //{绿茶=3, 元气森林=5}
    56.         System.out.println(map2); //{脉动=5, 绿茶=4}
    57.         map1.putAll(map2); //把map2集合中的元素全部倒入一份到map1集合中去（map2不会改变，相当于把map2的数据复制了一份给map1）
    58.         System.out.println(map1); //{脉动=5, 绿茶=4, 元气森林=5}
    59.         System.out.println(map2); //{脉动=5, 绿茶=4}
    60.     }
    61. }

    2.2 Map集合遍历方式

    2.2.1 键找值

            先获取Map集合全部的键，再通过遍历键来找值

    2.2.2 键值对

            把键值对堪称一个整体进行遍历

    2.2.3 Lambda表达式

            JDK1.8开始之后的新技术

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         Map map = new HashMap<>(); //多态
    5.         //添加元素
    6.         map.put("哇哈哈",3.0);
    7.         map.put("哇哈哈",2.0);  //重复数据（键重复），后加的数据会覆盖前加的
    8.         map.put("冰红茶",3.0);
    9.         map.put("农夫山泉",2.5);
    10.         map.put("脉动",5.5);
    11.         System.out.println(map);  //{脉动=5.5, 农夫山泉=2.5, 冰红茶=3.0, 哇哈哈=2.0} 无序，不重复，无索引
    12.  
    13.         System.out.println("-----------------------------");
    14.  
    15.         //Map集合遍历方式1——键找值
    16.         //先获取Map集合全部的键
    17.         Set keys_Set = map.keySet();
    18.         System.out.println(keys_Set); //[脉动, 农夫山泉, 冰红茶, 哇哈哈]
    19.         //再通过遍历键来找值，根据键获取其对应的值
    20.         for (String s : keys_Set) {
    21.             double value = map.get(s);
    22.             System.out.println(s+" "+value+"元");
    23.         }
    24.  
    25.         System.out.println("-----------------------------");
    26.  
    27.         //Map集合遍历方式2——键值对
    28.         //把键值对堪称一个整体进行遍历
    29.         //输入map.entrySet()后直接ctrl+alt+v 生成 Set> entries = map.entrySet();
    30.         Set> entries = map.entrySet();
    31.         System.out.println(entries); //[脉动=5.5, 农夫山泉=2.5, 冰红茶=3.0, 哇哈哈=2.0]
    32.         for (Map.Entry entry : entries) {
    33.             String key = entry.getKey();
    34.             double value = entry.getValue();
    35.             System.out.println(key+" "+value+"元");
    36.         }
    37.  
    38.         System.out.println("-----------------------------");
    39.  
    40.         //Map集合遍历方式3——Lambda表达式
    41.         //JDK1.8开始之后的新技术
    42.         map.forEach(new BiConsumer() {
    43.             @Override
    44.             public void accept(String s, Double aDouble) {
    45.                 System.out.println(s+" "+aDouble+"元");
    46.             }
    47.         });
    48.         //简化
    49.         System.out.println("-----------------------------");
    50.         map.forEach((s,aDouble) -> System.out.println(s+" "+aDouble+"元"));  //map.forEach((k,v) -> System.out.println(k+" "+v+"元"));
    51.     }
    52. }

    2.2.4 案例

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         List list = new ArrayList<>();  //用一个list存放学生的投票结果
    5.         Random r = new Random();
    6.         for (int i = 0; i < 80; i++) {
    7.             int choose = r.nextInt(4); //随机生成整数0，1，2，3
    8.             switch (choose){
    9.                 case 0:
    10.                     list.add('A');
    11.                     break;
    12.                 case 1:
    13.                     list.add('B');
    14.                     break;
    15.                 case 2:
    16.                     list.add('C');
    17.                     break;
    18.                 case 3:
    19.                     list.add('D');
    20.                     break;
    21.                 default:
    22.                     System.out.println("学生的选择不存在~~~");
    23.             }
    24.         }
    25.         System.out.println(list);
    26.         Map map = new HashMap<>(); //创建一个map集合存放投票统计结果
    27.         for (int i = 0; i < list.size(); i++) {
    28.             char key = list.get(i);  //用key保存当前的字符
    29.             //判断是否包含某个键（c的值）
    30.             if(map.containsKey(key)){  //包含（说明这个景点统计过）
    31.                 map.put(key,map.get(key)+1); //get方法返回的是键对应的值
    32.             }else{ //不包含（说明这个景点没统计过）
    33.                 map.put(key,1);
    34.             }
    35.         }
    36.         System.out.println(map);
    37.     }
    38. }

    2.3 HashMap

    HashMap集合的特点

            HashMap（由键决定特点）：无序、不重复、无索引（用的最多）

    HashMap集合的底层原理

            HashMap跟HashSet的底层原理是一致的，都是基于哈希表实现的（实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据）

            HashMap集合是一种增删改查数据，性能都较好的集合

            HashMap的键依赖hashCode方法和equals方法保证键的唯一

            如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的

    哈希表

            JDK8之前，哈希表=数组+链表

            JDK8开始，哈希表=数组+链表+红黑树

             哈希表是一种增删改查数据，性能都较好的数据结构

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         Map map = new HashMap<>();
    5.         map.put(new Car("奔驰",13.14),"made in C");
    6.         map.put(new Car("奔驰",13.14),"made in H");
    7.         map.put(new Car("宝马",13.13),"made in C");
    8.         System.out.println(map);
    9.         //如果不重写HashCode方法和equals方法，会保存两个Car{name='奔驰', price=13.14}数据
    10.         //{Car{name='奔驰', price=13.14}=made in H, Car{name='奔驰', price=13.14}=made in C, Car{name='宝马', price=13.13}=made in C}
    11.         //重写后
    12.         //{Car{name='宝马', price=13.13}=made in C, Car{name='奔驰', price=13.14}=made in H}
    13.     }
    14. }
    15.  
    16. //Car
    17. public class Car implements Comparable {
    18.     private String name;
    19.     private double price;
    20.  
    21.     //this代表主调   o是被调
    22.     @Override
    23.     public int compareTo(Car o) {
    24.         //如果认为左边对象大于右边对象返回正整数
    25.         //如果认为左边对象小于右边对象返回负整数
    26.         //如果认为左边对象等于右边对象返回0
    27.         //需求：按照价格升序排序
    28.  
    29.         //return (int)(this.price-o.price); //不能这样写，返回值是int类型，两个double类型相减之后强转可能会出bug
    30.  
    31.         //写法1
    32. //        if(this.price>o.price){
    33. //            return 1;
    34. //        }else if(this.price
    35. //            return -1;
    36. //        }else{
    37. //            return 0;
    38. //        }
    39.  
    40.         //写法2
    41.         return Double.compare(this.price,o.price);
    42.     }
    43.  
    44.     //右键->生成->equals()和hashCode()
    45.     @Override
    46.     public boolean equals(Object o) {
    47.         if (this == o) return true;
    48.         if (o == null || getClass() != o.getClass()) return false;
    49.         Car car = (Car) o;
    50.         return Double.compare(car.price, price) == 0 &&
    51.                 Objects.equals(name, car.name);
    52.     }
    53.  
    54.     @Override
    55.     public int hashCode() {
    56.         return Objects.hash(name, price);
    57.     }
    58.  
    59.     public Car() {
    60.     }
    61.  
    62.     public Car(String name, double price) {
    63.         this.name = name;
    64.         this.price = price;
    65.     }
    66.  
    67.     public String getName() {
    68.         return name;
    69.     }
    70.  
    71.     public void setName(String name) {
    72.         this.name = name;
    73.     }
    74.  
    75.     public double getPrice() {
    76.         return price;
    77.     }
    78.  
    79.     public void setPrice(double price) {
    80.         this.price = price;
    81.     }
    82.  
    83.     @Override
    84.     public String toString() {
    85.         return "Car{" +
    86.                 "name='" + name + '\'' +
    87.                 ", price=" + price +
    88.                 '}';
    89.     }
    90. }

    2.4 LinkedHashMap

    LinkedHashMap集合的特点

            LinkedHashMap（由键决定特点）：有序、不重复、无索引

    LinkedHashMap集合的底层原理

            LinkedHashMap集合也是基于哈希表（数组、链表、红黑树）实现的，但是它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置（保证有序）

            实际上，LinkedHashSet集合的底层原理就是LinkedHashMap

    2.5 TreeMap

    TreeMap集合的特点

            TreeMap（由键决定特点）：按照键的大小默认升序排序（只能对键排序）、不重复、无索引

    TreeMap集合的底层原理

            TreeMap和TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序

    注意：

            · 对于数值类型：Integer，Double，默认按照数值本身的大小进行升序排序

            · 对于字符串类型：默认按照首字符的编号升序排序

            · 对于自定义类型如Student对象，TreeSet默认是无法直接排序的

    TreeMap集合支持两种方式来指定排序规则

    方式一

    · 让自定义的类实现Comparable接口，重写里面的compareTo方法来指定比较规则

    方式二

    · 通过调用TreeSet集合有参数构造器，可以设置Comparator对象（比较器对象），用于指定比较规则

            public TreeSet(Comparator comparator)

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         Map map = new TreeMap<>(new Comparator() {
    5.             @Override
    6.             public int compare(Car o1, Car o2) {
    7.                 return Double.compare(o2.getPrice(),o1.getPrice());  //降序
    8.             }
    9.         });
    10.         // Map map = new TreeMap<>((o1, o2) -> Double.compare(o2.getPrice(),o1.getPrice()));
    11.         map.put(new Car("奔驰",13.14),"made in C");
    12.         map.put(new Car("奔驰",13.14),"made in H");
    13.         map.put(new Car("宝马",13.13),"made in C");
    14.         System.out.println(map);
    15.         //对于自定义类型，TreeSet默认是无法直接排序的，会产生ClassCastException异常
    16.         //升序：{Car{name='宝马', price=13.13}=made in C, Car{name='奔驰', price=13.14}=made in H}
    17.         //降序：{Car{name='奔驰', price=13.14}=made in H, Car{name='宝马', price=13.13}=made in C}
    18.     }
    19. }
    20.  
    21. //Car
    22. public class Car implements Comparable {
    23.     private String name;
    24.     private double price;
    25.  
    26.     //this代表主调   o是被调
    27.     @Override
    28.     public int compareTo(Car o) {
    29.         //如果认为左边对象大于右边对象返回正整数
    30.         //如果认为左边对象小于右边对象返回负整数
    31.         //如果认为左边对象等于右边对象返回0
    32.         //需求：按照价格升序排序
    33.         return Double.compare(this.price,o.price);
    34.     }
    35.  
    36.     //右键->生成->equals()和hashCode()
    37.     @Override
    38.     public boolean equals(Object o) {
    39.         if (this == o) return true;
    40.         if (o == null || getClass() != o.getClass()) return false;
    41.         Car car = (Car) o;
    42.         return Double.compare(car.price, price) == 0 &&
    43.                 Objects.equals(name, car.name);
    44.     }
    45.  
    46.     @Override
    47.     public int hashCode() {
    48.         return Objects.hash(name, price);
    49.     }
    50.  
    51.     public Car() {
    52.     }
    53.  
    54.     public Car(String name, double price) {
    55.         this.name = name;
    56.         this.price = price;
    57.     }
    58.  
    59.     public String getName() {
    60.         return name;
    61.     }
    62.  
    63.     public void setName(String name) {
    64.         this.name = name;
    65.     }
    66.  
    67.     public double getPrice() {
    68.         return price;
    69.     }
    70.  
    71.     public void setPrice(double price) {
    72.         this.price = price;
    73.     }
    74.  
    75.     @Override
    76.     public String toString() {
    77.         return "Car{" +
    78.                 "name='" + name + '\'' +
    79.                 ", price=" + price +
    80.                 '}';
    81.     }
    82. }

    2.6 集合的嵌套

            集合的嵌套指的是集合中的元素又是一个集合

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         Set set1 = new HashSet<>();
    5. //        set1.add("南京市");
    6. //        set1.add("扬州市");
    7. //        set1.add("苏州市");
    8.         //用Collection批量加入
    9.         Collections.addAll(set1,"南京市","扬州市","苏州市");
    10.         Set set2 = new HashSet<>();
    11. //        set2.add("武汉市");
    12. //        set2.add("宜昌市");
    13. //        set2.add("鄂州市");
    14.         Collections.addAll(set2,"武汉市","宜昌市","鄂州市");
    15.         Map> map = new HashMap<>();
    16.         map.put("江苏省",set1);
    17.         map.put("湖北省",set2);
    18.         
    19.         System.out.println(map);
    20.         System.out.println("湖北省："+map.get("湖北省"));
    21.  
    22.         //Lambda表达式 遍历
    23.         map.forEach((k,v) -> System.out.println(k+"："+v));
    24.     }
    25. }

    三. Stream流

            Stream也叫Stream流，是JDK8开始新增的一套API（java.util.stream.*），可以用于操作集合或者数组的数据

    优势：Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好

    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         List names = new ArrayList<>();
    5.         Collections.addAll(names,"张三","李四","张二二","王五","张老六");
    6.         System.out.println(names);  //[张三, 李四, 张二二, 王五, 张老六]
    7.  
    8.         //找出姓张，且是3个字的名字，存入到一个新集合中
    9.         List name_Zhang = new ArrayList<>();
    10.         for (String name : names) {
    11.             if(name.startsWith("张") && name.length()==3){
    12.                 name_Zhang.add(name);
    13.             }
    14.         }
    15.         System.out.println(name_Zhang); //[张二二, 张老六]
    16.  
    17.         //用Stream流实现
    18.         List name_Z = names.stream().filter(s -> s.startsWith("张"))
    19.                                             .filter(s -> s.length()==3).collect(Collectors.toList());
    20.         System.out.println(name_Z); //[张二二, 张老六]
    21.     }
    22. }

    3.1 获取Stream流

            获取集合的Stream流

    Collection提供的方法说明
    default Stream stream()获取当前集合对象的Stream流

            获取数组的Stream流

    Arrays类提供的方法说明
    public static Stream stream(T[] array)获取当前数组的Stream流
    Stream类提供的方法说明
    public static Stream of(T… values)获取当前接收数据的Stream流
    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         //List集合的Stream流
    5.         List names1 = new ArrayList<>();
    6.         Collections.addAll(names1,"张三","李四","张二二","王五","张老六");
    7.         System.out.println(names1);  //[张三, 李四, 张二二, 王五, 张老六]
    8.         Stream stream1 = names1.stream();
    9.         stream1.filter(s -> s.length()==2).forEach(s -> System.out.println(s));
    10.  
    11.         System.out.println("====================================");
    12.  
    13.         //Set集合的Stream流
    14.         Set names2 = new HashSet<>();
    15.         Collections.addAll(names2,"周一","周二","周三","周末","小周");
    16.         System.out.println(names2);  //[周一, 小周, 周末, 周三, 周二]
    17.         Stream stream2 = names2.stream();
    18.         stream2.filter(s -> s.startsWith("周")).forEach(s -> System.out.println(s));
    19.  
    20.         System.out.println("====================================");
    21.  
    22.         //Map集合的Stream流
    23.         Map map = new HashMap<>();
    24.         map.put("哇哈哈",3.0);
    25.         map.put("冰红茶",3.0);
    26.         map.put("农夫山泉",2.5);
    27.         map.put("脉动",5.5);
    28.         System.out.println(map);  //{脉动=5.5, 农夫山泉=2.5, 冰红茶=3.0, 哇哈哈=3.0}
    29.         //不能直接map.stream()，因为stream()方法是Collection提供的
    30.         Set keys = map.keySet();
    31.         Stream ks = keys.stream();
    32.  
    33.         Collection values = map.values();
    34.         Stream vs = values.stream();
    35.  
    36.         Set> entries = map.entrySet();
    37.         Stream> kvs = entries.stream();
    38.         kvs.filter(e -> e.getKey().contains("哈")).forEach(s -> System.out.println(s));
    39.  
    40.         System.out.println("====================================");
    41.  
    42.         //数组的Stream流
    43.         String[] names3 = {"Nike","Nim","Mike","Helen"};
    44.         System.out.println(Arrays.toString(names3));
    45.         Stream stream3 = Arrays.stream(names3);
    46.         Stream stream3_1 = Stream.of(names3);
    47.  
    48.         stream3.filter(s->s.contains("i")).forEach(s-> System.out.println(s));
    49.         System.out.println("====================================");
    50.         stream3_1.filter(s->s.length()==5).forEach(s-> System.out.println(s));
    51.     }
    52. }

    3.2 Stream流常见的中间方法

            中间方法指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程）

    Stream提供的常用中间方法说明
    Stream filter(Predicate predicate)用于对流中的数据进行过滤
    Stream sorted()对元素进行升序排序
    Stream sorted(Comparator comparator)按照指定规则排序
    Stream limit(long maxSize)获取前几个元素
    Stream skip(long n)跳过前几个元素
    Stream distinct()去除流中重复的元素
    Stream map(Function mapper)对元素进行加工，并返回对应的新流
    static Stream concat(Stream a , Stream b)合并a和b两个流为一个流
    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         List prices = new ArrayList<>();
    5.         Collections.addAll(prices,12.13,13.0,15.0,17.0,15.4,11.0);
    6.         //需求：找出价格超过15的数据，并升序排序，再输出
    7.         prices.stream().filter(s -> s>=15).sorted().forEach(s -> System.out.println(s));
    8.         System.out.println("========================================");
    9.  
    10.  
    11.         List students = new ArrayList<>();
    12.         Student s1 = new Student("张三","男",79,22);
    13.         Student s2 = new Student("张三","男",79,22);
    14.         Student s3 = new Student("李四","男",89.5,21);
    15.         Student s4 = new Student("王五","男",98,21);
    16.         Student s5 = new Student("小美","女",57.5,21);
    17.         Student s6 = new Student("小新","女",100,20);
    18.         Student s7 = new Student("小海","男",88,19);
    19.         Collections.addAll(students,s1,s2,s3,s4,s5,s6,s7);
    20.  
    21.         //需求：找出成绩在85-95（包括85和95）之间的学生，并按照成绩降序排序
    22.         students.stream().filter(s -> s.getScore()>=85 && s.getScore()<=95)
    23.                             .sorted((o1, o2) -> Double.compare(o2.getScore(),o1.getScore()))
    24.                             .forEach(s -> System.out.println(s));
    25.         System.out.println("========================================");
    26.  
    27.         //需求：取出成绩前三的学生，并输出
    28.             //先按照成绩降序排序再取出前三名
    29.         students.stream().sorted((o1,o2)->Double.compare(o2.getScore(),o1.getScore()))
    30.                             .limit(3).forEach(s -> System.out.println(s));
    31.         System.out.println("========================================");
    32.  
    33.         //需求：取出年纪最小的两个学生，并输出
    34.         students.stream().sorted((o1,o2) -> o1.getAge()-o2.getAge())
    35.                             .limit(2).forEach(s -> System.out.println(s));
    36.         System.out.println("========================================");
    37.  
    38.         //需求：取出年纪最大的两个学生，并输出
    39.         students.stream().sorted((o1,o2) -> o1.getAge()-o2.getAge())
    40.                             .skip(students.size()-2).forEach(s -> System.out.println(s));
    41.         System.out.println("========================================");
    42.  
    43.         //需求：找出年纪大于20岁的学生叫什么名字，要求去除重复名字，再输出
    44.         students.stream().filter(s -> s.getAge() > 20)
    45.                             .map(s -> s.getName())   //把这个流加工成只剩下名字
    46.                             .distinct().forEach(s -> System.out.println(s));
    47.         //distinct去重复，针对自定义类型的对象，如果希望内容一样就认为重复，需要重写HashCode和equals方法，不重写就不会去重复
    48.         students.stream().filter(s -> s.getAge() > 20)
    49.                             .distinct().forEach(s -> System.out.println(s));
    50.  
    51.  
    52.         Stream st1 = Stream.of("张三","李四");  //Stream.of()获取数组的stream流
    53.         Stream st2 = Stream.of("王五","李四");
    54.         Stream.concat(st1,st2).forEach(System.out::println);
    55.  
    56.         Stream st3 = Stream.of(1,2,3);
    57.         Stream st4 = Stream.of(5.2,7.7);
    58.         Stream.concat(st3,st4).forEach(System.out::println);
    59.     }
    60. }
    61.  
    62. //Student
    63. public class Student {
    64.     private String name;  //姓名
    65.     private String sex;  //性别
    66.     private double score;  //成绩
    67.     private int age;  //年龄
    68.  
    69.     public Student() {
    70.     }
    71.  
    72.     public Student(String name, String sex, double score, int age) {
    73.         this.name = name;
    74.         this.sex = sex;
    75.         this.score = score;
    76.         this.age = age;
    77.     }
    78.  
    79.     @Override
    80.     public boolean equals(Object o) {
    81.         if (this == o) return true;
    82.         if (o == null || getClass() != o.getClass()) return false;
    83.         Student student = (Student) o;
    84.         return Double.compare(student.score, score) == 0 &&
    85.                 age == student.age &&
    86.                 Objects.equals(name, student.name) &&
    87.                 Objects.equals(sex, student.sex);
    88.     }
    89.  
    90.     @Override
    91.     public int hashCode() {
    92.         return Objects.hash(name, sex, score, age);
    93.     }
    94.  
    95.     public String getName() {
    96.         return name;
    97.     }
    98.  
    99.     public void setName(String name) {
    100.         this.name = name;
    101.     }
    102.  
    103.     public String getSex() {
    104.         return sex;
    105.     }
    106.  
    107.     public void setSex(String sex) {
    108.         this.sex = sex;
    109.     }
    110.  
    111.     public double getScore() {
    112.         return score;
    113.     }
    114.  
    115.     public void setScore(double score) {
    116.         this.score = score;
    117.     }
    118.  
    119.     public int getAge() {
    120.         return age;
    121.     }
    122.  
    123.     public void setAge(int age) {
    124.         this.age = age;
    125.     }
    126.  
    127.     @Override
    128.     public String toString() {
    129.         return "Student{" +
    130.                 "name='" + name + '\'' +
    131.                 ", sex='" + sex + '\'' +
    132.                 ", score=" + score +
    133.                 ", age=" + age +
    134.                 '}';
    135.     }
    136. }

    3.3 Stream流常见的终结方法

            终结方法指的是调用完成后，不会返回新Stream了，没有继续使用流了

    Stream提供的常用终结方法说明
    void forEach(Consumer action)对此流运算后的元素执行遍历
    long count()统计此流运算后的元素个数
    Optional max(Comparator comparator)获取此流运算后的最大值元素
    Optional min(Comparator comparator)获取此流运算后的最小值元素

    收集Stream流

            收集Stream流就是把Stream流操作后的结果转回到集合或者数组中去返回

            Stream流：方便操作集合/数组的手段；  集合/数组：才是开发中的目的

    Stream提供的常用终结方法说明
    R collect(Collector collector)把流处理后的结果收集到一个指定的集合中去
    Object[] toArray()把流处理后的结果收集到一个数组中去
    Collectors工具类提供的具体的收集方法说明
    public static Collector toList()把元素收集到List集合中
    public static Collector toSet()把元素收集到Set集合中
    public static Collector toMap(Function keyMapper , Function valueMapper)把元素收集到Map集合中
    1. //demo
    2. public class demo{
    3.     public static void main(String[] args){
    4.         List students = new ArrayList<>();
    5.         Student s1 = new Student("张三","男",79,22);
    6.         Student s2 = new Student("张三","男",79,22);
    7.         Student s3 = new Student("李四","男",89.5,21);
    8.         Student s4 = new Student("王五","男",98,21);
    9.         Student s5 = new Student("小美","女",57.5,21);
    10.         Student s6 = new Student("小新","女",100,20);
    11.         Student s7 = new Student("小海","男",88,19);
    12.         Collections.addAll(students,s1,s2,s3,s4,s5,s6,s7);
    13.         //需求：计算出成绩>=90的学生人数
    14.             //long count()	统计此流运算后的元素个数
    15.         long sum = students.stream().filter(s -> s.getScore()>=90).count();
    16.         System.out.println(sum);  //2
    17.  
    18.         //需求：找出成绩最高的学生对象并输出
    19.             //Optional max(Comparator comparator)	获取此流运算后的最大值元素
    20.         Optional o_max = students.stream().max((o1, o2) -> Double.compare(o1.getScore(),o2.getScore()));
    21.         System.out.println(o_max); //Optional[Student{name='小新', sex='女', score=100.0, age=20}]
    22.         System.out.println(o_max.get()); //Student{name='小新', sex='女', score=100.0, age=20}
    23.  
    24.         //需求：找出成绩最低的学生对象并输出
    25.             //Optional min(Comparator comparator)	获取此流运算后的最小值元素
    26.         Optional o_min = students.stream().min((o1, o2) -> Double.compare(o1.getScore(),o2.getScore()));
    27.         System.out.println(o_min.get()); //Student{name='小美', sex='女', score=57.5, age=21}
    28.  
    29.  
    30.         //收集Stream流
    31.         //需求：找出成绩在75-90之间的学生对象，并放到一个新集合中去返回
    32.         //流只能收集一次
    33.         //放到List集合中
    34.         List list = students.stream().filter(s -> s.getScore()>75 && s.getScore()<90).collect(Collectors.toList());
    35.         System.out.println(list);
    36.         //[Student{name='张三', sex='男', score=79.0, age=22}, Student{name='张三', sex='男', score=79.0, age=22}, Student{name='李四', sex='男', score=89.5, age=21}, Student{name='小海', sex='男', score=88.0, age=19}]
    37.  
    38.         //放到Set集合中
    39.         Set set = students.stream().filter(s -> s.getScore()>75 && s.getScore()<90).collect(Collectors.toSet());
    40.         System.out.println(set);
    41.         //[Student{name='李四', sex='男', score=89.5, age=21}, Student{name='张三', sex='男', score=79.0, age=22}, Student{name='小海', sex='男', score=88.0, age=19}]
    42.         //Set中去把两个张三去重了（因为重写了HashCode和equals方法，不重写则不去重）
    43.  
    44.         //需求：找出成绩在75-90之间的学生对象，并把学生对象的名字和成绩，存放到一个Map集合中返回
    45.         Map map = students.stream().filter(s -> s.getScore() > 75 && s.getScore() < 90)
    46.                                                     .distinct().collect(Collectors.toMap(k -> k.getName(), v -> v.getScore()));
    47.         System.out.println(map); //{李四=89.5, 张三=79.0, 小海=88.0}
    48.  
    49.         Object[] objects = students.stream().filter(s -> s.getScore() > 75 && s.getScore() < 90).toArray();
    50.         System.out.println(Arrays.toString(objects));
    51.         Student[] stu = students.stream().filter(s -> s.getScore() > 75 && s.getScore() < 90).toArray(len -> new Student[len]);
    52.         System.out.println(Arrays.toString(stu));
    53.  
    54.     }
    55. }
    56.  
    57. //Student
    58. public class Student {
    59.     private String name;  //姓名
    60.     private String sex;  //性别
    61.     private double score;  //成绩
    62.     private int age;  //年龄
    63.  
    64.     public Student() {
    65.     }
    66.  
    67.     public Student(String name, String sex, double score, int age) {
    68.         this.name = name;
    69.         this.sex = sex;
    70.         this.score = score;
    71.         this.age = age;
    72.     }
    73.  
    74.     @Override
    75.     public boolean equals(Object o) {
    76.         if (this == o) return true;
    77.         if (o == null || getClass() != o.getClass()) return false;
    78.         Student student = (Student) o;
    79.         return Double.compare(student.score, score) == 0 &&
    80.                 age == student.age &&
    81.                 Objects.equals(name, student.name) &&
    82.                 Objects.equals(sex, student.sex);
    83.     }
    84.  
    85.     @Override
    86.     public int hashCode() {
    87.         return Objects.hash(name, sex, score, age);
    88.     }
    89.  
    90.     public String getName() {
    91.         return name;
    92.     }
    93.  
    94.     public void setName(String name) {
    95.         this.name = name;
    96.     }
    97.  
    98.     public String getSex() {
    99.         return sex;
    100.     }
    101.  
    102.     public void setSex(String sex) {
    103.         this.sex = sex;
    104.     }
    105.  
    106.     public double getScore() {
    107.         return score;
    108.     }
    109.  
    110.     public void setScore(double score) {
    111.         this.score = score;
    112.     }
    113.  
    114.     public int getAge() {
    115.         return age;
    116.     }
    117.  
    118.     public void setAge(int age) {
    119.         this.age = age;
    120.     }
    121.  
    122.     @Override
    123.     public String toString() {
    124.         return "Student{" +
    125.                 "name='" + name + '\'' +
    126.                 ", sex='" + sex + '\'' +
    127.                 ", score=" + score +
    128.                 ", age=" + age +
    129.                 '}';
    130.     }
    131. }
  • 相关阅读:
    Android 查看当前手机、APP的ABI架构信息
    Python实现PPT演示文稿中视频的添加、替换及提取
    Java String.format()方法具有什么功能呢？
    【Matlab】欧拉公式、梯形公式和改进欧拉公式求解常微分方程
    Android11 桌面默认横屏导致任务键近期任务布局UI显示错误！
    rabbitMQ:绑定Exchange发送和接收消息（direct）
    Apache Dubbo的@SPI接口应用
    【python学习】-列表的使用(添加/移除元素、寻找指定元素索引、列表复制等)
    深入理解python虚拟机：程序执行的载体——栈帧
    leetCode 72. 编辑距离 动态规划 + 滚动数组 + 优化空间
  • 原文地址：https://blog.csdn.net/qq_50755868/article/details/136718071