Java进阶_1集合框架

Java进阶_1

一、集合框架概念

• 集合是对象的容器，定义了多个对象进行操作的常用方法，类似数组的功能。

• 和数组的区别

  • （1）数组长度固定，集合长度不固定
  • （2）数组可以存储基本类型和引用类型，集合只能存储引用类型

• 位置：java.util.*;

图1-集合框架图

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

• **接口：**是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
• **实现（类）：**是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
• **算法：**是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

Set与List的区别：

​ 1.Set无序、不重复；List有序、可重复

​ 2.Set检索效率低，删除、插入效率高，插入和删除不会引起元素位置改变

​ 3.List检索效率高，删除、插入效率 低，且会引起元素位置改变

二、接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EkVPXIsK-1626935157083)(C:\Users\Nicole\AppData\Roaming\Typora\typora-user-images\image-20210715111726904.png)]

图2-集合框架接口

NavigableSet接口

​ NavigableSet扩展了 SortedSet，具有了为给定搜索目标报告最接近匹配项的导航方法。方法 lower、floor、ceiling 和 higher 分别返回小于、小于等于、大于等于、大于给定元素的元素，如果不存在这样的元素，则返回 null。

	类似地，方法 lowerKey、floorKey、ceilingKey 和 higherKey 只返回关联的键。所有这些方法是为查找条目而不是遍历条目而设计的。

​ 可以按照键的升序或降序访问和遍历 NavigableMap。descendingMap 方法返回映射的一个视图，该视图表示的所有关系方法和方向方法都是逆向的。升序操作和视图的性能很可能比降序操作和视图的性能要好。subMap、headMap 和 tailMap 方法与名称相似的 SortedMap 方法的不同之处在于：可以接受用于描述是否包括（或不包括）下边界和上边界的附加参数。任何 NavigableMap 的 Submap 必须实现 NavigableMap 接口。

​ 此外，此接口还定义了 firstEntry、pollFirstEntry、lastEntry 和 pollLastEntry 方法，它们返回和/或移除最小和最大的映射关系（如果存在），否则返回 null。

​ subMap(K, K)、headMap(K) 和 tailMap(K) 方法被指定为返回 SortedMap，以允许现有 SortedMap 实现能相容地改进为实现 NavigableMap，但鼓励此接口的扩展和实现重写这些方法以返回 NavigableMap。类似地，可以重写 SortedMap.keySet() 以返回 NavigableSet。

接口方法:

• E ceiling(E e)
  返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
• Iterator descendingIterator()
  以降序返回在此 set 的元素上进行迭代的迭代器。
• NavigableSet descendingSet()
  返回此 set 中所包含元素的逆序视图。
• E floor(E e)
  返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
• SortedSet headSet(E toElement)
  返回此 set 的部分视图，其元素严格小于 toElement。
• NavigableSet headSet(E toElement, boolean inclusive)
  返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
• E higher(E e)
  返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
• Iterator iterator()
  以升序返回在此 set 的元素上进行迭代的迭代器。
• E lower(E e)
  返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
• E pollFirst()
  获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
• E pollLast()
  获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
• NavigableSet subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
  返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
• SortedSet subSet(E fromElement, E toElement)
  返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
• SortedSet tailSet(E fromElement)
  返回此 set 的部分视图，其元素大于等于 fromElement。
• NavigableSet tailSet(E fromElement, boolean inclusive)
  返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。

NavigableMap接口

​ NavigableMap扩展了 SortedMap，具有了针对给定搜索目标返回最接近匹配项的导航方法。方法 lowerEntry、floorEntry、ceilingEntry 和 higherEntry 分别返回与小于、小于等于、大于等于、大于给定键的键关联的 Map.Entry 对象，如果不存在这样的键，则返回 null。类似地，方法 lowerKey、floorKey、ceilingKey 和 higherKey 只返回关联的键。所有这些方法是为查找条目而不是遍历条目而设计的。

​ 可以按照键的升序或降序访问和遍历 NavigableMap。descendingMap 方法返回映射的一个视图，该视图表示的所有关系方法和方向方法都是逆向的。升序操作和视图的性能很可能比降序操作和视图的性能要好。subMap、headMap 和 tailMap 方法与名称相似的 SortedMap 方法的不同之处在于：可以接受用于描述是否包括（或不包括）下边界和上边界的附加参数。任何 NavigableMap 的 Submap 必须实现 NavigableMap 接口。

	此接口还定义了 firstEntry、pollFirstEntry、lastEntry 和 pollLastEntry 方法，它们返回和/或移除最小和最大的映射关系（如果存在），否则返回 null。

	subMap(K, K)、headMap(K) 和 tailMap(K) 方法被指定为返回 SortedMap，以允许现有 SortedMap 实现能相容地改进为实现 NavigableMap，但鼓励此接口的扩展和实现重写这些方法以返回 NavigableMap。类似地，可以重写 SortedMap.keySet() 以返回 NavigableSet。

接口方法：

• Map.Entry<K,V> ceilingEntry(K key)
  返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
• K ceilingKey(K key)
  返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
• NavigableSet descendingKeySet()
  返回此映射中所包含键的逆序 NavigableSet 视图。
• NavigableMap<K,V> descendingMap()
  返回此映射中所包含映射关系的逆序视图。
• Map.Entry<K,V> firstEntry()
  返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
• Map.Entry<K,V> floorEntry(K key)
  返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。
• K floorKey(K key)
  返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
• SortedMap<K,V> headMap(K toKey)
  返回此映射的部分视图，其键值严格小于 toKey。
• NavigableMap<K,V> headMap(K toKey, boolean inclusive)
  返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
• Map.Entry<K,V> higherEntry(K key)
  返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
• K higherKey(K key)
  返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
• Map.Entry<K,V> lastEntry()
  返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
• Map.Entry<K,V> lowerEntry(K key)
  返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。
• K lowerKey(K key)
  返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。
• NavigableSet navigableKeySet()
  返回此映射中所包含键的 NavigableSet 视图。
• Map.Entry<K,V> pollFirstEntry()
  移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
• Map.Entry<K,V> pollLastEntry()
  移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
• NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
  返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
• SortedMap<K,V> subMap(K fromKey, K toKey)
  返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
• SortedMap<K,V> tailMap(K fromKey)
  返回此映射的部分视图，其键大于等于 fromKey。
• NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
  返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。

三、具体实现类

• 抽象类，具体关系见图1

  1. AbstractCollection 实现了大部分的集合接口。

  2. AbstractList 继承于AbstractCollection 并且实现了大部分List接口。

  3. AbstractSequentialList 继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。

  4. AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。

  5. AbstractMap 实现了大部分的Map接口。

• 常用List

  1. LinkedList该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：List list=Collections.synchronizedList(newLinkedList(...));LinkedList 查找效率低。

     

     图 3-LinkedList继承和实现

  2. ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。

     

     图4-ArrayList继承和实现

     • 以下情况使用 ArrayList :

       • 频繁访问列表中的某一个元素。
       • 只需要在列表末尾进行添加和删除元素操作。

       以下情况使用 LinkedList :

       • 你需要通过循环迭代来访问列表中的某些元素。
       • 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

• 常用Set

  1. HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。

     1. HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

        2. HashSet 允许有 null 值。

        3. HashSet 是无序的，即不会记录插入的顺序。

        4. HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。

        5. HashSet 实现了 Set 接口。

        

        图5-HashSet继承和实现

  2. LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。

  3. TreeSet 该类实现了Set接口，可以实现排序等功能。

• 常用Map

  1. HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。

     1. HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

     2. HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

     3. HashMap 是无序的，即不会记录插入的顺序。

     4. HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

        //字符串类型的key
        Map<String, String> map = Map.of("google", "google.com", "runoob", "runoob.com");
        //整型的key
        Map<Integer, String> map = Map.of(1, "google", 2, "runoob");
        

     

     图6-HashMap继承和实现

  2. TreeMap 继承了AbstractMap，并且使用一颗树。

  3. WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。

  4. LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序.

  5. IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。

四、集合算法

集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法。

在尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。

集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。

Collections中的方法

static <T> Queue<T> asLifoQueue(Deque<T> deque) 
//以后进先出 (Lifo) Queue 的形式返回某个 Deque 的视图。 

static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
//使用二分搜索法搜索指定列表，以获得指定对象。 如果没有找到对象，则返回一个i，应该插入的位置是-i-1

static <T> void copy(List<? super T> dest, List<? extends T> src) 
//将第二个参数列表的内容复制到第一个参数列表中，要保证第一个参数列表的长度是足够的

static boolean disjoint(Collection<?> c1, Collection<?> c2) 
//如果两个指定 collection 中没有相同的元素，则返回 true。 

static <T> void fill(List<? super T> list, T obj) 
//使用指定元素替换指定列表中的所有元素。 

static int frequency(Collection<?> c, Object o) 
//返回指定 collection 中等于指定对象的元素数。 

static int indexOfSubList(List<?> source, List<?> target) 
//返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。 

static int lastIndexOfSubList(List<?> source, List<?> target) 
//返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。 

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 
//根据指定比较器产生的顺序，返回给定 collection 的最大元素。 

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 
//根据指定比较器产生的顺序，返回给定 collection 的最小元素。 

static <T> List<T> nCopies(int n, T o) 
//返回由指定对象的 n 个副本组成的不可变列表。 

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
//使用另一个值替换列表中出现的所有某一指定值。 

static void reverse(List<?> list) 
//反转指定列表中元素的顺序。 

static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
//返回一个比较器，它强行逆转指定比较器的顺序。 

static void shuffle(List<?> list) 
//使用默认随机源对指定列表进行置换。 

static <T> void sort(List<T> list, Comparator<? super T> c) 
//根据指定比较器产生的顺序对指定列表进行排序。 

static void swap(List<?> list, int i, int j) 
//在指定列表的指定位置处交换元素。 

五、迭代器使用

通常情况下，你会希望遍历一个集合中的元素。例如，显示集合中的每个元素。

一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或 ListIterator接口。

迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了 Iterator，以允许双向遍历列表和修改元素。

图7-迭代器方法 ```

 1、使用迭代器

```java
Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}

2、使用列表迭代器

ListIterator li = list.listIterator();
while(li.hasNext()){
  System.out.println(li.nextIndex() + ":" + li.next()); //从前往后遍历
}

while(li.hasPrevious()){
  System.out.println(li.previousIndex() + ":" + li.previous()); //从后往前遍历
}

参考：

(6条消息) Java集合之NavigableMap与NavigableSet接口_lidongxiu0714-CSDN博客

Java 集合框架 | 菜鸟教程 (runoob.com)

cle/details/62236367?utm_medium=distribute.pc_relevant.none-task-blog-2_defaultBlogCommendFromMachineLearnPai2_{default-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2}default_{BlogCommendFromMachineLearnPai2}default-1.control)

Java 集合框架 | 菜鸟教程 (runoob.com)