集合框架：和集合、数组、映射相关的接口和类都是集合框架的成员 --- Map/Collection/Collections/Iterator/Comparator/Comparable/Arrays

问:Collection和Collections的区别?
答:Collection是java.util下的接口,它是各种集合的父接口,继承于它的接口主要有Set和List;
Collections是java.util下的类,是针对集合的帮助类,提供一系列静态方法实现对各种集合的搜索,排序(Collections.sort(list)),线程安全化等操作.

集合

存储多个数据的容器---大小不固定

Collection<E>

Java中集合的顶级接口。<E>---泛型---用于定义存储的元素类型。---由于泛型的限制，要求集合中只能存储引用类型的数据。---Collection<Integer>

Collection
|--List
|...|--LinkedList
|...|--ArrayList
|...|--Vector
|.......|--Stack
|
|--Set
|...|--HashSet：默认容量是16，默认加载因子是0.75f，每次默认增加一倍。线程不安全---扩容机制要求掌握

• List---列表
  保证元素的存储顺序---有序；有下标--存储重复的元素---List是有序可重复的集合

• LinkedList
  底层是基于链表（节点---Node）来实现的。内存是不连续的。没有初始容量，不需要考虑扩容问题。是一个线程不安全的集合。便于增删元素，不便于查询元素

• ArrayList
  底层用数组存储数据。内存连续的。默认初始容量为10，每次默认在上一次的长度的基础上增加一半，底层是基于了右移运算来实现的。 10 -> 15 -> 22。是一个线程不安全的集合。便于查询，不便于增删

• Vector
  向量---基于数组来实现的。内存空间连续的。默认初始容量是10，默认每次容量翻倍。基于三元运算来实现。是一个线程安全的集合。

• Stack
  栈。是Vector的子类。遵循先进后出的原则。向栈中放入元素---入栈/压栈，从栈中取出元素---出栈/弹栈。最先放入栈中的元素---栈底元素，最后放入栈中的元素---栈顶元素

• Set---散列集合,元素不重复。
  HashSet---线程不安全
  存储机制：底层是用的一个数组来存储的数据，这个数组的默认大小是16。数组的每一个位置称为一个桶(bucket)，每一个桶中维系了一个链式栈结构。存放元素的时候会先计算元素的哈希码，然后将哈希码进行二次运算，根据运算的结果放入对应的桶中。如果某个元素要存放的桶中已经有了元素，会先拿这个元素和桶中的元素依次比较，如果每一个比较都不相等，则会插到这个链表的首位。根据加载因子的值确定桶的使用数量，加载因子的默认值是0.75f，当使用的桶的数量超过了（总数量*加载因子)的值的时候，则会发生扩容操作，每次默认增加一倍。扩容之后，原来的所有的元素都要进行重新分布的操作（rehash）。
  如果初始容量比较小，则在初期会频繁发生扩容和rehash操作；如果初始容量过大会导致内存的浪费。
  如果加载因子较小，会导致扩容和rehash操作频繁发生，同时也会导致内存的大量的浪费。如果加载因子过大，会导致每个桶中的链表的长度过长，而链表长度过长会导致查询以及增删操作的效率都会降低。如果加载因子为1，则意味着不会扩容。

• Queue---队列
  先进先出(FIFO)。

• Iterator
  迭代器---本质上是通过指针的挪动来获取每一个元素。在遍历的时候，会先复制原集合，然后一次给每一个元素一个标记，如果这个元素被移除，则标记为false，反之标记为true，在遍历完成之后，会去比对原集合，如果标记为false，则将该元素从原集合中移除---在迭代过程中，不允许直接增删原集合中的元素
  Iterable---允许实现这个接口的类的对象能够被增强for循环进行遍历。---增强for循环的遍历过程实际上是迭代遍历的过程。---增强for循环是JDK1.5的特性之一

• 比较器
  A. Comparator：重写compare方法，指定比较规则。如果返回正数，表示第一个参数比较大，排序的时候会自动的排到后边；如果返回负数，表示第一个参数比较小，排序的时候会自动的排在前边
  B. Comparable：如果在排序的时候没有指定比较规则，则要求要排序的元素的对应的类身上必须实现Comparable接口，利用其中的compareTo方法进行自然排序

Map<K,V>---映射
两组变量---键，值。每一个键必然对应一个值，键不可重复---一个映射实际上是由多个键值对组成的。
键值对所对应的接口---Entry，它是Map中的内部接口---每一个键值对都是一个Entry对象，那么实际上Map是由多个Entry对象来组成的
Map是集合吗？---不是，是集合框架的一员。

• HashMap:允许键或者值为null。默认初始容量是16，加载因子是0.75f，默认增加一倍。是一个异步式线程不安全的映射
• Hashtable:不允许键或者值为null。默认初始容量是11，加载因子是0.75f。是一个同步式线程安全的映射---仅仅在笔试中出现
• ConcurrentHashMap---异步式线程安全的映射

附:迭代器的用法

package com.xzb;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class IteratorList {
    
    public static void main(String[] args) {
        testMap();
        testSet();
        testList();
    }
    
    /**
     * 迭代遍历Map
     */
    public static void testMap() {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        
        Set<Integer> set = map.keySet();
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
        Collection<String> collection = map.values();
        System.out.println(collection);
        
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator2 = entrySet.iterator();
        while (iterator2.hasNext()) {
            Map.Entry<Integer,String> entry = (Map.Entry<Integer,String>) iterator2.next();
            System.out.println("Key:" + entry.getKey());
            System.out.println("Value:" + entry.getValue());
        }
    }
    
    /**
     * 迭代遍历Set
     */
    public static void testSet() {
        Set<String> set = new HashSet<>();
        set.add("111");
        set.add("222");
        set.add("333");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String string = (String) iterator.next();
            System.out.println(string);
        }
    }
    
    /**
     * 迭代遍历List
     */
    public static void testList() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer j = (Integer) iterator.next();
            System.out.println(j);
        }
    }
    
}