提供了Collection接口的基础实现，具体来说，实现了如下方法：
public boolean addAll(Collection<? extends E> c) public boolean contains(Object o) public boolean containsAll(Collection<?> c) public boolean isEmpty() public boolean remove(Object o) public boolean removeAll(Collection<?> c) public boolean retainAll(Collection<?> c) public void clear() public Object[] toArray() public <T> T[] toArray(T[] a) public String toString()
AbstractCollection不知道基础数据是怎么存储的，它如何实现这些方法呢？
它依赖于如下更为基础的方法：
public boolean add(E e) public abstract int size(); public abstract Iterator<E> iterator();
add方法：
public boolean add(E e) { throw new UnsupportedOperationException();//如果子类集合是不可被修改的，则不用重写该方法，使用默认实现就可以了，否则必须重写 }
size()是抽象方法，iterator也是抽象方法。
提供了List接口的基本实现：
public boolean add(E e) public boolean addAll(int index, Collection<? extends E> c) public void clear() public boolean equals(Object o) public int hashCode() public int indexOf(Object o) public Iterator<E> iterator() public int lastIndexOf(Object o) public ListIterator<E> listIterator() public ListIterator<E> listIterator(final int index) public List<E> subList(int fromIndex, int toIndex)
abstrackList通过如下更为基础的方法实现：
public abstract int size(); abstract public E get(int index); public E set(int index, E element) public void add(int index, E element) public E remove(int index) //set, add, remove默认实现都是抛出异常
另外，AbstrackList不需要实现迭代器类和相关方法，因为其内部已经实现了。
它是AbstractList子类，它实现了如下方法：
public void add(int index, E element) public boolean addAll(int index, Collection<? extends E> c) public E get(int index) public Iterator<E> iterator() public E remove(int index) public E set(int index, E element)
它实现了根据索引位置进行操作的get,set,add,remove方法
这是通过重写listIterator（）方法实现的。
public E get(int index) { try { return listIterator(index).next(); } catch (NoSuchElementException exc) { throw new IndexOutOfBoundsException("Index: "+index); } }
虽然AbstractSequentialLis 是AbstrackList的子类，但实现逻辑和用法上和Abstract正好相反。
Abstrack需要具体子类写根据索引操作的方法get,set,add,remove,它提供了迭代器，但迭代器是
基于这些方法实现的。它假定子类可以高效地根据索引位置进行操作，适用于内部是随机访问类型
的存储结构（如数组），比如ArrayList就继承自AbstrackList。
AbstractSequentialList 需要具体子类重写迭代器，它提供了根据索引的操作方法get,set,add,
remove,但这些方法是基于迭代器实现的。它适用于内部是顺序访问类型的存储结构（如链表）。
AbstrackMap提供了Map接口的基础实现：
public void clear() public boolean containsKey(Object key) public boolean containsValue(Object value) public boolean equals(Object o) public V get(Object key) public int hashCode() public boolean isEmpty() public Set<K> keySet() public void putAll(Map<? extends K, ? extends V> m) public V remove(Object key) public int size() public String toString() public Collection<V> values()
AbstractMap 实现这些方法依赖于更基础的方法：
public V put(K key, V value) //抽象方法，子类必须实现 public abstract Set<Entry<K,V>> entrySet();
定义了两个公有的静态内部类：
AbstractMap.SimpleEntry implements Entry<K,V> //表示只读的键值对 AbstractMap.SimpleImmutableEntry implements Entry<K,V>
1.二分查找
//二分查找 public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) public static <T> int binarySearch(List<? extends T> list,T key, Comparator<? super T> c)
二分查找要求List中的元素是从小到大排序的。如果是从大到小排序，
需要传递一个逆序Comparator对象，Collections提供了返回逆序Comparator的方法：
public static <T> Comparator<T> reverseOrder() public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
ArrayList<Integer> list = new ArrayList<>(Arrays.asList
(new Integer[]{33, 22, 37, 88, 1, 8, 9}));
Collections.sort(list);
System.out.println(Collections.binarySearch(list, 22)); //3
2.查找最大最小值:
<T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
3.查找元素出现次数：
public static int frequency(Collection<?> c, Object o)
4.在sourceList中查找targetList的位置：
public static int indexOfSubList(List<?> source, List<?> target) public static int lastIndexOfSubList(List<?> source, List<?> target)
indexOfSubList 从头开始查找，lastIndexOfList从结尾开始查找，没有找到返回-1，
找到第一个匹配元素的索引位置。
5.查看两个集合是否有交集：
public static boolean disjoint(Collection<?> c1, Collection<?> c2)//没有返回true，有返回false
6.替换：
public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)//替换成功返回true
1.排序、交换位置与翻转：
public static <T extends Comparable<? super T>> void sort(List<T> list) public static <T> void sort(List<T> list, Comparator<? super T> c)
//交换元素位置 public static void swap(List<?> list, int i, int j)
//翻转 public static void reverse(List<?> list)
2.随机化重排：
public static void shuffle(List<?> list) public static void shuffle(List<?> list, Random rnd)
原文：https://www.cnblogs.com/Shadowplay/p/10032026.html