用来表示和操作集合的统一架构
包含三个方面：
1、接口：定义了集合操作的规范
2、实现类：集合接口的具体实现，本质上，是可重复使用的数据结构
3、算法： 实现集合操作的常用算法

[四个接口区别]
1、collection： 存储不唯一、无序的数据 
2、list： 存储不唯一、有序的数据
3、set： 存储唯一、无序的数据
4、Map： 以键值的形式存储数据，以键取值，键不能重复，值可以重复 

1、常用方法：
  ① add();在列表最后添加元素
  ② add(index,obj);在列表指定位置添加元素
  ③ size();返回列表元素个数
  ④ get(int index);返回下标为index的元素。
                   如果没有泛型约束，返回object类型，需要强转；
                   如果有泛型约束，直接返回返回类型，无需强转。
  ⑤ clear();清除列表中所有数据
     isEmpty();检测列表是否为空
  ⑥ contains();传入一个对象，检测列表中是否包含该对象
               如果传入的是String 和基本数据类型，可以直接比对
               如果传入的是实体对象，则默认值比对两个对象的地址，因此需要在实体类中重写equals()方法
  ⑦ indexOf()传入一个对象，返回该对象在列表中是第一次出现的位置,如果没有则返回-1
     lastIndexOf();返回最后一次出现的位置
  ⑧ remove();传入一个下标，或者一个对象，删除指定元素；
              如果传入下标，返回被删除的元素对象，如果下标大于size(),会报下标越界
              如果传入对象，则要求重写equals()方法，返回true或false表示是否删除成功
  ⑨ set(index,obj):用新传入的对象，将指定位置的元素替换掉，返回被替换的元素
  ⑩ list.subList(1,3);截取一个子列表，返回List类型
     toArray();将列表转为数组，返回一个Object[]类型的数组

2、常用实现类
  ① ArrayList
      实现了一个长度可变的数组，在内存空间中开辟一串连续的空间。
      这种存储结构，在循环遍历和随机访问元素的速度比较快
  ② LinkedList
      使用链表结构存储数据，在(中间)插入和删除元素时比较快
  LinkedList特有的方法：
   ① addFirst():在该列表开头插入指定的元素。
       addLast():在该列表最后插入指定的元素。
   ② removeFirst();从此列表中删除并返回第一个元素。
       removeLast();从此列表中删除并返回最后一个元素。
   ③ getFirst();返回第一个元素。
       getLast();返回最后一个元素。

1、常用方法：与List接口基本相同 但是，由于Set接口中的元素是无序的，因此没有与下标相关的方法
   例如：get(index) remove(index) add(index,obj)
2、Set接口特点：无序、唯一
3、HashSet 底层是调用HashMap的相关方法，传入数据后，根据数据的hashcode进行散列运算，得到一个散列值后再进行运算，确定元素在序列中存储的位置
  HashSet如何确定两个对象是否相等
  ① 先判断对象的HashCode(),如果hashcode不同，那肯定不相同
    如果hashcode相等，那继续判断equals()方法
  ②重写equals()方法
  >>>所以，使用HashSet存储实体对象时，必须重写HashCode()和equals()两个方法
4、LinkHashSet：在HashSet的基础上，新增了一个链表。
   用链表来记录HashSet存放的元素顺序，因此使用迭代器遍历时，可以按照放入的顺序依次读取元素
5、TreeSet：将存入的元素，进行排序，然后再输出
   如果存入的是实体对象，那么实体类必须实现Comparable接口，重写CompareTo()方法
   或者，也可以在实例化TreeSet的同时，通过构造函数传入一个比较器
   比较器：一个实现了Comparator接口，并重写了compare()方法的实现类的对象。

//使用匿名内部类，拿到一个比较器对象

   Set<Person> set=new TreeSet<Person>(new Comparator(){

   public int compare(Person p1,Person p2){

        return p1.getId()-p2.getId();

          }

     }

  );

   //自定义一个比较类，实现Comparator接口 

  <Person> set=new TreeSet<Person>(new Compare());

   class Compare implements Comparator{

      // 重写compare方法。

   public int compare(Person p1,Person p2){

      return p1.getId()-p2.getId();

    }
}

[Comparable接口 和 Comparator接口的区别]

 1、Comparable由实体类实现，重写compareTo()方法；

   实体类实现Comparable接口以后，TreeSet使用空参构造即可。

 2、Comparator需要单独一个比较类进行实现，重写Compare()方法。

   实例化TreeSet的时候，需要传入这个比较类的对象。

1、特点：以键值对的形式存储数据，以键取值。 键不能重复，只可以重复
2、Map常用的方法
  ① put(key,value):向map的在最后追加一个键值对； 
  ② get(key); 通过建，取值
  ③ clear(); 清除所有键值对；
  ④ containsValue(obj);检测是否包含指定的值
     containsKey(obj);检测是否包含指定的键  
3、LinkedHashMap
   可以使用链表，记录数据放入的顺序，使让读出的数据次序与存入的次序一致，与LinkedHashSet一样
4、TreeMap
   根据键的顺序，进行排序后，输出。如果传入的是实体对象，必须重写比较函数，详见TreeSet

[HashMap与HashTable的区别]
1、HashTable是线程安全(线程同步)的，HashMap是线程不安全(线程不同步)的
2、HashTable的键不能为null,HashMap的键可以为null
3、HashMap继承了AbstractMap，HashTable继承Dictionary抽象类，两者均实现Map接口。
4、HashMap的初始容量为16，Hashtable初始容量为11，两者的填充因子默认都是0.75。
5、HashMap扩容时是当前容量翻倍即:capacity*2，Hashtable扩容时是容量翻倍+1即:capacity*2+1。
6、两者计算hash的方法不同： 
   Hashtable计算hash是直接使用key的hashcode对table数组的长度直接进行取模：
   HashMap计算hash对key的hashcode进行了二次hash，以获得更好的散列值，然后对table数组长度取摸：
7、判断是否含有某个键 
  在HashMap 中，null 可以作为键，这样的键只有一个；可以有一个或多个键所对 应的值为null。当get()方法返回null 值时，
  既可以表示HashMap 中没有该键，也可以表示该键所对应的值为null。因此，在HashMap 中不能用get()方法来判断HashMap中是否存在某个键，、
  而应该用containsKey()方法来判断。Hashtable 的键值都不能为null，所以可以用get()方法来判断是否含有某个键。

/**
         * 遍历Map方式一
         */
        Set<String> keys = map1.keySet();
        Iterator<String> iter1 = keys.iterator();
        while (iter1.hasNext()) {
            String key = iter1.next();
            System.out.println(key + "------" + map1.get(key));
        }

        /**
         * 遍历Map方式二
         */
        Collection<String> values = map1.values();
        Iterator<String> iter2 = values.iterator();
        while (iter2.hasNext()) {
            System.out.println(iter2.next());
        }

        /**
         * 遍历Map方式三
         */
        Set<Entry<String, String>> set3 = map1.entrySet();
        /*Iterator<Entry<String,String>> iter3 = set3.iterator();
        while (iter3.hasNext()) {
            Entry<String,String> entry=iter3.next();
            Entry是java给我们提供的一种特殊的数据类型，其实就是一个键值对
             * 键就是当前这条记录的键，使用getKey()取到；
             * 值就是当前这条记录的值，使用getValue()取到
            
//            System.out.println(entry);
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }*/
        for(Entry<String,String>entry:set3){
            System.out.println(entry.getKey()+"-----"+entry.getValue());
        }

Collections是Java中专门用来操作集合的工具类
Collection是一个接口

[方法]
1、addAll()方法：向集合中添加多个数据
  Collections.addAll(list, "Test1","Test2","Test3");

2、sort()方法：对集合中的数据进行排序 如果集合中的数据是实体对象那么 
  ① 实体类实现Comparable接口，重写compareTo方法
  ②在sort的第二个参数传入一个实现了Comparator接口的比较器对象，重写compare方法

    Collections.sort(list1, new Comparator<Person1>() {
     @Override
      public int compare(Person1 o1, Person1 o2) {
      return o1.getId() – o2.getId();
      }
    });

3、binarySearch()：查找元素，返回下标
  使用binarySearch()要先排序 如果集合中的数据是实体对象那么 
  ①实体类实现Comparable接口，重写compareTo方法 (推荐使用)
  ②在sort的第二个参数和binarySearch的第三个参数传入一个实现了Comparator接口的比较器对象，重写compare方法
  System.out.println(Collections.binarySearch(list, "list2"));

4、找出最大、最小元素，如果实体对象，同上需要实现比较器接口
  Collections.max(list);
  System.out.println(Collections.min(list1));

5、repalceAll(): 将列表的指定值，替换新值. 如果是对象，重写equals方法

     Collections.replaceAll(list1, new Person1(1, “张三”, 12),
     new Person1(1, “111张三”, 12));

6、翻转列表中的所有元素
  Collections.reverse(list1);

7、对集合的元素，随机排序
  Collections.shuffle(list1);
8、 将集合中的元素位置，进行交换
  Collections.swap(list1, 0, 1);

9、将集合中的所有元素替换为同一个元素
  Collections.fill(list, "姜皓真帅");