java集合Collection及其子接口简述

前言

Java 的集合主要按两种接口分类：Collection, Map。本文重点介绍：Collection，下图是其常用子接口

一、Collection

public interface Collection<E> extends Iterable<E>

集合的特点：1、集合中存储的元素是对象。2、集合的长度是可变的；3、集合是不可以存储基本数据类型的

1、添加

boolean add(E e)//确保此集合包含指定的元素（可选操作）。 
 
boolean addAll(Collection<? extends E> c)//将指定集合中的所有元素添加到这个集合（可选操作）。 

2、是否包含

boolean contains(Object o)//返回 true如果集合包含指定元素。  
boolean containsAll(Collection<?> c)//返回 true如果这个集合包含指定集合的所有元素。  

3、仅移除

void clear()//从这个集合中移除所有的元素（可选操作）。  

boolean remove(Object o)//从这个集合中移除指定元素的一个实例，如果它是存在的（可选操作）。 
 
boolean removeAll(Collection<?> c)//删除此集合中包含的所有元素（可选操作）的所有元素（可选操作）。 
 
default boolean removeIf(Predicate<? super E> filter)//删除满足给定谓词的这个集合的所有元素。  

4、仅保留

boolean retainAll(Collection<?> c)//仅保留包含在指定集合中的这个集合中的元素（可选操作）。  

5、转换成数组

Object[] toArray()//返回包含此集合中所有元素的数组。  

<T> T[] toArray(T[] a)//返回包含此集合中所有元素的数组；返回数组的运行时类型是指定的数组的运行时类型。

6、比较

boolean equals(Object o)将指定的对象与此集合进行比较，以进行相等性。  

7、元素的数目

boolean isEmpty()返回 true如果集合不包含任何元素。  

int size()返回此集合中的元素的数目。

8、迭代器

Iterator<E> iterator()返回此集合中的元素的迭代器。 
default Spliterator<E> spliterator()创建此集合中的元素的 Spliterator。 

9、流

default Stream<E> parallelStream()返回一个可能并行 Stream与集合的来源。  

default Stream<E> stream()返回一个序列 Stream与集合的来源。 

二、List

public interface List<E> extends Collection<E>

按照顺序插入元素，元素有序且可重复

1、指定位置添加值

boolean addAll(int index, Collection<? extends E> c);
E set(int index, E element);
void add(int index, E element);

2、获取和删除指定位置的值

E get(int index);
E remove(int index);
List<E> subList(int fromIndex, int toIndex);

3、获取值的位置

int indexOf(Object o);

   
int lastIndexOf(Object o);

4、指定规则替换值

default void replaceAll(UnaryOperator<E> operator)

5、迭代

ListIterator<E> listIterator();

ListIterator<E> listIterator(int index);

6、排序

default void sort(Comparator<? super E> c) 

三、Set

Set接口常见子类有TreeSet、HashSet和LinkedHashSet
TreeSet底层是TreeMap
HashSet底层是HashMap
LinkedHashSet底层是LinkedHashMap

一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何其他的规定）。

对这些构造方法的其他规定是（不要奇怪），所有构造方法必须创建一个不包含重复元素的 set（正如上面所定义的）。

注：如果将可变对象用作 set 元素，那么必须极其小心。如果对象是 set 中某个元素，以一种影响 equals 比较的方式改变对象的值，那么 set 的行为就是不确定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。

他的方法都是继承Collection的

四、Set子接口SortedSet

public interface SortedSet<E> extends Set<E>

进一步提供关于元素的总体排序 的 Set。这些元素使用其自然顺序进行排序，或者根据通常在创建有序 set 时提供的 Comparator 进行排序。该 set 的迭代器将按元素升序遍历 set。提供了一些附加的操作来利用这种排序。（此接口是 SortedMap 的 set 对应接口）。

插入有序 set 的所有元素都必须实现 Comparable 接口（或者被指定的比较器所接受）。另外，所有这些元素都必须是可互相比较的：对于有序 set 中的任意两个元素 e1 和 e2，执行 e1.compareTo(e2)（或 comparator.compare(e1, e2)）都不得抛出 ClassCastException。试图违反此限制将导致违反规则的方法或者构造方法调用抛出 ClassCastException。

注意，如果有序 set 要正确实现 Set 接口，则有序 set 所维持的顺序（无论是否提供了明确的比较器）都必须与 equals 一致。（有关与 equals 一致 的精确定义，请参阅 Comparable 接口或 Comparator 接口。）这是因为 Set 接口是按照 equals 操作定义的，但有序 set 使用它的 compareTo（或 compare）方法对所有元素进行比较，因此从有序 set 的角度来看，此方法认为相等的两个元素就是相等的。即使顺序与 equals 不一致，有序 set 的行为仍然是 定义良好的，只不过没有遵守 Set 接口的常规协定。

所有通用有序 set 实现类都应该提供 4 个“标准”构造方法：1) void（无参数）构造方法，它创建一个空的有序 set，按照元素的自然顺序进行排序。2) 带有一个 Comparator 类型参数的构造方法，它创建一个空的有序 set，根据指定的比较器进行排序。3) 带有一个 Collection 类型参数的构造方法，它创建一个新的有序 set，其元素与参数相同，按照元素的自然顺序进行排序。4) 带有一个 SortedSet 类型参数的构造方法，它创建一个新的有序 set，其元素和排序方法与输入的有序 set 相同。无法保证强制实施此建议，因为接口不能包含构造方法。

注：一些方法返回具有受限范围的子集。这些范围区间是半开的，也就是说，它们包括低端点，但不包括高端点（如果适用）。如果需要一个闭区间（同时包含两个端点），且元素类型允许计算给定值的后继值，则只需要请求从 lowEndpoint 到 successor(highEndpoint) 的子区间。例如，假设 s 是一个字符串有序 set。下面的语句将得到一个包含 s 中从 low 到 high（包括）所有字符串的视图：

SortedSet sub = s.subSet(low, high+"\0");可使用类似的技术生成开区间（两个端点都不包括）。下面的语句得到包含 s 中从 low 到 high（不包括）所有字符串的视图：
SortedSet sub = s.subSet(low+"\0", high);此接口是 Java Collections Framework 的成员。

1、部分视图返回

SortedSet<E> headSet(E toElement )
返回此 set 的部分视图，其元素严格小于 toElement（不包括）

SortedSet<E> subSet(E fromElement, E toElement)
返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。

SortedSet<E> tailSet(E fromElement)
返回此 set 的部分视图，其元素大于等于 fromElement（包括）

案例

SortedSet<String> set = new TreeSet<String>();
set.add("b");
set.add("c");
set.add("a");
System.out.println(set);[a, b, c]

System.out.println(set.headSet("b"));// a

System.out.println(set.subSet("a","c") );//[a, b]

System.out.println(set.tailSet("b") );//[b, c]

2、查询元素

E first()返回此 set 中当前第一个（最低）元素。
E last() 返回此 set 中当前最后一个（最高）元素。

案例

SortedSet<String> set = new TreeSet<String>();
set.add("b");
set.add("c");
set.add("a");
System.out.println(set);[a, b, c]

System.out.println(set.first()); a

System.out.println(set.last() );c

3、比较器返回

Comparator<? super E> comparator() 返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。

五、NavigableSet

public interface NavigableSet<E> extends SortedSet<E>

扩展的 SortedSet，具有了为给定搜索目标报告最接近匹配项的导航方法。方法 lower、floor、ceiling 和 higher 分别返回小于、小于等于、大于等于、大于给定元素的元素，如果不存在这样的元素，则返回 null。可以按升序或降序访问和遍历 NavigableSet。descendingSet 方法返回 set 的一个视图，该视图表示的所有关系方法和方向方法都是逆向的。升序操作和视图的性能很可能比降序操作和视图的性能要好。此外，此接口还定义了 pollFirst 和 pollLast 方法，它们返回并移除最小和最大的元素（如果存在），否则返回 null。subSet、headSet 和 tailSet 方法与名称相似的 SortedSet 方法的不同之处在于：可以接受用于描述是否包括（或不包括）下边界和上边界的附加参数。任何 NavigableSet 的 Submap 必须实现 NavigableSet 接口。

导航方法的返回值在允许 null 元素的实现中可能是不确定的。不过，即使在这种情况下，也可以通过检查 contains(null) 来明确结果。为了避免这样的问题，建议在此接口的实现中不 允许插入 null 元素。（注意，Comparable 元素的有序集本身不允许 null。）

subSet(E, E)、headSet(E) 和 tailSet(E) 方法被指定为返回 SortedSet，以允许现有 SortedSet 实现能相容地改进为实现 NavigableMap，但鼓励此接口的扩展和实现重写这些方法以返回 NavigableSet。

1、部分视图返回

NavigableSet<E> descendingSet() 返回此 set 中所包含元素的逆序视图。

NavigableSet<E> headSet(E toElement, boolean inclusive)
返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。

NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。

NavigableSet<E> tailSet(E fromElement, boolean inclusive)
 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。

案例

NavigableSet<String> set = new TreeSet<String>();
set.add("b");
set.add("c");
set.add("d");
set.add("a");
System.out.println(set);[a, b, c, d]

System.out.print(set.descendingSet());//[d, c, b, a]

System.out.print(set.headSet("c",true));//[a, b, c]

System.out.println(set.subSet("a",true,"d",false) );//[a, b, c]

System.out.println(set.tailSet("c",false) );//[d]

2、元素查询

E ceiling(E e) 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。

E floor(E e)返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。

E higher(E e) 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。

E lower(E e) 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。

案例

NavigableSet<String> set = new TreeSet<String>();
set.add("b");
set.add("c");
set.add("d");
set.add("a");
System.out.println(set);[a, b, c, d]

System.out.print(set.floor("c"));//c

System.out.println(set.ceiling("c"));//c

System.out.print(set.higher("c"));//d

System.out.print(set.lower("c"));//b

3、删除

E pollFirst() 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。

E pollLast()获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。

4、遍历

Iterator<E> descendingIterator()以降序返回在此 set 的元素上进行迭代的迭代器。

Iterator<E> iterator() 以升序返回在此 set 的元素上进行迭代的迭代器。

四、Queue

public interface Queue<E> extends Collection<E>

按照排队的规则来确定对象的产生顺序（通常与他们被插入的顺序相同）

Queue通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。

1、尾部添加

boolean offer(E e)

2、移除头

//此方法与 poll 唯一的不同在于：此队列为空时将抛出一个异常。
E remove()//获取并移除此队列的头。
E poll()//获取并移除此队列的头，如果此队列为空，则返回 null。

3、获取头

E peek()//获取但不移除此队列的头；如果此队列为空，则返回 null。
E element()//获取，但是不移除此队列的头 此方法与peek唯一的不同在于：此队列为空时将抛出一个异常

五、Queue子接口Deque

public interface Deque<E> extends Queue<E>

一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。
此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。插入操作的后一种形式是专为使用有容量限制的 Deque 实现设计的；在大多数实现中，插入操作不能失败。
虽然 Deque 实现没有严格要求禁止插入 null 元素，但建议最好这样做。建议任何事实上允许 null 元素的 Deque 实现用户最好不 要利用插入 null 的功能。这是因为各种方法会将 null 用作特殊的返回值来指示双端队列为空。
Deque 实现通常不定义基于元素的 equals 和 hashCode 方法，而是从 Object 类继承基于身份的 equals 和 hashCode 方法。

1、尾部添加，违反容量限制抛出异常

void addLast(E e)
boolean offer(E e)
boolean offerLast(E e)

2、头部添加，违反容量限制抛出异常

void addFirst(E e)
void push(E e)
boolean offerFirst(E e)

3、尾部检索，但不删除

E getLast()
E peekLast()

4、头部检索，但不删除

E getFirst()
E peek ()
E peekFirst()

5、尾部删除

E pollLast()
E removeLast()

6、头部删除

E pollFirst()
E pop()
E  removeFirst()

7、指定元素删除

boolean removeFirstOccurrence(Object o) 删除第一个出现的指定元素从这个队列。
boolean removeLastOccurrence(Object o) 移除指定元素的最后出现从这个队列。

8、遍历

Iterator<E> descendingIterator()返回在反向顺序在deque容器元素的迭代器。