Java_集合框架(二)

Map集合

概述

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

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

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

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

5. Map集合体系

   graph TB;
       Map-->HashMap
       Map-->......
       Map-->TreeMap
       HashMap-->LinkedHashMap

6. Map集合体系特点：

   • 注意：Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的
   • HashMap（由键决定特点）：无序、不重复、无索引（用的最多）
   • LinkedHashMap（由键决定特点）：由键决定的特点：有序、不重复、无索引。
   • TreeMap（由键决定特点）：按照大小默认升序排序、不重复、无索引。

常用方法

1. 为什么要先学习Map的常用方法？

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

2. Map的常用方法：

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

遍历方式

1. Map集合的遍历方式：

   • 键找值：先获取Map集合全部的键，再通过遍历键来找值
   • 键值对：把“键值对”看成一个整体进行遍历（难度较大）
   • Lambda：JDK1.8 开始之后的新技术（非常的简单）

2. 键找值：

   • 使用该方法遍历map集合，需要用到以下方法：

     方法名称	说明
     public Set<K> keySet()	获取所有键的集合
     public V get(Object key)	根据键获取其对应的值

   • 代码实现：

     Map<String, Double> map = new HashMap<>();
     Set<String> keys = map.keySet();
     
     for (String key : keys){
     	double value = map.get(key);
     	System.out.println(key + "-->" + value);
     }

3. 键值对：

   • 使用该方法遍历map集合，需用到以下方法：

     Map提供的方法	说明
     Set<Map.Entey<K, V>> entrySet()	获取所有“键值对”的集合

     Map.Entry提供的方法	说明
     K getKey()	获取键
     V getValue()	获取值

   • 代码实现：

     Map<String, Double> map = new HashMap<>()
     
     Set<Map.Entry<String, Double>> entries = map.entrySet();
     for (Map.Entry<String, Double> entry : entries) {
     	String key = entry.getKey();
     	double value = entry.getValue();
     	System.out.println(key + "-->" + value);
     }

4. Lambda：

   • 使用该方法遍历map集合，需用到以下方法：

     方法名称	说明
     default void forEach(BiConsumer<? K, ? super V> action)	结合lambda遍历Map集合

   • 代码实现：

     // 使用Lambda表达式前代码
     map.forEach(new BiConsumer<String, Double>() {
         @Override
         public void accept(String key, Double value) {
         	System.out.println(key + "-->" + value);
         }
     });
     
     // 使用Lambda表达式简化
     map.forEach((key, value )->{
     	System.out.println(key + "-->" + value);
     });

HashMap

  1. HashMap特点：无序、不重复、无索引（用的最多）
 2. HashMap和跟HashSet的底层原理是一模一样的，都是基于哈希表实现的
 3. 实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。
 4. 哈希表：
    - JDK8之前，哈希表 = 数组 + 链表
    - JDK8之后，哈希表 = 数组 + 链表 + 红黑树
    - 哈希表是一种增删改查数据，性能都较好的数据结构

5. HashMap底层原理是基于哈希表实现的
   - HashMap集合是一种增删改查数据，性能都较好的集合
   - 但是它是无序，不能重复，没有索引支持的（由键值决定特点）
   - HashMap的键依赖`hashCode`和`equals`方法保证键的唯一
   - 如果键存储的是自定义类型的对象，可以通过重写`hashCode`和`equals`方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。

LinkedHashMap

1. LinkedHashMap特点：由键决定的特点：有序、不重复、无索引。
2. LinkedHashMap集合的底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外多了一个双链表机制记录元素顺序（保证有序）。
3. 实际上：原来学的LinkedHashSet集合的底层原理就是LinkedHashMap。

TreeMap

1. TreeMap特点：不重复、无索引、可排序（按照键的大小默认升序排序，只能对键排序）

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

3. TreeMap集合同样也支持两种方式来指定排序规则

   • 让类实现Comparable接口，重写比较规则。
   • TreeMap集合有一个有参构造器，支持创建Comparator比较器对象，以便来指定比较规则。

补充知识：集合的嵌套

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

JDK8新特性：Stream

认识Stream流

1. 什么是Stream？

   • 也叫Stream流，是JDK8开始新增的一套API（java.util.stream.*），可以用于操作集合或者数组的数据。
   • 优势：Stream流大量结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组的数据，代码更简洁，可读性更好

2. Stream流的使用步骤：

   

Stream流的常用方法

1. 获取Stream流

   • 获取 集合 的Stream流

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

   • 获取 数组 的Stream流

     Arrays类提供的如下方法	说明
     public static <T> Stream<T> stream(T[] array)	获取当前数组的Stream流

     Stream类提供的如下方法	说明
     public static <T> Stream<T> of(T... values)	获取当前接收数据的Stream

2. Stream流常见的中间方法

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

     Stream提供的常用中间方法	说明
     Stream<T> filter(Predicate<? super T> predicate)	用于对流中的数据进行过滤
     Stream<T> sorted()	对元素进行升序排序
     Stream<T> sorted(Comparator<? super T> comparator)	按照指定规则排序
     Stream<T> limit(long maxSize)	获取前几个对象
     Stream<T> skip(long n)	跳过前几个对象
     Stream<T> distinct()	去除流中重复的元素
     <R> Stream<R> map(Function<? super T, extends R> mapper)	对元素进行加工，并返回对应的新流
     static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流

3. Stream流常见的终结方法

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

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

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

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

     Stream提供的常见终结方法	说明
     R collect(Collector collector)	把流处理后的结果收集到一个指定的集合中去
     Object[] toArray()	把流处理后的结果收集到一个数组中去

     Collectors工具类提供了具体的收集方法	说明
     public static <T> Collector toList()	把元素收集到List集合中
     public static <T> Collector toSet()	把元素收集到Set集合中
     public static Collector toMap(Function keyMapper, Function valueMapper)	把元素收集到Map集合中

4. 注意：流只能收集一次