java-doc-集合和映射

概览

类与接口	描述
Collection	接口，允许操作一组对象，位于集合层次结构的顶部
Deque	接口，扩展Queue以处理双端队列
List	接口，扩展Collection以处理序列(对象列表)
NavigableSet	接口，扩展SortedSet以基本最接近匹配原则检索元素
Queue	接口，扩展Collection以处理特殊类型的列表，这种类型的列表只能从列表顶部删除元素
Set	接口，扩展Collection以处理集合，集合中的元素必须唯一
SortedSet	接口，扩展Set以处理已排序的集合
Map	接口，将唯一键映射到值
Map.Entry	接口，描述映射中的元素(键/值对)，这是Map的内部类
NavigableMap	接口，扩展SortedMap接口，以处理基于最接近匹配原则的键/值对检索
SortedMap	接口，扩展Map接口，从而以升序保存键

AbstractCollection	类，实现Collection接口的大部分
AbstractList	类，扩展AbstractCollection类并实现List接口的大部分
AbstractQueue	类，扩展AbstractCollection类并实现Queue接口的大部分
LinkedList	类，通过扩展AbstractSequentialList类实现链表
ArrayList	类，通过扩展AbstractList类实现动态数组，线程不安全
ArrayDeque	类，通过扩展AbstractCollection类并实现Set接口的大部分
EnumSet	类，扩展AbstractSet类，用于enum元素
HashSet	类，扩展AbstractSet类，用于哈希表
LinkedHashSet	类，扩展HashSet类以运行按照插入的顺序进行迭代
PriprityQueue	类，扩展AbstractQueue类以支持基于优先级的队列
TreeSet	类，实现存储于树种的组，扩展AbstractSet类
AbstractMap	类，实现了Map接口的大部分
EnumMap	类，扩展了AbstractMap，以使用enum键
HashMap	类，扩展了AbstractMap，以使用哈希表
TreeMap	类，扩展了AbstractMap，以使用树结构
WeakHashMap	类，扩展了AbstractMap，以使用带有弱键的哈希表
LinkedHashMap	类，扩展了HashMap，以运行按照插入顺序进行迭代
IdentityHashMap	类，扩展了AbstractMap，并且当比较文档时使用引用相等性

Vector	类，遗留类，与ArrayList类似
Stack	类，遗留类，扩展了Vector，实现了标准的后进先出的堆栈
Dictionary	类，遗留类，与Map类似
Hashtable	类，遗留类，是Dictionary的具体实现，与HashMap类似
Properties	类，遗留类，扩展Hashtable，用于保存值的列表

BlockingQueue	接口，阻塞队列
BlockingDeque	接口，双端阻塞队列
TransferQueue	接口，转移队列接口，生产者要等消费者消费的队列，生产者尝试把元素直接转移给消费者
ConcurrentMap	接口，并发 Map 的接口
ArrayBlockingQueue	类，线程安全，实现BlockingQueue接口，数组实现
LinkedBlockingQueue	类，线程安全，实现BlockingQueue接口，链表实现
LinkedBlockingDeque	类，线程安全，阻塞双端队列，链表实现
DelayQueue	类，线程安全，实现BlockingQueue接口，并且元素是 Delay 的子类，保证元素在达到一定时间后才可以取得到
PriorityBlockingQueue	类，线程安全，实现BlockingQueue接口，优先级阻塞队列
SynchronousQueue	类，线程安全，实现BlockingQueue接口，同步队列，但是队列长度为 0，生产者放入队列的操作会被阻塞，直到消费者过来取，所以这个队列根本不需要空间存放元素；有点像一个独木桥，一次只能一人通过，还不能在桥上停留
CopyOnWriteArrayList	类，线程安全，copy-on-write 模式的 array list，每当需要插入元素，不在原 list 上操作，而是会新建立一个 list，适合读远远大于写并且写时间并苛刻的场景
CopyOnWriteArraySet	类，线程安全
ConcurrentLinkedDeque	类，线程安全，非阻塞双端队列，链表实现
ConcurrentLinkedQueue	类，线程安全，非阻队列，链表实现，使用CAS
LinkedTransferQueue	类，线程安全，实现TransferQueue接口，转移队列的链表实现，它比 SynchronousQueue 更快
ConcurrentSkipListMap	类，线程安全，NavigableMap 的实现类（要求元素之间可以比较），同时它比 ConcurrentHashMap 更加 scalable——ConcurrentHashMap 并不保证它的操作时间，并且你可以自己来调整它的 load factor；但是 ConcurrentSkipListMap 可以保证 O(log n) 的性能，同时不能自己来调整它的并发参数，只有你确实需要快速的遍历操作，并且可以承受额外的插入开销的时候，才去使用它
ConcurrentHashTable	类，线程安全
ConcorrenctHashMap	类，线程安全，并发 HashMap
ConcurrentNavigableMap	类，线程安全，NavigableMap 的实现类，返回最接近的一个元素
ConcurrentSkipListSet	类，线程安全

Arrays	类，通过了对数组操作有用的方法，这些方法有助于连接集合和数组。

集合

Collection

Collection接口是构建集合框架的基础，因为定义集合的所有类都必须实现该方法。Collection是泛型接口。

Collection扩展了Iterable接口，这意味着所有集合都可以使用for-each风格的for循环进行遍历。

Collection接口声明的方法

方法	描述
`boolean add(E obj)`	将obj添加到调用集合中。如果obj被添加到集合中，就返回true；如果obj已经是集合的成员并且集合不运行重复，就返回false
`boolean addAdd(Collection<? extends E>c)`	将c中的所有元素添加到调用集合中。如果调用集合发生了变化(例如添加了元素)，就返回true；否则返回false
`void clear()`	移除调用集合的所有元素
`boolean contains(Object obj)`	如果obj是调用集合中的元素，就返回true；否则返回false
`boolean containsAll(Collection<?> c)`	如果调用集合包含c的所有元素，就返回true；否则返回false
`boolean equals(Object obj)`	如果调用集合与obj相等，就返回true；否则返回false
`int hashCode()`	返回调用集合的散列码
`boolean isEmpty()`	如果调用集合为空，就返回true；否则返回false
`Iterator<E> iterator()`	返回调用集合的一个迭代器
`default Stream<E> parallelStream()`	返回一个视野调用集合作为元素来源的流，该流能够支持并行操作(JDK8新增)
`boolean remove(Object obj)`	从调用集合中移除obj的一个实例。如果移除了元素，就返回true；否则返回false
`boolean removeAll(Colection<?> c)`	从调用集合中移除c的所有元素。如果操作集合发生了变化(即移除了元素)，就返回true；否则返回false
`default boolean removeIf(Predicate<? super E> predicate)`	从调用集合中移除满足predicate指定条件的那些元素(JDK8新增)
`boolean retainAll(Collection<?> c)`	移除调用集合中除了c中元素之外的所有元素。如果集合发生了变化(即移除了元素)，就返回true；否则返回false
`int size()`	返回调用集合中元素的数量
`default Spliterator<E> spliterator()`	返回调用集合的Spliterator(JDK8新增)
`default Stream<E> stream()`	返回一个使用调用集合作为元素来源的流。该流失顺序流(JDK8新增)
`Object[] toArray()`	返回包含调用集合中存储的所有元素的数组，数组元素是集合元素的副本
`<T> T[] toArray(T array[])`	返回调用集合元素中元素的数组。数组元素是集合元素的副本。如果array的场地等于元素的数量，就将返回的元素保存在array中；如果array的长度小于元素的数量，就分配必须大小的新数组并返回这个新数组；如果array的长度大于元素的数量，就将最后一个元素之后的数组设置为null；如果所有集合元素的类型都不是array的子类型，那么就抛出ArrayStoreException异常

List

List接口扩展了Collection，并且声明了用来存储一连串元素的集合的行为。在列表中，可以使用从0开始的索引，通过元素的位置插入或访问元素。列表可以包含重复的元素。List是泛型接口。

List接口声明的方法

方法	描述
`void add(int index, E obj)`	将obj插入到调用列表中由index指定的索引位置。在插入点及之后位置存储的元素将被后移，因此没有元素会被覆盖
`boolean addAll(int index, Collection<? extends E> c)`	将c中的所有元素插入到调用列表中，由index指定的索引位置。任何插入点以及之后位置存储的元素都将后移，因此没有元素会被覆盖。如果调用列表发生了变化，就返回true；否则返回false
`E get(int index)`	返回调用集合中在指定索引位置存储的对象
`int indexOf(Object obj)`	返回调用列表中第一个obj实例的索引。如果obj不是列表中的元素，就返回-1
`int lastIndexOf(Object obj)`	返回调用列表中最后一个obj实例的索引。如果obj不是列表中的元素，就返回-1
`ListIterator<E> listIterator()`	返回调用列表的一个迭代器，该迭代器从列表的开头开始
`ListIterator<E> listIteraotr(int index)`	返回调用列表的一个迭代器，该迭代器从列表中由index指定的索引位置开始
`E remove(int index)`	从调用列表中移除位于index索引位置的元素，并返回被移除的元素，结果列表被压缩，也就是说，后面所有元素的索引都被减1
`default void replaceAll(UnaryOperator<E> opToApply)`	使用opToApply函数获得的值更新列表中的每个元素(JDK8新增)
`E set(int index, E obj)`	将调用列表中由index指定的索引位置的元素设置为obj，返回原来的值
`default void sort(Comparator<? super E> comp)`	使用comp指定的比较器排序列表(JDK8新增)
`List<E> subList(int start, int end)`	返回的子列表包含调用列表中索引位置在start到end-1之间的元素。返回列表中的元素仍然被调用对象引用

Set

Set接口定义了组(set)。它扩展了Collection接口，并且声明了集合中不允许重复元素的组行为。所以，如果为组添加重复的元素，add()方法就会返回false。Set是泛型接口。

SortedSet

SortedSet接口扩展了Set接口，并且声明了以升序进行排序的组行为。SortedSet是泛型接口。

SortedSet在使用时，如果调用组中没有包含条目，其中的几个方法会抛出NoSuchElementException异常；如果对象和组中的元素不兼容，就抛出ClassCastException异常；如果试图为不允许存储null对象的组添加null对象，就抛出NullPointerException异常；如果使用的参数无效，会抛出IllegalArgumentException异常。

SortedSet接口声明的方法

方法	描述
`Comparator<? super E> comparator()`	返回已排序调用组的比较器。如果这个组使用自然排序，就返回null
`E first()`	返回已排序调用组的第一个元素
`SortedSet<E> headSet(E end)`	返回的SortedSet对象包含已排序调用组中那些小于end的元素。对于返回的已排序组中的元素，也将被已排序调用组引用
`E last()`	返回已排序调用组中的最后一个元素
`SortedSet<E> subSet(E start, E end)`	返回SortedSet对象包含索引位置在start与end-1之间的元素。返回组中的元素也将被调用对象引用
`SortedSet<E> tailSet(E start)`	返回SortedSet对象包含排序组中大于或等于start的元素。返回组中的元素也将被调用对象引用

NavigableSet

NavigableSet接口扩展了SortedSet接口，并且该接口声明了支持基于最近匹配原则检索元素的集合行为。NavigableSet是泛型接口。

NavigableSet接口声明的方法

方法	描述
`E ceiling(E obj)`	在组中查找大于等于obj的最小元素。如果找到了这样的元素，就返回元素；否则返回null
`Iterator<E> descendingIterator()`	返回一个从最大元素向最小元素移动的迭代器。换句话说，返回一个反向迭代器
`NavigableSet<E> descendingSet()`	返回用来翻转调用组的NavigableSet对象，结果组基于调用组
`E floor(E obj)`	查找组中小于等于obj的最大元素。如果找到了这样的元素，就返回元素；否则返回null
`NavigableSet<E> headSet(E upperBound, boolean incl)`	返回的NavigableSet对象包含调用组中小于upperBound的所有元素。如果incl为true，那么包含等于upperBound的那个元素。结果基于调用组
`E higher(E obj)`	在组中查找大于obj的最大元素。如果找到了这样的元素，就返回元素；否则返回null
`E lower(E obj)`	在组中查找小于obj的最大元素。如果找到了这样的元素，就返回元素；否则返回null
`E pollFirst()`	返回第一个元素，在操作过程中移除该元素。因为组是排序的，所以该元素具有最小值。如果组为空，那么返回null
`E pollLast()`	返回最后一个元素，在操作过程中移除该元素。因为组是排序过的，所以该元素具有最大值。如果组为空，那么返回null
`NavigableSet<E> subSet(E lowerBound, boolean lowIncl, E upperBound, boolean highIncl)`	返回NavigableSet对象包含调用组中大于lowerBound且小于upperBound的所有元素。如果lowIncl为true，那么包含等于lowerBound的那个元素；如果highIncl为true，那么包含等于upperBound的那个元素。结果组基于调用组
`NavigableSet<E> tailSet(E lowerBound, boolean incl)`	返回的NavigableSet对象包含调用组中大于lowerBound的所有元素。如果incl为true，那么包含等于lowerBound的那个元素。结果组基于调用组

Queue

Queue接口扩展了Collectoin接口，并且声明了队列的行为，队列通常是先进先出的列表。Queue是泛型接口。

Queue接口声明的方法

方法	描述
`E element()`	返回队列头部的元素，不移除该元素。如果队列为空，那么抛出NoSucnElementException异常
`boolean offer(E obj)`	试图将obj添加到队列中。如果将obj添加到队列中，那么返回true；否则返回false
`E peek()`	返回队列头部的元素。如果队列为空，那么返回null。不移除该元素
`E pool()`	返回队列头部的元素。在过程中移除该元素。如果队列为空，那么返回null
`E remove()`	移除队列头部的元素，并在操作过程中移除该元素。如果队列为空，那么抛出NoSuchElementException异常

Deque

Deque接口扩展了Queue接，并且声明了双端队列的行为。双端队列既可以像标准队列那样先进先出，也可以像堆栈那样后进先出。Deque是泛型接口。

Deque接口声明的方法

方法	描述
`void addFirst(E obj)`	将obj添加到双端队列的头部。如果超出了容量有限的双端队列的空间，就抛出IllegalStateException异常
`void addList(E obj)`	将obj添加到双端队列的尾部。如果超出了容量有限的双端队列的空间，就抛出IllegalStateException异常
`Iterator<E> descendingIterator()`	返回一个双端队列尾部向头部移动的迭代器。也就是反向迭代器
`E getFirst()`	返回双端队列的第一个元素，不从双端队列中移除对象。如果上端队列为null，就抛出NoSuchElementException异常
`E getLast()`	返回双端队列的最后一个元素，不从双端队列中移除对象。如果双端队列为空，就抛出NoSuchElementException异常
`boolean offerFirst(E obj)`	将obj添加到双端队列的头部。如果obj被添加到双端队列中，就返回true；否则返回false。隐藏，如果试图向一个已满并且容量有限的双端队列添加obj，那么会返回false
`boolean offerLast(E obj)`	试图将obj添加到双端队列的尾部。如果obj被添加到双端队列中，就返回true，否则返回false
`E peekFirst()`	返回双端队列头部的元素。如果双端队列为空，就返回null。对象不被移除
`E peekLast()`	返回双端队列的尾部元素。如果双端队列为空，就返回null，对象不被移除
`E poolFirst()`	返回双端队列头部的元素，在操作过程中移除该元素。如果双端队列为空，就返回null
`E poolLast()`	返回双端队列尾部的元素，在操作过程中移除该元素。如果双端队列为空，就返回null
`E pop()`	返回双端队列头部的元素，在操作过程中移除该元素。如果双端队列为空，就抛出NoSuchElementException异常
`void push(E obj)`	将obj添加到双端队列的头部。如果超出了容量有限的双端队列的空间，就抛出IllegalStateException异常
`E removeFirst()`	返回双端队列的头部元素，在操作过程中移除该元素。如果双端队列为空，就抛出NoSuchElementException异常
`boolean removeFirstOccurrence(Object obj)`	从双端队列中移除第一次出现的obj对象。如果成功，就返回true；如果双端队列不包含obj，就返回false
`E removeLast()`	返回双端队列尾部的元素，在操作过程中移除该元素。如果双端队列为空，就抛出NoSuchElementException异常
`boolean removeLastOccurrence(Object obj)`	从双端队列中移除最后一次出现的obj对象。如果成功，就返回true；如果双端队列不包含obj，就返回false

ArrayList

ArrayList类扩展了AbstractList类并实现了List接口。ArrayList是泛型类。

ArrayList类支持能够按需增长的动态数组。在Java中，标准数组的长度是固定的。数组在创建之后，就不能增长或缩小，这意味着必须实现知道数组将包含多少元素。但是，有时可能直到运行时才直到所需数组的准确大小。本质上，ArrayList就是元素为对象引用的长度可变的数组。也就是说，ArrayList可以动态增加或减少大小。数组列表使用初始大小创建。当超出这个大小时，集合会自动扩大。当对象呗移除时，也可以减小数组。

尽管存储对象时，ArrayList对象的容量会自动增长，但是可以调用ensureCapacity()方法手动增长ArrayList对象的容量。如果实现知道将在集合中存储的元素比当前保存的元素多很多，那么可以在开始时，一次性增加容量，从而避免以后多次重新分配内容。因为重新分配内存很耗时，阻止不必要的内存分配次数可以提高性能。

构造函数

方法	描述
`ArrayList()`	构建一个空的数组列表
`ArrayList(Collection<? extends E> c)`	使用集合e进行初始化
`ArrayList(int capacity)`	构建一个初始容量为capacity的数组列表

ArrayList类声明的方法

方法	描述
`void ensureCapacity(int cap)`	将容器大小设置为cap
`void trimToSize()`	精确地调整当前容器的大小
`object[] toArray()`	将列表所有元素以数组形式返回
`<T> T[] toArray(T array[])`	将列表所有元素以数组形式返回

LinkedList

LinkedList类扩展了AbstractSequentialList类，实现了List、Deque以及Queue接口，并且它提供了一种链表数据结构。LinkedList是泛型类。

构造函数

方法	描述
`LinkedList()`	构建一个空链表
`LinkedList(Collection<? extends E> c)`	构建一个使用集合c进行初始化的链表

HashSet

HashSet类扩展了AbstractSet类并实现了Set接口，该类用于创建使用哈希表存储元素的集合。HashSet是泛型类。

构造函数

方法	描述
`HashSet()`	构造一个默认的哈希组
`HashSet(Collection<? extends E> c)`	构造一个使用集合c中的元素初始化的哈希组
`HashSet(int capacity)`	构造一个指定默认容器大小的哈希组
`HashSet(int capacity, float fillRatio)`	根据参数同时初始化哈希组的容量和填充率(也称为载入容量 (load capacity))。填充率必须介于0.0到1.0之间，填充率觉得了哈希组被填充到什么程度就增加容量。特别地，元素的数量大于哈希组的容量与填充率的乘积时，将扩展哈希组。默认填充率是0.75

LinkedHashSet

LinkedHashSet扩展了HashSet类，它没有添加自己的方法。LinkedHashSet是泛型类。

LinkedHashSet维护组中条目的一个链表，链表中条目的顺序也就是插入它们的顺序，这使得可以按照插入顺序迭代集合。当使用迭代器遍历LinkedHashSet时，元素将以插入它们的顺序返回。这也是在堆LinkedHashSet对象调用toString()方法时，在返回的字符串中包含它们的顺序。

TreeSet

TreeSet扩展了AbstractSet类并实现了NavigableSet接口，用于创建使用树进行存储的组。对象以升序存储，访问和检索速度相当快，对于存储大量的、必须能够快速查找到的有序信息来说，TreeSet是极佳选择。

构造函数

方法	描述
`TreeSet()`	构建一个空树
`TreeSet(Collection<? extends E> c)`	构建一个包含集合c中元素的树
`TreeSet(Comparator<? super E> comp)`	构建一个空树，将按照comp指定的比较器进行存储
`TreeSet(SortedSet<E> ss`	构建一个包含ss中元素的树

PriorityQueue

PriorityQueue扩展了AbstractQueue类并实现了Queue接口，用于根据队列的比较器来判断优先次序的队列。PriorityQueue是泛型类。

构造函数

方法	描述
`PriorityQueue()`	构造一个空的队列
`PriorityQueue(int capacity)`	构建一个指定初始容量的队列
`PriorityQueue(Comparator<? super E> comp)`	构造一个指定比较器的队列
`PriorityQueue(int capacity, Comparator<? super E> comp)`	构造一个指定容量和比较器的队列
`PriorityQueue(Collection<? extends E> c)`	构造一个包含c元素的队列
`PriorityQueue(PriorityQueue<? extends E> c)`	构造一个包含c元素的队列
`PriorityQueue(SortedSet<? extends E> c)`	构造一个包含c元素的队列

当构建PriorityQueue对象时，如果没有指定比较器，将使用队列中存储的数据类型的默认比较器。默认比较器以升序对队列进行排序。因此，队列头部的条目将包含最小的值。通过提供定制的比较器，可以指定不同的排序模式。

尽管可以使用迭代器遍历PriorityQueue，但是迭代的顺序是不确定的。为了正确地使用PriorityQueue，必须调用offer()和pool()这类方法，这些方法是由Queue接口定义的。

ArrayDeque

ArrayDeque扩展了AbstractCollection类并实现了Deque接口，没有添加自己的方法。ArrayDeque是动态数组，没有容量限制(Deque接口支持限制容量的实现，但是这种限制不是必须的)。ArrayDeque是泛型类。

构造函数

方法	描述
`ArrayDeque()`	构建一个空的双端队列
`ArrayDeque(int size)`	构建一个具有指定初始容量的双端队列
`ArrayDeque(Collection<? extends E> c)`	创建使用参数c传递过来的集合的元素进行初始化的双端队列

EnumSet

EnumSet扩展了AbstractSet类并实现了Set接口，专门用于枚举类型的元素。EnumSet是泛型类。

EnumSet没有定义构造函数，而是使用工厂方法来创建对象。

EnumSet类声明的方法

方法	描述
`static <E extends Enum<E>> EnumSet<E> allOf(Class<E> t)`	创建的EnumSet包含由t指定的枚举中的元素
`static <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> e)`	创建的EnumSet由未存储在e中的元素组成
`static <E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E>) c`	根据c中存储的元素创建EnumSet
`static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c)`	根据c中存储的元素创建EnumSet
`static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> t)`	创建的EnumSet不包含由t指定的枚举中的元素。根据定义，这是一个空组
`static <E extends Enum<E>> EnumSet<E> of(E v, E ...varargs)`	创建的EnumSet包含v，以及0个或更多个其他枚举值
`static <E extends Enum<E>> EnumSet<E> of(E v)`	创建的EnumSet包含v
`static <E extends Enum<E>> EnumSet<E> of(E v1, E v2)`	创建的EnumSet包含v1和v2
`static <E extends Enum<E>> EnumSet<E> of(E v1, E v2, E v3)`	创建的EnumSet包含v1、v2和v3
`static <E extends Enum<E>> EnumSet<E> of(E v1, E v2, E v3, E v4)`	创建的EnumSet包含v1、v2、v3和v4
`static <E extends Enum<E>> EnumSet<E> of(E v1, E v2, E v3, E v4, E v5)`	创建的EnumSet包含v1、v2、v3、v4和v5
`static <E extends Enum<E>> EnumSet<E> range(E start, E end)`	创建的EnumSet包含指定范围(由start和end指定)内的元素

BitSet

BitSet类创建特殊类型的数组，这类数组的元素是布尔值形式的位值。

构造函数

方法	描述
`BitSet()`	创建默认对象
`BitSet(int size)`	知道对象的初始化大小，所有位都被初始化为false

BitSet类定义的方法

方法	描述
`void and(BitSet bitSet)`	对调用BitSet对象的内容和bitSet指定对象的内容进行AND操作，结果将被放入调用对象中
`void andNot(BitSet bitSet)`	对于bitSet中值为true的每个位，将调用BitSet对象中的相应位清除
`int cardinality()`	返回调用对象中已置位的数量
`int clear()`	将所有位设置为false
`void clear(int index)`	将index指定的位设置为false
`void clear(int startIndex, int endIndex)`	将startIndex和endIndex-1之间的位设置为false
`Object clone()`	复制调用BitSet对象
`boolean equals(Object bitSet)`	如果调用位组与bitSet传入的位组相对，就返回true；否则返回false
`void flip(int index)`	翻转由index指定的位的值
`void flip(int startIndex, int endIndex)`	返回startIndex和endIndex-1之间的所有位的值
`boolean get(int index)`	返回由index指定的位的当前状态
`BItSet get(int startIndnex, int endIndex)`	返回的BitSet对象由startIndex和endIndex-1之间的位组成。不改变调用对象
`int hashCode()`	返回调用对象的散列码
`boolean intersects(BitSet bitSet)`	如果调用对象和biSet指定对象中至少有一对对应位为1，就返回true
`boolean isEmpty()`	如果调用对象中的所有位都是false，就返回true
`int length()`	返回容纳调用BitSet对象的内容所需要的位数。这个值由最后一位的位置决定
`int nextClearBit(int startIndex)`	返回下一个被清除位(即下一个值为false的位)的索引，从startIndex指定的索引位置开始
`int nextSetBit(int startIndex)`	返回下一个被置位的位(即下一个值为true的位)的位置，从startIndex指定的索引位置开始。如果没有位被置位，就返回-1
`void or(BitSet bitSet)`	对调用BitSet对象的内容和bitSet指定对象的内容进行OR操作，结果将被放入调用对象中
`int previousClearBit(int startIndex)`	返回在startIndex指定索引位置或之前下一个被清除位(即下一个值为false的位)的索引。如果没有找到被清除的位，就返回-1
`void set(int index)`	将index指定的位置位
`void set(int index, boolean v)`	将index指定的位设置为v传递过来的值。如果为true，就置位，如果为false，就清除位
`void set(int startIndex, int endIndex)`	将startIndex和endIndex-1之间的位置位
`void set(int startIndex, int endIndex, boolean v)`	将startIndex和endIndex-1之间的位设置为v传入的值。如果为true，就置位；如果为false，就清除位
`int size()`	返回调用BitSet对象中位的数量
`IntStream stream()`	返回一个流，其中由低到高包含已被置位的位的位置(JDK8新增)
`byte[] toByteArray()`	返回包含调用BitSet对象的byte数组
`long[] toLongArray()`	返回包含调用BitSet对象的long数组
`String toString()`	返回调用BitSet对象的等价字符串
`static BitSet valueOf(byte[] v)`	返回一个包含v中位的BitSet对象
`static BitSet valueOf(ByteBuffer v)`	返回一个包含v中位的BitSet对象
`static BitSet ValueOf(long[] v)`	返回一个包含v中位的BitSet对象
`static BitSet ValueOf(LongBuffer v)`	返回一个包含v中位的BitSet对象
`void xor(BitSet bitSet)`	对调用BitSet对象的内容和bitSet指定对象的内容进行XOR操作，结果将被放入调用对象中

import java.util.*;

public class LearnBitSet1 
{
    public static void main(String args[])
    {
        BitSet bits1 = new BitSet(16);
        BitSet bits2 = new BitSet(16);
        
        for(int i = 0; i < 16; i++) {
            if((i%2) == 0) {
                bits1.set(i);
            }
            
            if((i%5) != 0) {
                bits2.set(i);
            }
        }
        
        System.out.println("Initial pattern in bits1:");
        System.out.println(bits1);
        System.out.println("Initial pattern in bits2:");
        System.out.println(bits2);
        
        bits2.and(bits1);
        System.out.println("\nbits2 AND bits1:");
        System.out.println(bits2);
        
        bits2.or(bits1);
        System.out.println("\nbits2 OR bits1:");
        System.out.println(bits2);
        
        bits2.xor(bits1);
        System.out.println("\nbits2 XOR bits1:");
        System.out.println(bits2);
    }
}

RandomAccess

RandomAccess接口不包含成员。然后，通过实现这个接口，可表明集合支持高效地随机访问其中的元素。尽管集合可能支持随机访问，但是可能没有如此高效。通过检查RandomAccess接口，客户端代码可以在运行时确定集合是否适合特定类型的随机访问操作————特别是当将它们应用于大的集合时(可以用instanceof来判断类是否实现了某个接口)。ArrayList和遗留的Vector类实现了RandomAccess接口。

映射

映射是存储键和值直接关联关系(键值对)的对象。给定一个键，就可以找到对应的值。键和值都是对象。键必须是唯一，但是值可以重复。某些映射可以接受null键和null值。

关于映射需要关注的关键一点是：它们没有实现Iterable接口。这以为着不能使用for-each风格的for循环遍历映射。此外，不能为映射获取迭代器。但是，可以获取映射的集合视图来使用for循环和迭代器。

Map

Map接口将唯一键映射到值。键是以后用于检索值的对象。给定键和值，可以在Map对象中存储值；存储值以后，可以使用相应的键检索值。Map是泛型接口。

Map接口声明的方法

方法	描述
`void clear()`	移除调用映射中的所有键/值对
`default V compute(K k, BiFuction<? super K, ? super V, ? extends V> func)`	调用func以构造一个新值。如果func的返回值不是null，就把心的键值对添加到映射中，移除原来的配对，并返回新值。如果func返回null，就移除原来的配对，并返回null(JDK8新增)
`default V computeIfAbsent(K k, Function<? super K, ? extends V> func)`	返回与键k关联的值。如果没有值，就通过调用func构造一个值，并把改配对输入到映射中，返回构造的值。如果无法构造新值，就返回null(JDK8新增)
`default V computeIfPresent(K k, BitFunction<? super K, ? super V, ? extends V> func)`	如果k包含在映射中，就通过调用func为其构造一个新值，替换映射中原来的值，然后返回新值。如果func返回的值为null，就从映射中删除现有的键和值，并返回null(JDK8新增)
`boolean containsKey(Object k)`	如果调用映射包含k作为键，就返回true；否则返回false
`boolean containsValue(Object v)`	如果调用映射包含v作为值，就返回true；否则返回false
`Set<Map.Entry<K, V>> entrySet()`	返回包含映射中所有条目的Set对象，这个组包含Map.Entry类型的对象。因此，该方法提供了调用映射的一个组视图
`boolean equals(Object obj)`	如果obj是Map对象并且与调用映射包含相同的条目，就返回true；否则返回false
`default void forEach(BiConsumer<? super K, ? super V> action)`	对调用映射中的每个元素执行action。如果在操作过程中移除了元素，会抛出ConcurrencyModificationException异常(JDK8新增)
`V get(Object k)`	返回与键k关联的值。如果没有找到键，就返回null
`default V getOrDefault(Object k, V defVal)`	如果映射中包含与k关联的值，就返回该值；否则，返回defVal(JDK8新增)
`int hashCode()`	返回调用映射的散列码
`boolean isEmpty()`	如果调用映射为空，就返回true；否则返回false
`Set<K> keyset()`	返回包含映射中某些键的Set对象。这个方法提供了调用映射中键的一个组视图
`default V merge(K k, V v, BiFunction<? super V, ? super V, ? extends V> func)`	如果k没有包含在映射中，就把k和v配对，添加到映射中，并返回v。否则，func基于原有的值返回一个新值，键被更新为使用这个新值，并且merge()方法返回这个值。如果func返回的值为null，就从映射中删除现有的键和值，并返回null(JDK8新增)
`V put(K k, V v)`	将一个条目放入调用映射中，覆盖之前与此键管理的值。键和值分别为k和v。如果键不存在，就返回null；否则，返回之前与键关联的值
`void putAll(Map<? extends K, ? extends V> m)`	将m中的所有条目添加到调用映射中
`default V putIfAbsent(K k, V v)`	如果此键值配对没有包含在调用映射中，或者现有的值为null，就将此配对添加到调用映射中，并返回原来的值。如果之前不存在映射，或者值为null，就返回null(JDK8新增)
`V remove(Object k)`	移除键等于k的条目
`default boolean remove(Object k, Object v)`	如果k和v指定的键值对包含在调用映射中，就移除该配对，并返回true。否则，返回false(JDK8新增)
`default boolean replace(K k, V oldV, V newV)`	如果k和oldV指定的键值对包含在调用映射中，就用newV替换oldV，并返回true；否则，返回false(JDK8新增)
`default V replace(K k, V v)`	如果k指定的键值包含在调用映射中，就将其值设为v，并返回原来的值。否则，返回false(JDK8新增)
`default void replaceAll(BiFunction<? super K, ? super V, ? extends V> func)`	对调用映射的每个元素执行func，用func返回的结果替换元素。如果在操作过程中删除元素，会抛出ConcurrentModificationException(JDK8新增)
`int size()`	返回映射中键值对的数量
`Collection<V> values()`	返回包含映射中所有值的集合。该方法提供了调用映射中值的一个集合视图

SortedMap

SortedMap接口扩展了Map接口，确保条目以升序保存，并且支持非常高效的子映射(即映射的子集)操作。SortedMap是泛型接口。

SortedMap接口声明的方法

方法	描述
`Comparator<? super K> comparator()`	返回调用的有序映射的比较器。如果调用映射使用的是自然排序，就返回null
`K firstKey()`	返回调用映射中第一个键
`SortedMap<K, V> headMap(K end)`	返回由键小于end的那些映射条目组成的有序映射
`K lastKey()`	返回调用映射中的最后一个键
`SortedMap<K, V> subMap(K start, K end)`	返回由键大于或等于start，但小于end的那些条目组成的有序映射
`SortedMap<K, V> tailMap(K start)`	返回由键大于或等于start的那些条目组成的有序映射

NavigableMap

NavigableMap接口扩展了SortedMap接口，支持基于最接近匹配原则的条目检索行为，即支持检索与给定的一个或多个键最相匹配的条目。NavigableMap是泛型接口。

Navigable接口声明的方法

方法	描述
`Map.Entry<K, V> ceilingEntry(K obj)`	搜索映射，查找大于等于obj的最小键。如果找到这样的键，就返回与之对应的条目；否则返回null
`K ceilingKey(K obj)`	搜索映射，查找大于等于obj的最小键。如果找到这样的键，就返回该键；否则返回null
`NavigableSet<K> descendingKeySet()`	返回的NavigableSet组以逆序形式包含调用映射的所有键。因此，该方法返回键的逆序组视图。结果组基于映射
`NavigableMap<K,V> descendingMap()`	返回NavigableMap映射是调用映射的逆序映射。结果映射基于调用映射
`Map.Entry<K,V> firstEntry()`	返回映射中的第一个条目，也就是具有最小键值的条目
`Map.Entry<K,V> floorEntry(K obj)`	搜索映射，查找小于等于obj的最大键。如果找到这样的键，就返回与之对应的条目，否则返回null
`K floorKey(K obj)`	搜索映射，查找小于等于obj的最大键。如果找到这样的键，就返回该键；否则返回null
`NavigableMap<K,V> headMap(K upperBound, boolean incl)`	返回的NavigableMap映射包含调用映射中、键小于upperBound的所有条目。如果incl为true，那么包含键等于upperBound的那个元素。结果映射基于调用映射
`Map.Entry<K,V> higherEntry(K obj)`	搜索组，查找大于obj的最小键。如果找到这样的键，就返回与之对应的条目；否则返回null
`K higherKey(K obj)`	搜索组，查找大于obj的最小键。如果找到这样的键，就返回该键；否则返回null
`Map.Entry<K,V> lastEntry()`	返回映射中最后一个条目，也就是具有最大键的条目
`Map.Entry<K,V> lowerEntry(K obj)`	搜索组，查找小于obj的最大键。如果找到这样的键，就返回与之对应的条目；否则返回null
`K lowerKey(K obj)`	搜索组，查找小于obj的最大的键。如果找到这样的键，就返回该键；否则返回null
`NavigableSet<K> navigableKeySet()`	返回包含调用映射中所有键的NavigableSet组，结果组基于调用映射
`Map.Entry<K,V> pollFirstEntry()`	返回第一个条目，在这个过程中移除该条目。因为映射是排过序的，所以也就是具有最小键值的条目。如果映射是空，就返回null
`Map.Entry<K,V> pollLastEntry()`	返回最后一个条目，在这个过程中移除该条目。因为映射是排过序的，所以也就是具有最大键值的条目。如果映射为空，就返回null
`NavigableMap<K,V> subMap(K lowerBound, boolean lowIncl, K upperBound, boolean highIncl)`	返回的NavigableMap映射包含调用映射中、键大于lowerBound且小于upperBound的所有条目。如果lowIncl为true，那么包含键等于lowerBound的那个元素；如果highIncl为true，那么包含键等于upperBound的那边元素。结果映射基于调用映射
`NavigableMap<K,V> tailMap(K lowerBound, boolean incl)`	返回的NavigableMap映射包含调用映射中、键大于lowerBound的所有条目。吐过incl为true，那么包含键等于lowerBound的那个元素。

Map.Entry

Map.Entry接口提供了操作映射条目的功能。Map.Entry是泛型接口。

Map.Entry接口声明的方法

方法	描述
`boolean equals(Object obj)`	如果obj是一个键和值都与调用对象相等的Map.Entry，就返回true
`K getKey()`	返回该映射条目的键
`V getValue()`	返回该映射条目的值
`int hashCode()`	返回该映射条目的散列值
`V setValue(V v)`	将这个映射条目的值设置为v。如果对于该映射v不是正确的类型，就抛出ClassCastException异常；如果v存在问题，那么抛出IllegalArgumentException异常；如果v为null但映射不允许null键，那么抛出NullPointerException异常；如果映射不允许修改，那么抛出UnsupportedOperationException异常

HashMap

HashMap扩展了AbstractMap类并实现了Map接口。它使用哈希表存储映射，这使得即使对于比较大的集合，get()和put()方法的执行时间也保持不变。HashMap是泛型类

哈希映射在存储的时候不保证元素的顺序。所以，向哈希映射添加元素的顺序不一定是通过迭代器读取它们的顺序。

构造函数

方法	描述
`HashMap()`	构造一个默认的哈希映射
`HashMap(Map<? extends K, ? extends V> m)`	使用m中的元素初始化哈希映射
`HashMap(int capacity)`	将哈希映射的容量初始化为capacity
`HashMap(int capacity, float fillRotio)`	使用参数同时初始化容量和填充率。默认容量是16，默认填充率是0.75

TreeMap

TreeMap扩展了AbstractMap类并实现了NavigableMap接口，该类用于创建存储在树结构中映射。TreeMap提供了有序存储键值对的高效手段，并且支持快速检索。与哈希映射不同，树映射确保元素以键的升序存储。TreeMap是泛型类。

构造函数

方法	描述
`TreeMap()`	构造一个空的树映射，使用键的自然顺序进行存储
`TreeMap(Comparator<? super K> comp)`	构造一个空的基于树的映射，使用比较器comp进行排序
`TreeMap(Map<? extends K, ? extends V> m)`	使用m中的条目初始化树的映射，使用键的自然顺序进行排序
`TreeMap(StortedMap<K, ? extends V> sm)`	使用sm中的条目初始化树映射，使用与sm相同的顺序进行排序

LinkedHashMap

LinkedHashMap扩展了HashMap类，在映射中以插入条目的顺序维护一个条目链表，从而可以按照插入顺序迭代整个映射。当变量LinkedHashMap的集合映射视图时，将以元素的插入顺序返回元素。也可以创建按照最后访问的顺序返回元素的LinkedHashMap。LinkedHashMap是泛型类。

构造函数

方法	描述
`LinkedHashMap()`	构造默认的LinedHashMap
`LinkedHashMap(Map<? extends K, ? extends V> m)`	使用m中的元素初始化LinkedHashMap
`LinkedHashMap(int capacity)`	构建一个指定默认容量的LinkedHashMap
`LinkedHashMap(int capacity, float fillRatio)`	构建一个指定初始化容量和填充率的LinkedHashMap
`LinkedHashMap(int capacity, float fillRatio, boolean Order)`	构建一个指定是按照插入顺序还是按照最后访问的顺序存储元素的LinkedHashMap。如果为true，就是有访问顺序；如果Order为false，就使用插入顺序

IdentityHashMap

IdentityHashMap扩展了AbstractMap类并实现了Map接口。除了当比较元素时使用相等性之外，其他方法与HashMap类似。IdentityHashMap是泛型类。

EnumMap

EnumMap扩展了AbstractMap类并实现了Map接口，是专门为了使用枚举类型的键而设计的。EnumMap是泛型类。

构造函数

方法	函数
`EnumMap(Class<K> kType)`	创建一个类型为kType的空EnumMap
`EnumMap(Map<K, ? extends V> m)`	创建一个包含m中相同条目的EnumMap
`EnumMap(EnumMap<K, ? extends V> em)`	创建一个使用em中的值进行初始化的EnumMap

元素访问

迭代器

为了能够通过迭代器访问集合，首先必须获得迭代器。每个集合类都提供了iterator()方法，该方法返回一个指向集合开头的迭代器。通过使用这个迭代器对象，可以访问集合中的每个元素，每次访问一个元素。通过，为了使用迭代器遍历集合的内容，需要以下步骤：

通过调用集合的iterator()方法，获取执行集合开头的迭代器
建立一个hasNext()方法调用循环。只有hasNext()方法返回true，就继续迭代
在循环中，通过调用next()方法获取每个元素。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class LearnIterator1 
{
    public static void main(String args[])
    {
        ArrayList<String> a1 = new ArrayList<String>();
        
        a1.add("C");
        a1.add("A");
        a1.add("E");
        a1.add("B");
        a1.add("D");
        a1.add("F");
        
        System.out.println("Original contents of a1:");
        Iterator<String> itr = a1.iterator();
        while(itr.hasNext()) {
            String element = itr.next();
            System.out.println(element + " ");
        }
        
        System.out.println();
        
        ListIterator<String> litr = a1.listIterator();
        while(litr.hasNext()) {
            String element = litr.next();
            System.out.println(element + " ");
        }
        
        System.out.println();
        
        while(litr.hasPrevious()) {
            String element = litr.previous();
            System.out.println(element + " ");
        }
        
        System.out.println();
    }
}

for-each

如果不修改集合的内容，也不用反向获取元素，那么使用for-each风格的for循环遍历集合通常比使用迭代器更方便。

import java.util.ArrayList;

public class LearnIterator2 
{
    public static void main(String args[])
    {
        ArrayList<Integer> vals = new ArrayList<Integer>();
        
        vals.add(1);
        vals.add(2);
        vals.add(3);
        vals.add(4);
        vals.add(5);
        
        System.out.println("Contents of vals:");
        
        for(int v : vals) {
            System.out.println(v + " ");
        }
        
        System.out.println();
        
        int sum = 0;
        for(int v : vals) {
            sum += v;
        }
        
        System.out.println("Sum of values : " + sum);
    }
}

Iterator

Iterator接口允许遍历集合，获取或移除元素。Iterator是泛型接口。

Iterator接口声明的方法

方法	描述
`default void forEachRemaining(Consumer<? super E> action)`	对于集合中每个未处理的元素，执行action指定的动作(JDK8新增)
`boolean hasNext()`	如果还有更多的元素，就返回true；否则返回false
`E next()`	返回下一个元素。如果不存在下一个元素，就抛出NoSuchElementException异常

ListIterator

ListIterator接口扩展了Iterator接口，允许双向遍历列表，并且允许修改元素。ListIterator是泛型接口。

ListIterator接口声明的方法

方法	描述
`void add(E obj)`	将obj插入到列表中，新插入的元素位于下一次next()方法调用返回的元素之前
`defaule void forEachRemaining(Consumer<? super E> action)`	对于集合中每个未处理的元素，执行action指定的动作(JDK8新增)
`boolean hasNext()`	如果还有更多的元素，就返回true；否则返回false
`boolean hasPrevious()`	如果存在前一个元素，就返回true；否则返回false
`E next()`	返回下一个元素。如果不存在下一个元素，就抛出NoSuchElementException异常
`int nextIndex()`	返回下一个元素的索引。如果不存在下一个元素，就返回列表的大小
`E previous()`	返回前一个元素。如果不存在前一个元素，就抛出NoSuchElementException异常
`int previousIndex()`	返回前一个元素的索引。如果不存在前一个元素，就返回-1
`void remove()`	从列表中移除当前元素。如果在调用next()或previous()方法之前调用remove()方法，那么会抛出IllegalStateException异常
`void set(E obj)`	将obj的值赋给当前元素，也就是next()或previous()方法调用最后返回的元素

Spliterator

Spliterator用于循环遍历元素序列，但是，使用spliterator的方法与使用迭代器不同。另外，它提供的功能远比Iterator或ListIterator多。最重要的是它支持并行迭代序列的一部分。Spliterator支持并行编程，即使用不到并行编程，也可以使用Spliterator。这么做的理由是它将hasNext和next操作合并到了一个方法中，从而提高了效率。Spliterator是泛型接口。

Spliterator接口声明的方法

方法	描述
`int characteristics()`	返回调用spliterator的特征，该特征被编码为整数
`long estimateSize()`	估计剩余的要迭代的元素数，并返回结果。如果由于某种原因得不到元素数，就返回Long.MAX_VALUE
`default void forEachRemaining(Consumer<? super T> action)`	将action应用到数据源中未被处理的每个元素
`default Comparator<? super T> getComparator()`	返回调用spliterator使用的比较器；如果使用了自然顺序，就返回null。如果序列未被排序，就抛出IllegalStateException异常
`default long getExactSizeIfKnown()`	如果调用spliterator是SIZED，就返回剩余的要迭代的元素数；否则返回false
`default boolean hasChracteristics(int val)`	如果val中传递了调用spliterator的特征，就返回true；否则返回false
`boolean tryAdvance(Consumer<? super T> action)`	在迭代中的下一个元素上执行action。如果没有下一个元素，就返回true；否则返回false
`Spliterator<T> trySplit()`	如果可以，分割调用spliterator，并返回对分割后新spliterator的引用；失败时，返回false。因此，在操作成时，原spliterator会迭代序列的一部分，返回的spliterator迭代序列的其他部分

import java.util.ArrayList;
import java.util.Spliterator;

public class LearnIterator3 
{
    public static void main(String args[])
    {
        ArrayList<Double> vals = new ArrayList<Double>();
        
        vals.add(1.0);
        vals.add(2.0);
        vals.add(3.0);
        vals.add(4.0);
        vals.add(5.0);
        
        System.out.println("Contents of vals:\n");
        Spliterator<Double> spltitr = vals.spliterator();
        while(spltitr.tryAdvance((n) -> System.out.println(n)));
        System.out.println();
        
        spltitr = vals.spliterator();
        ArrayList<Double> sqrs = new ArrayList<>();
        while(spltitr.tryAdvance((n) -> sqrs.add(Math.sqrt(n))));
        
        System.out.println("Contens of sqrs:\n");
        spltitr = sqrs.spliterator();
        spltitr.forEachRemaining((n)->System.out.println(n));
    }
}

比较器

如果希望以不同的方式排序元素，可以在构造组或映射时指定比较器，这样就可以精确控制在有序集合和映射中存储元素的方式。

Comparator接口声明的方法

方法	描述
`int compare(T obj1, T obj2)`	obj1和obj2比较，相对返回0；如果obj1大于obj2，返回整数；反之返回负数
`boolean equals(object obj)`	obj是将要进行相等测试的对象。如果obj1和调用对象都是比较器，并且使用相同的排序规则，那么返回true了否则返回false
`default Comparator<T> reversed()`	返回颠倒后的比较器。
`static <T extends Comparable<? super T>> Comparator<T> reverseOrder()`	返回一个颠倒元素的自然顺序的比较器。
`static <T extends Comparable<? super T>> Comparator<T> naturalOrder()`	返回一个使用自然顺序的比较器。
`static <T> Comparator<T> nullsFirst(Comparator<? super T> comp)`	返回的比较器认为null比其他值小
`static <T> Comparator<T> nullsLast(Comparator<? super T> comp)`	返回的比较认为null比其他值大
`default Comparator<T> thenComparing(Comparator<? super T> thenByComp)`	指定在第一次比较返回相等后调用的比较器
`default <U extends Comparable<? super U> Comparator<T> thenComparing(Function<? super T, ? extends U> getKey)>`	getKey引用的函数获得下一个比较键，当第一次比较返回相等后，将使用这个比较键
`default <U> Comparator<T> thenComparing(Function<? super T, ? extends U> getKey, Comparator<? super U> keyComp)`	keyComp指定用于比较键的比较器
`default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> getKey)`	getKey引用的函数用于获得下一个比较键
`default Comparator<T> thenComparingInt(ToIntFunction<? super T> getKey)`	getKey引用的函数用于获得下一个比较键
`default Comparator<T> thenComparingLong(ToLongFunction<? super T> getKey)`	getKey引用的函数用于获得下一个比较键
`static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> getKey)`	getKey引用的函数用于获得下一个比较键
`static <T, U> Comparator<T> comparing(Function<? super T, ? extends U> getKey, Comparator<? super U> keyComp)`	getKey引用的函数用于获得下一个比较键,keyComp指定了用于比较键的比较器
`static <T> Comparator<T> ComparingDouble(ToDoubleFunction<? super T> getKey)`	getKey引用的函数用于获得下一个比较键
`static <T> Comparator<T> ComparingInt(ToIntFunction<? super T> getKey)`	getKey引用的函数用于获得下一个比较键
`static <T> Comparator<T> ComparingLong(ToLongFunction<? super T> getKey)`	getKey引用的函数用于获得下一个比较键

import java.util.*;

class CompLastNames implements Comparator<String>
{
    public int compare(String aStr, String bStr)
    {
        int i, j;
        
        i = aStr.lastIndexOf(' ');
        j = bStr.lastIndexOf(' ');
        
        return aStr.substring(i).compareToIgnoreCase(bStr.substring(j));
    }
}

class CompThenByFirstName implements Comparator<String>
{
    public int compare(String aStr, String bStr)
    {
        int i, j;
        
        return aStr.compareToIgnoreCase(bStr);
    }
}

public class LearnComparator1 
{
    public static void main(String args[])
    {
        CompLastNames compLN = new CompLastNames();
        Comparator<String> compLastThenFirst = compLN.thenComparing(new CompThenByFirstName());
        
        TreeMap<String, Double> tm = new TreeMap<String, Double>(compLastThenFirst);
        
        tm.put("John Doe", new Double(3434.32));
        tm.put("Tom Smith", new Double(123.22));
        tm.put("Jane Baker", new Double(1378.00));
        tm.put("Tod Hall", new Double(99.22));
        tm.put("Ralph Smith", new Double(-19.08));
        
        Set<Map.Entry<String, Double>> set = tm.entrySet();
        
        for(Map.Entry<String, Double> me : set) {
            System.out.println(me.getKey() + " : " + me.getValue());
        }
        
        System.out.println();
        
        double balance = tm.get("John Doe");
        tm.put("John Doe", balance + 1000);
        
        System.out.println("John Doe's new balance: " + tm.get("John Doe"));
    }
}

算法

集合框架定义了一些算法，可以用于集合和映射快速的完成某些操作。

Collections定义的算法方法

方法	描述
`static <T> boolean addAll(Collection<? super T> c, T ... elements)`	将由elements指定的元素插入由c指定的集合中。如果元素被插入c中，就返回true；否则返回false
`static <T> Queue<T> asLifoQueue(Deque<T> c)`	返回c的一个后进先出的视图
`static <T> int binarySearch(List<? extends T> list, T value, Comparator<? super T> c)`	根据c以确定的顺序在list中查找value。返回value在list中的位置，如果没有找到，就返回一个负值
`static <T> int binarySearch(List<? extends Comparable<? super T>> list, T value)`	在list中查找value，列表必须是排过序的。返回value在list中的位置，如果没有找到value，就返回一个负值
`static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> t)`	返回集合的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常
`static <E> List<E> checkedList(List<E> c, Class<E> t)`	返回List的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常
`static <K,V> Map<K,V> checkedMap(Map<K,V> c, Class<K> keyT, Class<V> valueT)`	返回Map的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常
`static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> nm, Class<E> keyT, Class<V> valueT)`	返回NavigableMap的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常(JDK8新增)
`static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> ns, Class<E> t)`	返回NavigableSet的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常(JDK8新增)
`static <E> Queue<E> checkedQueue(Queue<E> q, Class<E> t)`	返回Queue的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常(JDK8新增)
`static <E> List<E> checkedSet(Set<E> c, Class<E> t)`	返回Set的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常
`static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> c, Class<K> keyT, Class<V> valueT)`	返回SortedMap的一个运行时类型安全视图。如果试图插入不兼容的元素，那么会导致ClassCastException异常
`static <E> SortedSet<E> checkedSortedSet(SortedSet<E> c, Class<E> t)`	返回SortedSet的一个运行时类型安全视图。如果视图插入不兼容的元素，那么会导致ClassCastException异常
`static <T> void copy(List<? super T> list1, List<? extends T> list2)`	将list2中的元素复制到list1中
`static boolean disjoint(Collection<?> a, Collection<?> b)`	比较a和b中的元素。如果两个集合不包含公共元素(即集合包含不相交的一组元素)，就返回true；否则返回false
`static <T> Enumeration<T> emptyEnumeration()`	返回一个空的枚举，即没有元素的枚举
`static <T> Iterator<T> emptyIterator()`	返回一个空的迭代器，即没有元素的迭代器
`static <T> List<T> emptyList()`	返回一个推断类型的、不可变的空List对象
`static <T> ListIterator<T> emptyListIterator()`	返回一个空的迭代器，即没有元素的列表迭代器
`static <K,V> Map<K,V> emptyMap()`	返回一个推断类型的、不可变的空Map对象
`static <K,V> NavigableMap<K,V> emptyNavigableMap()`	返回一个推断类型的、不可变的空NavigableMap对象(JDK8新增)
`static <E> NavigableSet<E> emptyNagivableSet()`	返回一个推断类型的、不可变的空的NavigableSet对象(JDK8新增)
`static <T> Set<T> emptySet()`	返回一个推断类型的、不可变的空的Set对象
`static <K,V> SortedMap<K,V> emptySortedMap()`	返回一个推断类型的、不可变的空SortedMap对象(JDK8新增)
`static <E> SortedSet<E> emtpySortedSet()`	返回一个推断类型的、不可变的空SortedSet对象(JDK8新增)
`static <T> Enumeration<T> enumeration(Collection<T> c)`	返回一个基于集合c的枚举
`static <T> void fill(List<? super T> list, T obj)`	将obj赋给list中的每个元素
`static int frequency(Collection<?> c, Object obj)`	计算obj在集合c中出现的次数并返回结果
`static int indexOfSubList(List<?> list, List<?> subList)`	查找list中subList首次出现的位置。返回首次匹配时的位置索引。如果没有找到匹配，就返回-1
`static int lastIndexOfSubList(List<?> list, List<?> subList)`	查找list中subList最后一次出现的位置。返回最后匹配时的位置索引。如果没有找到匹配，就返回-1
`static <T> ArrayList<T> list(Enumeration<T> enum)`	返回一个包含enum中元素的ArrayList
`static <T> T max(Collection<? extends T> c, Comparator<? super T> comp)`	返回集合c中由comp决定的最大元素
`static <T extends object & Comparable<? super T>> T max(Collection<? extends T> c)`	返回集合c中由自然顺序决定的最大元素，集合不必是排过序的
`static <T> min(Collection<? extends T> c, Comparator<? super T> comp)`	返回集合c中由comp决定的最小元素，集合不必是排过序的
`static <T extends object & Comparable<? super T>> T min(Collection<? extends T> c)`	返回集合c中由自然顺序决定的最小元素
`static <T> List<T> nCopies(int num, T obj)`	返回包含在一个不可变列表中的obj的num个副本，num必须大于或等于0
`static <E> Set<E> newSetFromMap(Map<E, Boolean> m)`	创建并返回由m指定的映射所支持的一个集合。调用该方法时，映射必须为空
`static <T> boolean replaceAll(List<T> list, T old, T new)`	将list中的所有old替换为new。如果至少发生一次替换，就返回true；否则返回false
`static void reverse(List<T> list)`	颠倒list中元素的顺序
`static <T> Comparator<T> reverseOrder(Comparator<T> comp)`	返回一个逆序比较器，基于传递到comp中的比较器。也就是说，返回的比较器会颠倒comp的比较结果
`static <T> Comparator<T> reverseOrder()`	返回一个逆序比较器，也就是颠倒两个元素比较结果的比较器
`static void rotate(List<T> list, int n)`	将list向右旋转n个位置。要向左旋转，可使用n的负值
`static void shuffle(List<T> list, Random r)`	使用r作为随机数的来源，搅乱(即随机)list中的元素
`static <T> Set<T> singleton(T obj)`	将obj作为不可变的组返回，这是将单个对象转换成组的一种简单方式
`static <T> List<T> singletonList(T obj)`	将obj作为不可变的列表返回，这是将单个对象转换成列表的一种简单方式
`static <K,V> Map<K,V> singletonMap(K k, V v)`	将键值对kv作为不可变的映射返回，这是将单个键值对转换成映射的一种简单方式
`static <T> void sort(List<T> list, Comparator<? super T> comp)`	按照由comp决定的顺序对list中的元素进行排序
`static <T extends Comparable<? super T>> void sort(List<T> list)`	按照自然顺序对list中的元素进行排序
`static void swap(List<?> list, int idx1, int idx2)`	交换list中由idx1和idx2指定的索引位置的元素
`static <T> Collection<T> synchronizedCollection(Collection<T> c)`	返回基于集合c的线程安全的集合
`static <T> List<T> synchronizedList(List<T> list)`	返回基于list的线程安全的列表
`static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)`	返回基于m的线程安全的映射
`static <K,V> NagivableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> nm)`	返回基于nm的同步的NavigableMap对象(JDK8新增)
`static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> ns)`	返回基于ns的同步的NavigableSet对象(JDK8新增)
`static <T> Set<T> synchronizedSet(Set<T> s)`	返回基于s的线程安全的组
`static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> sm)`	返回基于sm的线程安全的有序映射
`static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> ss)`	返回基于ss的线程安全的有序组
`static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)`	返回基于c的不可修改的集合
`static <T> List<T> unmodifiableList(List<? extends T> list)`	返回基于list的不可修改的列表
`static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m)`	返回基于m的不可修改的映射
`static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> nm)`	返回基于nm的不可修改的NavigableMap对象(JDK8新增)
`static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> ns)`	返回基于ns的不可修改的NavigableSet对象
`static <T> Set<T> unmodifiableSet(Set<? extends T> s)`	返回基于s的不可修改的组
`static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> sm)`	返回基于sm的不可修改的有序映射
`static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> ss)`	返回基于ss的不可修改的有序组

注意有些方法用于获取各种几何的同步(线程安全的)副本，例如synchronizedList()和synchronizedSet()。作为一般规则，标准集合实现不是同步的。必须使用同步算法提供同步。另外一点：同步集合的迭代器必须在synchrodnized代码块中使用。

import java.util.*;

public class LearnAlgorithm1 
{
    public static void main(String args[])
    {
        LinkedList<Integer> ll = new LinkedList<Integer>();
        ll.add(-8);
        ll.add(20);
        ll.add(-20);
        ll.add(8);
        
        Comparator<Integer> r = Collections.reverseOrder();
        Collections.sort(ll, r);
        
        System.out.println("List sorted in reverse:");
        for(int i : ll) {
            System.out.print(i + " ");
        }
        
        System.out.println();
        
        Collections.shuffle(ll);
        
        System.out.println("List shuffled:");
        for(int i : ll) {
            System.out.print(i + "  ");
        }
        
        System.out.println();
        System.out.println("Minimum: " + Collections.min(ll));
        System.out.println("Maximum: " + Collections.max(ll));
    }
}

Arrays

Arrays类提供了对数组操作有用的方法，这些方法有助于连接集合和数组。

Arrays声明的方法

方法	描述
`static <T> List asList(T ... array)`	返回基于指定数组的列表。列表和数组引用相同的位置
`static int binarySearch(byte array[] byte value) ...`	使用二分搜索法查找特定数值。只能为排过序的数组应用这个方法。
`static boolean[] copyOf(boolean[] source, int len) ...`	截取副本指定长度并返回数组的副本
`static boolean[] copyOfRange(boolean[] source, int start, int end) ...`	截取副本指定范围并返回副本数组
`static boolean equals(boolean array[], boolean array2[]) ...`	比较2个数组的内容是否相等
`static boolean deepEquals(Object[] a, Object[] b)`	用于比较两个可能包含嵌套数组的数组是否相等
`static void fill(boolean array[], boolean value) ...`	将某个值赋个数组中的所有元素，也就是使用指定的值填充数组。
`static void sort(byte array[]) ...`	对数组进行排序，从而使其中的元素以升序进行排列。
`static void parallelSort(byte array[]) ...`	并行的方式进行排序，然后合并结果
`static Spliterator.OfDouble spliterator(double array[]) ...`	并行的方式遍历数组
`static DoubleStream stream(double array[]) ...`	将数组以流的方法返回
`static void setAll(double array[], IntToDoubleFunction<? extends T> genVal)`	为所有的元素赋值
`static void parallelSetAll(double array[], IntToDoubleFunction<? extends T> genVal) ...`	并行的方式为所有元素赋值

import java.util.Arrays;

public class LearnArray1 
{
    public static void main(String args[])
    {
        int array[] = new int[10];
        for(int i = 0; i < 10; i++) {
            array[i] = -3 * i;
        }
        
        System.out.print("Original Contends : ");
        display(array);
        Arrays.sort(array);
        System.out.print(" Sorted: ");
        display(array);
        
        Arrays.fill(array, 2, 6, -1);
        System.out.print("After fill: ");
        display(array);
        
        Arrays.sort(array);
        System.out.print("After sorting again:");
        display(array);
        
        System.out.print("The value -9 is at location");
        int index = Arrays.binarySearch(array, -9);
        
        System.out.println(index);
        
    }
    
    static void display(int array[])
    {
        for(int i : array) {
            System.out.print(i + "  ");
        }
        
        System.out.println();
    }
}

遗留类和接口

Enumeration

使用Enumration接口定义的方法可以枚举(每次获取一个)对象集合中的元素。这个遗留接口已经被Iterator接口取代。

Vector

Vector实现了动态数组，与ArrayList类似，但是有两个区别：Vector是同步的，并且包含取代遗留的方法，这些方法与集合框架定义的方法具有相同的功能。随着集合的出现，对Vector进行了重新设计以扩展AbstractList类实现List接口。随着JDK5的发布，对Vector进行了重修以使用泛型，并进行了重修设计以实现Iterable接口。这意味着Vector与集合完全兼容，并且可以通过增加的for循环来迭代Vector内容。

Stack

Stack是Vector的子类，实现了标准的后进先出堆栈。

Dictionary

Dictionary是表示键值对存储库的抽象类，其操作与Map类似。

Hashtable

Hashtable是Dictionary的具体实现，与HaskMap类似，Hashtable在哈希表中存储键值对。但是键和值不能是null。当使用Hashtable时，需要指定作为键的对象以及与键关联的值。然后对键进行散列，产生的哈希码用作索引，在哈希表中对应索引的位置存储值。

Properties

Properties是Hashtable的子类，用于保存值的列表。在列表中，键是String类型，值也是String类型。

使用Properties类最有用的方面之一是：在Properties对象中保存的信息，可以使用store()和load()方法很容易地存储到磁盘中已经从磁盘中加载。在任何时候，都可以将Properties对象写入到流中或者从流中读取。这使得对于实现简单的数据库来说，属性列表特别方便。

import java.io.*;
import java.util.*;

public class LearnProperties1 
{
    public static void main(String args[]) throws IOException
    {
        Properties ht = new Properties();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String name, number;
        FileInputStream fin = null;
        boolean changed = false;
        
        try {
            fin = new FileInputStream("phonebook.dat");
        } catch(FileNotFoundException e) {
            
        } 
        
        try {
            if(fin != null) {
                ht.load(fin);
                fin.close();
            }
        } catch(IOException e) {
            System.out.println("Error reading file");
        }
        
        do {
            System.out.println("Enter new name ('quit' to stop) :");
            name = br.readLine();
            if(name.equals("quit")) {
                continue;
            }
            
            System.out.println("Enter number:");
            number = br.readLine();
            
            ht.put(name, number);
            changed = true;
        } while(!name.equals("quit"));
        
        if(changed) {
            FileOutputStream fout = new FileOutputStream("phonebook.dat");
            
            ht.store(fout, "Telephone Book");
            fout.close();
        }
        
        do {
            System.out.println("Enter name to find ('quit' to quit):");
            name = br.readLine();
            
            if(name.equals("quit")) {
                continue;
            }
            
            number = (String)ht.get(name);
            System.out.println(number);
        } while(!name.equals("quit"));
    }
}