Java Reference

总结一些 Java 常用的集合接口以及一些工具类。

Java Collections 类

Collection is the root interface in the collection hierarchy. A collection represents a group of objects, known as its elements. Some collections allow duplicate elements and others do not. Some are ordered and others unordered. The JDK does not provide any direct implementations of this interface: it provides implementations of more specific subinterfaces like Set and List. This interface is typically used to pass collections around and manipulate them where maximum generality is desired.

Collection 总览

Collection	Interface	Ordered	Sorted	Thread safe	Duplicate	Nullable
ArrayList	List	Y	N	N	Y	Y
Vector	List	Y	N	Y	Y	Y
LinkedList	List, Deque	Y	N	N	Y	Y
CopyOnWriteArrayList	List	Y	N	Y	Y	Y
HashSet	Set	N	N	N	N	One null
LinkedHashSet	Set	Y	N	N	N	One null
TreeSet	Set	Y	Y	N	N	N
CopyOnWriteArraySet	Set	Y	N	Y	N	One null
ConcurrentSkipListSet	Set	Y	Y	Y	N	N
HashMap	Map	N	N	N	N (key)	One null (key)
HashTable	Map	N	N	Y	N (key)	N (key)
LinkedHashMap	Map	Y	N	N	N (key)	One null (key)
TreeMap	Map	Y	Y	N	N (key)	N (key)
ConcurrentHashMap	Map	N	N	Y	N (key)	N
ConcurrentSkipListMap	Map	Y	Y	Y	N (key)	N
ArrayDeque	Deque	Y	N	N	Y	N
PriorityQueue	Queue	Y	N	N	Y	N
ConcurrentLinkedQueue	Queue	Y	N	Y	Y	N
ConcurrentLinkedDeque	Deque	Y	N	Y	Y	N
ArrayBlockingQueue	Queue	Y	N	Y	Y	N
LinkedBlockingDeque	Deque	Y	N	Y	Y	N
PriorityBlockingQueue	Queue	Y	N	Y	Y	N

collections

下面是 Collection 接口所定义的方法。

// 添加方法
boolean add(E e); // 添加一个对象
boolean addAll(Collection<? extends E> c); // 添加一个集合的对象
// 删除方法
void clear(); // 移除所有对象
boolean remove(Object); // 移除一个对象
boolean removeAll(Collection<?> c); // 移除一个集合的对象，只要有一个对象移除了，就返回true。
boolean removeIf(Predicate<? super E> filter); // 按照一个断言规则过滤集合中的对象。
// 判断方法
boolean contains(Object o); // 判断集合是否包含该对象
boolean containsAll(Collection<?> c); // 判断集合中是否包含指定的集合对象，只有包含所有的对象，才返回 true。
boolean isEmpty(); // 判断集合是否为空。
boolean equals(Object o) // 判断两个集合是否相等（元素的个数以及各个元素都相等）
// 其他
Iterator<E> iterator(); // 迭代器
boolean retainAll(Collection<?> c); // 保留当前集合中所有位于c中的元素
int size(); // 对象个数
Object[] toArray(); // 转换为数组

三大基本接口

Collection 可以主要分为 Set、List、Queue 三种类型。Map 是不属于 Collection 的，Map 是一个独立的数据结构。但是 Collention 又和 Map 的实现上又互相依赖。

Queue

定义

public interface Queue<E> extends Collection<E>;

方法

// Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
boolean add(E e);
// The offer method inserts an element if possible, otherwise returning false. This differs from the Collection.add method, which can fail to add an element only by throwing an unchecked exception. The offer method is designed for use when failure is a normal, rather than exceptional occurrence, for example, in fixed-capacity (or "bounded") queues.
boolean offer(E e); 

// Retrieves and removes the head of this queue. This method differs from poll() only in that it throws an exception if this queue is empty.
E remove();
// Retrieves and removes the head of this queue, or returns null if this queue is empty.
E poll(); 

// The element() and peek() methods return, but do not remove, the head of the queue.
// This method differs from peek only in that it throws an exception if this queue is empty.
E element();
// Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
E peek();

Deque

定义

public interface Deque<E> extends Queue<E>

方法

void addFirst(E e); // 添加一个元素到Deque首部，若没有空间添加则抛出IllegalStateException异常
void addLast(E e); // 添加一个元素到Deque尾部，若没有空间添加则抛出IllegalStateException异常
boolean offerFirst(E e); // 添加一个元素到Deque首部，若没有空间添加则返回false
boolean offerLast(E e); // 添加一个元素到Deque尾部，若没有空间添加则返回false

E removeFirst(); // 移除队首元素并将其返回，当队列为空时抛出NoSuchElementException异常
E removeLast(); // 移除队尾元素并将其返回，当队列为空时抛出NoSuchElementException异常
E pollFirst(); // 移除队首元素并将其返回，当队列为空时返回null
E pollLast(); // 移除队尾元素并将其返回，当队列为空时返回null

E getFirst(); // 返回队首元素，当队列为空时抛出NoSuchElementException异常
E getLast(); // 返回队尾元素，当队列为空时抛出NoSuchElementException异常
E peekFirst(); // 返回队首元素，当队列为空时返回null
E peekLast(); // 返回队尾元素，当队列为空时返回null

boolean removeFirstOccurrence(Object o); // 移除第一次出现的元素o
boolean removeLastOccurrence(Object o); // 移除最后一次出现的元素o

// 栈方法
void push(E e); // 压栈，等价于addFirst
E pop(); // 出栈，等价于removeFirst

List

定义

public interface List<E> extends Collection<E>;

方法

// 修改列表
void add(int index, E element); // 在指定位置添加元素
boolean addAll(int index, Collection<? extends E> c); // 在指定位置添加集合c中的元素
void replaceAll(UnaryOperator<E> operator); // 替换List中的元素
E remove(int index); // 移除指定位置的元素
E set(int index, E element); // 替换指定位置的元素
void sort(Comparator<? super E> c); // 先调用toArray方法将List转为Array，然后调用Arrays.sort根据比较器c排序
List<E> subList(int fromIndex, int toIndex); // 返回[fromIndex, toIndex)的子列表

// 查询列表
E get(int index); // 获取指定位置的元素
int indexOf(Object o); // 返回元素下标，元素不存在则返回-1
int lastIndexOf(Object o); // 返回元素下标，若有多个雷同元素，返回该元素最后一次出现的下标，元素不存在返回-1

// 静态构造列表 下面的静态方法全部返回一个不可修改的List
static <E> List<E> copyOf(Collection<? extends E> coll); // 返回一个包含coll中的元素的不可修改的List
static <E> List<E> of(); // 返回一个不可修改的空List
static <E> List<E> of(E e1); // 返回一个不可修改的包含e1的List
static <E> List<E> of(E e1, E e2); // 返回一个不可修改的包含e1，e2的List
...
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10); // 返回一个不可修改的包含e1...e10的List
static <E> List<E> of(E... elements); // 返回一个不可修改的包含任意多个元素的List

Set

定义

public interface Set<E> extends Collection<E>;

方法

// 静态构造集合 下面的静态方法全部返回一个不可修改的Set
static <E> List<E> copyOf(Collection<? extends E> coll); // 返回一个包含coll中的元素的不可修改的Set
static <E> List<E> of(); // 返回一个不可修改的空Set
static <E> List<E> of(E e1); // 返回一个不可修改的包含e1的Set
static <E> List<E> of(E e1, E e2); // 返回一个不可修改的包含e1，e2的Set
...
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10); // 返回一个不可修改的包含e1...e10的Set
static <E> List<E> of(E... elements); // 返回一个不可修改的包含任意多个元素的Set

Java 工具类

只需掌握最常用的两个工具类的使用方法即可。

Arrays

public static <T> List<T> asList(T... a); // 返回一个固定大小的List，包含a中所有元素

• 该方法适用于对象型数据的数组
• 该方法不建议使用于基本数据类型的数组
• 该方法将数组与返回的 List 连接起来，当更新其中一个时，另一个自动更新
• 不支持 add()、remove()、clear() 等方法

public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c);
public static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)

• 该方法只能用于已有序，且升序排列的数组
• 数组中的两个元素按照比较器 c 排序必须是升序的
• 可以在整个数组中查找，也可以在某个范围内查找。

public static <T> boolean equals(T[] a, T[] a2, Comparator<? super T> cmp);

• 当两个数组根据比较器 cmp 比较完全相等时返回 true。

public static void fill(Object[] a, Object val);
public static void fill(float[] a, int fromIndex, int toIndex, float val);

• 利用给定的 val 值去填充数组。
• 可以填充整个数组，也可以只填充部分数组。

public static <T> void sort(T[] a, Comparator<? super T> c);
public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c);
public static <T> void parallelSort(T[] a, Comparator<? super T> cmp);
public static <T> void parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp);

• 所有基本数据类型数组的底层排序算法采用 DualPivotQuicksort，所有泛型数组的底层排序算法采用 TimeSort（归并排序算法的优化版本）。
• 有单线程和多线程的排序算法可供选择。

public static <T> Stream<T> stream(T[] array);
public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive);
public static String toString(Object[] a);

Collections

public static <T> boolean addAll(Collection<? super T> c, T... elements); // 将elements添加到集合c中

public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key); // 使用二分查找算法查找list
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c); // 使用二分查找算法查找list，需要传入比较器

public static <T> void fill(List<? super T> list, T obj); // 填充list
public static int frequency(Collection<?> c, Object o); // 统计元素出现的频率

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll); // 寻找最大值
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp); // 寻找最大值
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll); // 寻找最小值
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp); // 寻找最小值

public static <T> ArrayList<T> list(Enumeration<T> e); // 将数据转换为List

public static void reverse(List<?> list); // 反转列表
public static void rotate(List<?> list, int distance); // 旋转列表
public static void shuffle(List<?> list); // 置乱列表

public static <T extends Comparable<? super T>> void sort(List<T> list); // 排序，实际是调用List的sort方法
public static <T> void sort(List<T> list, Comparator<? super T> c); // 排序，实际是调用List的sort方法
public static void swap(List<?> list, int i, int j); // 交换List中的两个元素

Comparable

public interface Comparable<T> {
  
	public int compareTo(T o); // 返回负数，0，正数，分别表示小于，等于，大于o。
  
}

Comparator

public interface Comparator<T> {
  
	int compare(T o1, T o2); // 返回负数，0，正数，分别表示o1小于，等于，大于o2。
  
}