Java集合之List，Set，Map

List：有序，可重复
一，List接口的三个典例实现：
    List list1 = new ArrayList();
    底层数据结构是数组，查询快，增删慢;线程不安全，效率高
    
    List list2 = new Vector();
    底层数据结构是数组，查询快，增删慢;线程安全，效率低,几乎已经淘汰了这个集合
    
    List list3 = new LinkedList();
    底层数据结构是链表，查询慢，增删快;线程不安全，效率高
    
二，List的遍历：(以遍历 ArrayList为例)

    List<String> list=new ArrayList<String>();
     list.add("123");
     list.add("456");
     list.add("000");
     //第一种遍历方法使用foreach遍历List
     for (String str : list) {            //也可以改写for(int i=0;i<list.size();i++)这种形式
        System.out.println(str);
     }
 
     //第二种遍历，把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  foreach(String str:strArray)这种形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三种遍历 使用迭代器进行相关遍历
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }

     
Set：无序，不可重复
一，典型实现
    Set hashSet = new HashSet();
    1，不能保证元素的顺序；不可重复；不是线程安全的；集合元素可以为 NULL;
    2，底层为数组，查询速度快，HashSet 集合底层数组的索引和值有一个确定的关系：index=hash(value),那么只需要调用这个公式，就能快速的找到元素或者索引。
    3，如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同：
        <1>，当向HashSet集合中存入一个元素时，HashSet会先调用该对象的hashCode（）方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置
        <2>，如果 hashCode 值不同，直接把该元素存储到 hashCode() 指定的位置
        <3>，如果 hashCode 值相同，那么会继续判断该元素和集合对象的 equals() 作比较
        <4>，hashCode 相同，equals 为 true，则视为同一个对象，不保存在 hashSet（）中
        <5>，hashCode 相同，equals 为 false，则存储在之前对象同槽位的链表上，这非常麻烦，我们应该约束这种情况，即保证：如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。
        
    注意：每一个存储到 哈希 表中的对象，都得提供 hashCode() 和 equals() 方法的实现，用来判断是否是同一个对象，对于 HashSet 集合，我们要保证如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。
        
    Set linkedHashSet = new LinkedHashSet();
    不可以重复，有序，因为底层采用 链表 和 哈希表的算法。链表保证元素的添加顺序，哈希表保证元素的唯一性
    
    Set treeSet = new TreeSet();
    有序；不可重复，底层使用 红黑树算法，擅长于范围查询。
        
二，遍历方式与List类似

Map：key-value 的键值对，key 不允许重复，value 可以
    严格来说 Map 并不是一个集合，而是两个集合之间 的映射关系。
    这两个集合没每一条数据通过映射关系，我们可以看成是一条数据。即 Entry(key,value）。Map 可以看成是由多个 Entry 组成。
    因为 Map 集合即没有实现于 Collection 接口，也没有实现 Iterable 接口，所以不能对 Map 集合进行 for-each 遍历。

一，主要实现类
    HashMap：访问速度快，最多只允许一条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。非同步的。
    
    TreeMap：能够把它保存的记录根据key排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
    
    Hashtable：key和value的值均不允许为null;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。
    
    LinkedHashMap：保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。

二，Map遍历（以HashMap为例）：    

      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      //第一种：普遍使用，二次取值
      System.out.println("通过Map.keySet遍历key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三种：推荐，尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      //第四种
      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);