Java集合总结

1.
Collection
Set 无序，不可重复；
List 有序，重复；
Queue 队列集合；
Map
Map 映射关系；

2.Collection 接口
boolean add(Object o);
boolean addAll(Collection c);
void clear();
boolean contains(Object o);
boolean containsAll(Collection c);
boolean isEmpty();
Iterator itreraror();
boolean remove(Object o);
boolean removeAll(Collection c);
boolean retainAll(Collection c);
int size();
Object[] toArray();

removeIf(Predicate filter);       Predicate 是函数式接口，可为 Lambda 表达式；

3.集合遍历

1.forEach(Consumer action);  参数为 Lambda 表达式；
    例：collection.forEach(obj -> System.out.println(obj));

2.Iterator 接口
    boolean hasNext()       集合没有被遍历完，返回 true；
    Object next()           下一个元素；
    void remove()           删除集合里上一次 next 方法返回的元素；
    void forEachRemaining(Consumer action)  使用 Lambda 表达式来遍历集合；

    例：
        Iterator it = collection.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }

        Collection 集合里的元素不能被改变；只有通过 Iterator 的 remove()方法删除上一次 next() 方法返回的集合才可以；

    例：
        Iterator it = collection.iterator();
        it.forEachRemaining(obj -> System.out.println(obj));

3.使用 foreach 循环

    for(Object obj : collection)
    {
        System.out.println(obj);
    }

4.Stream 操作集合

5.set
不允许包含相同元素

1.HashSet
    不保证元素排列顺序；
    不是同步的；
    元素值可为 null;

    元素相等判断标准：两个对象通过 equals() 方法比较相等，hashCode() 方法返回值相等；

    LinkedHashSet 类  按元素的添加顺序来访问集合元素；

2.TreeSet
    元素集合处于排序状态；
    Comparator comparator();    重写 compare()方法  定制排序；
    Object first();
    Object last();
    Object lower(Object e);
    Object higher(Object e);
    SortedSet subSet(Object fromElement, Object toElement);
    SortedSet headSet(Object toElement);
    SortedSet tailSet(Object fromElement);


    TreeSet 最好只添加一种类型对象；

    Comparable 接口：
        BigDecimal,BigInteger,Character,Boolean,String,Date,Time;
        自然排序：升序；
        定制排序：
            Comparator 对象 或 Lambda 表达式；

3.EnumSet
    为枚举设计的集合类，创建完对象，不可变；

    EnumSet allOf(Class elementType);           包含指定枚举类里所有枚举值的 EnumSet 集合；
    EnumSet complementOf(EnumSet s);            原集合不包含的，剩余的枚举值；
    EnumSet copyOf(Collection c);               使用普通集合创建 EnumSet 集合；
    EnumSet copyOf(EnumSet s);                  创建相同元素类型，相同集合元素的 EnumSet 集合；
    EnumSet noneOf(Class elementType);          空 EnumSet 集合；
    EnumSet of(E first, E...rest);              一个或多个枚举值的 EnumSet 集合；
    EnumSet range(E from, E to);                从 from 枚举值到 to 枚举值范围的所有枚举值；

6.List 集合

1.方法

    void add(int index, Object element);            
    boolean addAll(int index, Collection c);
    Object get(int index);
    int indexOf(Object o);                          返回对象 o 在 List 集合中第一次出现位置的索引；
    int lastIndexOf(Object o);                      返回对象 o 在 List 集合中最后一次出现位置的索引；
    Object remove(int index);                       删除并返回 index 索引处的元素；
    Object set(int index, Object element);          将 index 索引处的元素替换成 element 对象，返回被替换的旧元素；
    List subList(int fromIndex, int toIndex);       返回从 fromIndex 到 toIndex 所有集合元素的子集和；
    void replaceAll(UnaryOperator operator);        根据 operator 指定的计算规则重新设置 List 集合的所有元素；
    void sort(Comparator c);                        

2.ListIterator 接口新加方法

    boolean hasPrevious();
    boolean previous();
    void add(Object o);

3.ArrayList 和 Vector 

    重新分配 Object[] 数组；

        void ensureCapacity(int minCapacity);       将 Object[] 数组长度增加大于或等于 minCapacity;
        void trimToSize();                          调整 Object[] 数组长度为当前元素个数；

    少用 Vector 实现类，线程安全，性能低；

    Stack 子类： -> ArrayDeque
        Object peek();
        Object pop();
        void push(Object item);

7.Queue 集合

1.Queue 接口方法 
    void add(Object e);             将元素加入队尾；
    Object element();               返回队头元素；
    boolean offer(Object e);        将元素加入队尾；(有容量限制好)
    Object peek();                  返回队头元素；(空 null)
    Object poll();                  返回队头元素，并删除该元素；(空 null)
    Object remove();                返回队头元素，并删除该元素；

2.Queue 接口实现类 PriorityQueue
    大小排序顺序；
    不允许插入 null 元素； 
    自然排序，定制排序；

 3.Deque 接口实现类 ArrayDeque LinkedList

    void addFirst(Object e);                    插入双端队列开头；
    void addLast(Object e);                     插入双端队列末尾；
    Iterator descendingIterator();              返回双端队列对应的迭代器，逆向顺序；
    Object getFirst();                          返回双端队列第一个元素；
    Object getLast();                           返回双端队列最后一个元素；
    boolean offerFirst(Object e);               将元素插入双端队列开头；
    boolean offerLast(Object e);                将元素插入双端队列末尾；
    Object peekFirst();                         返回双端队列第一个元素；(空 null)
    Object peekLast();                          返回双端队列最后一个元素；(空 null)
    Object pollFirst();                         返回并删除双端队列第一个元素；(空 null)
    Object pollLast();                          返回并删除双端队列最后一个元素；(空 null)
    Object pop();(栈方法)                      pop 出该双端队列栈顶元素；
    void push(Object e);(栈方法)               将一个元素 push 进双端队列栈顶；
    Object removeFirst();                       返回并删除双端队列第一个元素；
    Object removeFirstOccurrence(Object o);     删除双端队列第一次出现的元素 o;
    Object removeLast();                        返回并删除双端队列最后一个元素；
    Object removeLastOccurrence(Object o);      删除双端队列最后一次出现的元素 o;


    LinkedList 是 List 接口，Dequqe 接口实现类       (链表实现)
        可以当成双端队列，栈，队列使用；

8.Map 集合

1.Map 接口方法

    void clear();                           删除所有 key-value 对；
    boolean containsKey(Object key);        查询是否包含指定 key ;
    boolean containsValue(Object value);    查询是否包含一个或多个 value ;
    Set entrySet();                         返回 key-value 对所组成的 Set 集合，每个集合元素都是 Map.Entry 对象；
    Object get(Object key);                 返回指定 key 所对应的 value;
    boolean isEmpty();                      查询 Map 是否为空；
    Set keySet();                           返回所有 key 组成的集合；
    Object put(Object key, Object value);   添加一个 key-value 对，会覆盖；
    void putAll(Map m);                     将指定 Map 中的 key-value 对复制到本 Map 中；
    Object remove(Object key);              删除指定 key 对应的 key-value 对，并返回删除的 value；
    boolean remove(Object key, Object value);删除指定 key-value 对；
    int size();                             返回 key-value 对个数；
    Collection values();                    返回所有 value 组成的 Collection；

    Map 接口内部类 Entry
        Object getKey();                    返回 Entry 里包含的 key 值；
        Object getValue();                  返回 Entry 里包含的 value 值；
        Object setValue(V value);           设置 Entry 里包含的 value 值，并返回新值；


2.HashMap 和 Hashtable 

    Hashtable 线程安全，不允许使用 null 作为 key 和 value ;
    HashMap 借助工具类 Collection 变成线性安全；可以使用 null 作为 key 或 value, 性能略高；

    HashMap 的子类 LinkedHashSet (双向链表，迭代顺序与插入顺序一致)
        遍历：forEach((key, value) -> System.out.printn(key + "-->" + value));

    Properties 类是 Hashtable 类的子类 (读写属性文件)
        String getProperty(String key);
        String getProperty(String key, String defaultValue);
        Object setProperty(String key, String value);

        void load(InputStream inStream);
        void store(OutputStream out, String comments);

3.TreeMap 实现类(SortedMap 接口)

    Map.Entry firstEntry();
    Map.Entry lastEntry();
    Object firstKey();
    Object lastKey();

4.WeakHashMap 实现类
    弱引用，如果 WeakHashMap 对象的 key 所引用的对象没有被其他强引用变量所引用，则 key 所引用的对象
    可能被垃圾回收，WeakHashMap 会自动删除这些 key-value 对；
  IdentityHashMap 实现类
    两个 key 严格相等才认为相等；

5.EnumMap 实现类

9.Collections 工具类

1.排序操作
    void reverse(List list);
    void shuffle(List list);                随机排序；
    void sort(List list);
    void sort(List list, Comparator c);
    void swap(List list, int i, int j);
    void rotate(List list, int distance);   distance 为正数，集合后 distance 个元素移到前面；负数，前 distance 个元素移到后面；

2.查找，替换操作

    int binarySearch(List list, Object key);
    Object max(Collection coll);
    Object min(Collection coll);
    Object max(Collection coll, Comparator comp);
    Object min(Collection coll, Comparator comp);
    void fill(List list, Object obj);
    int frequency(Collection c, Object o);
    int indexOfSubList(List source, List target);
    int lastIndexOfSubList(List source, List target);
    boolean replaceAll(List list, Object oldVal, Object newVal);

3.同步控制

    synchronizedXxx()方法
    HashSet,TreeSet,ArrayList,ArrayDeque,LinkedList,HashMap,TreeMap 线程不安全；

    例：Set s = Collections.synchronizedSet(new HashSet);