Java集合框架

public interface Collection<E> extends Iterable<E> {
    // Query Operations（查询操作）
    // 返回集合的元素个数
    int size();

    // 集合是否为空，即没有元素
    boolean isEmpty();

    // 查看集合是否包含特定的元素
    boolean contains(Object o);

    // 返回集合的迭代器，用于遍历集合元素
    Iterator<E> iterator();

    // 把集合里面的全部元素转换成数组类型返回
    Object[] toArray();

    // 和上面的方法类似，不过这里可以指定元素的类型
    <T> T[] toArray(T[] a);

    // Modification Operations（修改操作）
    // 添加一个元素到集合中
    boolean add(E e);

    // 从集合中移除特定的元素
    boolean remove(Object o);

    // Bulk Operations（批量操作）
    // 集合是否包含另一个集合的所以元素
    boolean containsAll(Collection<?> c);

    // 把另一个集合的元素添加到该集合
    boolean addAll(Collection<? extends E> c);
 
    // 移除该集合中和另一个集合相同的元素
    boolean removeAll(Collection<?> c);
    
    // 只保留该集合中和另一个集合相同的元素
    boolean retainAll(Collection<?> c);

    // 清空集合中的元素
    void clear();

    // Comparison and hashing

    boolean equals(Object o);

    int hashCode();
}

public interface Set<E> extends Collection<E> {
    // 往集合里面添加一个元素，如果元素已存在，则添加失败，返回false
    boolean add(E e);
}

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

    // 往集合里面添加一个元素，添加到集合的最后面
    boolean add(E e);
    
    // 获取下标为index的元素，List的下标和数组一样，从0开始
    E get(int index);

    // 替换下标为index的元素为指定的元素
    E set(int index, E element);

    // 添加一个元素到下标为index的位置，接着原来这个位置及其后面的元素都向后移动
    // 如果index越界了，则插入失败，并抛出异常，所以index不能大于集合的元素个数
    void add(int index, E element);

    // 移除下标为index的位置的元素，接着把这个位置后面的元素向前移动
    // 如果index越界了，则移除失败，并抛出异常，所以index不能大于或等于集合的元素个数
    E remove(int index);

    // 查找集合中对应的元素，找到了则返回其下标，找不到返回-1
    // 如果对应元素在集合里面出现了多次，将会返回最早出现（最小下标）的元素的下标
    int indexOf(Object o);

    // 查找集合中对应的元素，找到了则返回其下标，找不到返回-1
    // 如果对应元素在集合里面出现了多次，将返回最后出现（最大下标）的元素的下标
    int lastIndexOf(Object o);

    // 返回有序的迭代器
    ListIterator<E> listIterator();

    // 返回从指定下标开始的有序的迭代器
    ListIterator<E> listIterator(int index);
    
    // 返回集合的一部分元素，从fromIndex开始（包括fromIndex），到toIndex结束（不包括toIndex）
    List<E> subList(int fromIndex, int toIndex);
}

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
    E next();
    boolean hasPrevious();
    E previous();  // 访问前一个元素
    int nextIndex();
    int previousIndex();
    void remove();
    void set(E e);
    void add(E e);
}

public interface Queue<E> extends Collection<E> {
    // 添加一个元素到队列，在先进先出队列中，是添加到队列尾部
    // 如果由于容量不足插入失败，则抛出异常，不会返回false
    boolean add(E e);
    
    // 和add方法一样，不过不同之处在于，这个方法添加失败一般是返回false，而不是抛出异常
    boolean offer(E e);
    
    // 移除队列尾部的元素（最后进来的元素），如果队列为空，则抛出异常，不返回false
    E remove();

    // 和remove方法一样，不过这个方法在队列为空时会返回false，不抛出异常
    E poll();

    // 查看队列头部的元素（最先进来的元素），如果队列为空，则抛出异常，不返回null
    E element();
    
    // 和element方法一样，不过这个在队列为空时，返回null，不抛出异常
    E peek();
}

public interface Deque<E> extends Queue<E> {
    // 添加元素到队列头部，如果添加失败，则抛出异常
    void addFirst(E e);

    // 添加元素到队尾，如果添加失败，则抛出异常
    void addLast(E e);

    // 和addFirst一样，不同之处是该方法有返回值，由于容量不足添加失败会返回false
    boolean offerFirst(E e);

    // 和addLast一样，不同之处是该方法有返回值，由于容量不足添加失败会返回false
    boolean offerLast(E e);

    // 移除并返回队首元素，如果队列为空则抛出异常，不返回null
    E removeFirst();

    // 移除并返回队尾元素，如果队列为空则抛出异常，不返回null
    E removeLast();

    // 和removeFirst方法一样，不过该方法在队列为空的时候返回null，不抛出异常
    E pollFirst();

    // 和removeLast方法一样，不过该方法在队列为空的时候返回null，不抛出异常
    E pollLast();

    // 返回队首元素，如果队列为空则抛出异常，不返回null
    E getFirst();
    
    // 返回队尾元素，如果队列为空则抛出异常，不返回null
    E getLast();

    // 和getFirst方法一样，不过该方法在队列为空的时候返回null，不抛出异常
    E peekFirst();

    // 和getLast方法一样，不过该方法在队列为空的时候返回null，不抛出异常
    E peekLast();

    // 移除在队列中首次出现的特定元素（从队头到队尾），如果元素不存在，则返回false
    boolean removeFirstOccurrence(Object o);

    // 移除在队列中最后出现的特定元素（从队头到队尾），如果元素不存在，则返回false
    boolean removeLastOccurrence(Object o);

    // *** Queue methods ***

    // 添加元素到队列尾部，如果队列容量不足，则抛出异常，不返回false
    boolean add(E e);

    // 和add方法一样，不过该方法在队列容量不足的时候返回false，不抛出异常
    boolean offer(E e);
    
    // 移除队头元素，这些方法和Queue里面的含义是一样的
    E remove();

    E poll();

    E element();

    E peek();

    // *** Stack methods ***
    // 双向队列可以当作一个栈来使用

    // 把一个元素入栈，实际上就是添加到双向队列的首部
    // 这个方法等同于addFirst
    void push(E e);

    // 弹出栈顶元素，实际上就是双向队列中的队尾元素
    // 该方法等同于removeFirst
    E pop();

    // 这是Collection里面的remove方法，不过在这里该方法有不同的含义
    // 这个方法将移除双向队列中首次出现的元素（从队首到队尾）
    // 等同于removeFirstOccurrence
    boolean remove(Object o);
}

public interface Map<K,V> {
    // Query Operations

    // Map中的键值对数量
    int size();

    // Map是否为空，即没有键值对
    boolean isEmpty();

    // Map中是否包含特定的键
    boolean containsKey(Object key);

    // Map中是否包含特定的值
    boolean containsValue(Object value);

    // 根据key获取对应的value，如果key不存在则返回null
    V get(Object key);

    // Modification Operations

    // 向Map中放入一个键值对，返回键值对的值
    // 如果键在Map中已存在，则使用给定的值来更新原来的键值对的值，返回原来的旧值
    V put(K key, V value);

    // 根据key移除键值对，如果key在Map中不存在，则返回null，否则返回key对应的value
    V remove(Object key);

    // Bulk Operations

    // 把另一个Map的键值对放入该Map，向当于将另一个Map的键值对调用put方法放到该Map中
    void putAll(Map<? extends K, ? extends V> m);

    // 移除Map中所有的键值对
    void clear();

    // Views

    // 返回该Map中所有键的集合，返回类型为Set，因为键都是不相同的
    Set<K> keySet();

    // 返回该Map中的所有值的集合，返回类型为Colleectino
    Collection<V> values();

    // 返回该Map中所有键值对的集合，返回类型为Set<Map.Entry<K, V>>
    // Map.Entry表示一个键值对
    Set<Map.Entry<K, V>> entrySet();

    // 表示一个键值对
    interface Entry<K,V> {
        // 返回该键值对的key
        K getKey();

        // 返回该键值对的value
        V getValue();

        // 修改该键值对的value
        V setValue(V value);

        // 判断该键值对与指定的键值对是否相等
        boolean equals(Object o);

        int hashCode();

        // 省略了部分方法
    }

    // Comparison and hashing

    boolean equals(Object o);

    int hashCode();
}

public class Sort {
    public static void main(String[] args) {
        List<String> list = Arrays.asList(args);
        Collections.sort(list);
        System.out.println(list);
    }
}

// Make a List of all anagram groups above size threshold.
List<List<String>> winners = new ArrayList<List<String>>();
for (List<String> l : m.values())
    if (l.size() >= minGroupSize)
        winners.add(l);

// Sort anagram groups according to size
Collections.sort(winners, new Comparator<List<String>>() {
    public int compare(List<String> o1, List<String> o2) {
        return o2.size() - o1.size();
    }});

// Print anagram groups.
for (List<String> l : winners)
    System.out.println(l.size() + ": " + l);

public class Shuffle {
    public static void main(String[] args) {
        List<String> list = Arrays.asList(args);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

public class Shuffle {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (String a : args)
            list.add(a);
        Collections.shuffle(list, new Random());
        System.out.println(list);
    }
}

int pos = Collections.binarySearch(list, key);

int pos = Collections.binarySearch(list, key, new Comparator(){...});

// Returns the number of elements in the specified collection equal to the specified object.
static int	frequency(Collection<?> c, Object o)

// Returns true if the two specified collections have no elements in common.
static boolean	disjoint(Collection<?> c1, Collection<?> c2)

// Returns the maximum element of the given collection, 
// according to the natural ordering of its elements
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

// Returns the maximum element of the given collection, 
// according to the order induced by the specified comparator
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

// Returns the minimum element of the given collection, 
// according to the natural ordering of its elements
static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

// Returns the minimum element of the given collection, 
// according to the order induced by the specified comparator
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)