先简单说一下梗概，比较多：

1.List：

可以允许重复的对象。
可以插入多个null元素。
是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。
常用的实现类有 ArrayList、LinkedList 和 Vector。
ArrayList 最为流行，
它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适

2.Set：

不允许重复对象
无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序。
只允许一个 null 元素
Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。
最流行的是基于 HashMap 实现的 HashSet；
TreeSet 还实现了 SortedSet 接口，
因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。而且可以重复

3.Map

Map不是collection的子接口或者实现类。Map是一个接口。
Map 的每个 Entry 都持有两个对象，也就是一个键一个值，
Map 可能会持有相同的值对象但键对象必须是唯一的。
TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序。
Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）

以下是详解List、Set、Map集合：

一、List集合

java.util.List接口

上层接口implements Collection接口
下层实现类 ArrayList 、Vector 、LinkedList
总结：有顺序的Collection

1.List接口特点

有序的集合，存储和取出元素的顺序是一致的
有索引，包含一了些带索引的方法
允许重复的元素（Set不包含重复元素）

2.常用方法（List特有）

带索引的方法（List特有）  
1.void      add(int index ,E element) 将指定的元素添加到指定位置上（不写索引默认添加到最后）

2.E        get(int index)  返回指定索引的元素

3.E        remove(int index)  删除指定索引的元素，返回删除的元素

4.E         set(int index ,E emement)
            用元素替换集合中指定位置的元素，返回更新前的元素 
（注意索引越界异常）

3.遍历方式（同Collection，三种）

同上层的Collection，for循环，foreach循环，Iterator遍历

4.List下层：ArrayList、Vector

ArrayList java.util.ArrayList 最常用的集合
Vectorjava.util.Vector
共同点：
- 上层接口都是List接口
- 存储的结构是数组结构。
- 特点：元素增删慢，查询快
不同点：
- Vector 线程安全/线程同步，比较慢，已经被淘汰
- ArrayList 线程不安全/线程不同步

4.List下层：LinkedList

java.util.LinkedList

上层接口： List接口
储存结构是双向链表结构
特点
- 底层是一个链表结构：元素查询慢，增删快
- 双向链表结构，包含了大量操作首尾的方法
常用方法：

双向链表结构，包含了大量操作首尾的方法 
这是LinkedList特有的方法，使用这些方法不能使用多态
1. void      addFirst(E e)  将指定元素插入列表的开头 
   void      addLast(E e) 将指定元素插入列表的结尾

2. void      push(E e)将元素推入此列表表示的堆栈

3. E         getFirst() 返回此列表的第一个元素。
   E         getLast()  返回此列表的最后一个元素。

4. E        removeFirst() 移除并返回此列表的第一个元素。
   E        removeLast()  移除并返回此列表的最后一个元素。
   E        pop()        从此列表所表示的堆栈处弹出一个元素。

5. boolean    isEmpty()   判断是否为空

二、Set集合

java.util.Set接口

上层接口implements Collection接口
下层实现类 HashSet 、LinkedHashSet 、TreeList、EnumSet(专门用于枚举类型的Set)
总结：去重复的Collection

1.Set接口特点

不允许存储重复元素的
(底层是Map接口的K,此时V默认为Object类型对象)
没有索引，
所以不带索引方法，也不能使用普通的for循环遍历
只能用增强的for循环和迭代器遍历

2.遍历（比List少一种，两种）

同上层的Collection，foreach循环，Iterator遍历。但是不能用普通的for循环遍历

3.Set下层：HashSet

java.util.HashSet

上层接口： Set接口
储存结构是双向链表结构
1.HashSet专属特点：
- 底层是一个无序的集合,存储元素和取出元素的顺序有可能不同
- 底层是一个HashMap(HashSet只取K值,，查询速度非常快)
2.HashSet存储结构：哈希表
- JDK1.8之后
  哈希表=数组+链表
  哈希表=数组+红黑树(提高查询速度)
- 哈希表特点：速度快
3.HashSet存储自定义元素:

1.Set集合报错元素唯一
 存储的元素(String ,Integer...Student,Person(自定义类型)) 
 必须重写Object类的hashCode()和equals()方法

4.哈希表（HashCode）

是一串十进制的整数，由系统随机给出（就是对象的地址值,是一个逻辑地址，模拟出来的地址，不是数据实际存储的物理地址）

1.HashCode应用

1.在Object类中有一个方法可以获取
int     hashCode() 
  源码：
  public native int hashCode();
  native:代表该方法调用的是本地操作系统的方法 
  
2.toString()源码
public String toString(){
    
    
       return getClss().getName()+"@"+Integer.toHexString(hashCode());
}

2.Set集合不允许重复元素的原理：

HashSet集合保证元素唯一性的原理
1.根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入第二步

2.当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入第三步

3.通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素

在这里插入图片描述

5.HashSet下层：LinkedHashSet

java.util.LinkedHashSet

上层接口： HashSet接口 —>Set接口
储存结构是：哈希表(数组+链表/红黑树)+链表
LinkedHashSet专属特点：
相比HashSet多了一条链表用来记录元素的存储顺序，保证元素有序

6.Set下层：TreeSet

java.util.TreeSet

上层接口： Set接口
储存结构是双向链表结构
1.TreeSet特点：(跟普通Set不同)
- 不允许存储重复元素的(底层是Map接口的K,Map底层是哈希表) (继承自Set)
- 是一个有序的集合,支持自然排序或者提供的Comparator进行排序
  自定义比较规则需要实现Comparable接口重写CompareTo()方法
- 底层是一个TreeMap(TreeSet只取K值,速度非常快)

三、Map集合

java.util.Map<K,V>

Collection是所有单列集合的超类 ,
Map是所有双列集合的超类
下层实现类： HashMap、Hashtable（同步）、TreeMap

1.Map集合的特点

Map集合是一个双列集合，一个元素包含两个值(一个key 一个value)
Map集合中的元素，Key是不允许重复的，value是可以重复
Map集合中的元素，key和value是一一对应
Map集合中的元素，key和value的数据类型可以相同也可以不同

2.遍历方式（三种）

方式一：通过键找值

        public class MapF {
    
    
             public static void main(String[] args) {
    
    
              Map<String, Integer> tempMap = new HashMap<String, Integer>();
              tempMap.put("a","12");
              tempMap.put("b","34");
              tempMap.put("c","56");
方式一：通过键找值  Set<K>  keySet()  返回映射中包含的Set视图
   步骤：  
   1.使用Map集合中的方法keySet()，把集合中所有的key取出来存储到一个Set集合中
   2.遍历Set集合，获取Map集合中的每一个key
   3.通过Map集合中的方法get(key)通过key找到value 
   Set<String> set =tempMap.keySet();
   Iterator it =set.iterator();
   while(it.hasNext()){
    
    
           String key =it.next();
           Integer value =tempMap.get(key);
           System.out.println(key+"="+value)
   }

方式一：键值对对象找值

方式二：使用键值对对象遍历Set<Map.Entry<K,V>>  entrySet() 返回映射中包含的映射关系Set视图
 Map.Entry<K,V>:在Map接口中有一个内部结构Entry
     作用:当Map集合一创建，那么就会在Map集合中创建一堆Entry对象，用来记录键与值
          (键值对对象，键、值的映射关系)
     1.使用Map集合中的方法enteySet() ,把集合中所有的Entry对象取出来存储到一个Set	 集合中
     2.遍历Set集合，获取每一个Entry对象
     3.通过Entry对象中的方法getKey() ,获取键、值
        Set<Map.Entry<String,Integer>> set =tempMap.keySet();
     Iterator it =set.iterator();
     while(it.hasNext()){
    
    
             Map.Entry<String,Integer> entry=it.next();
             String key =entey.get(key);
             Integer value =entey.get(value);
             System.out.println(key+"="+value)
     }

方式三：foreach遍历

方式三：JDK1.5开始,For-Each循环
  for (Map.Entry<String, Integer> entry : tempMap.entrySet()) {
    
    
   String key = entry.getKey().toString();
   String value = entry.getValue().toString();
   System.out.println("key=" + key + " value=" + value);
  }

3.Map常用方法

1. V        put(K key ,V value)  添加键值对的值到指定K中，返回添加

2. V        remove(Object key)   根据键删除键值对的元素

3.void      clear()             移除所有的键值对元素

4.boolean    containsKey(Object key)   判断集合是否包含指定的键

5.boolean    containsValue(Object value)  判断集合是否包含指定的值

6.boolean    isEmpty()       判断集合是否为空

7.int        size()          集合的长度，也就是集合中键值对的个数

8.V          get(Object key)    根据键获取值

9.Set<K>         keySet()        获取所有键的集合

10.Collection<V>       values()     获取所有值的集合

11.Set<Map.Entry<K,V>>   entrySet()  获取所有键值对对象的集合

4.Map下层：HashMap

java.util.HashMap<k,v>

上层接口： Map接口
下层子类：LinkedHashMap
储存结构是：HashMap集合底层是哈希表(增删查询都特别快)
- JDK1.8之前：数组+单项链表
- JDK1.8之后：数组+链表/红黑数组(链表长度超过8)：提高查询速度
1.LinkedHashSet专属特点：.
HashMap集合是一个无序的集合，存储元素和取出元素有可能不一致
HashSet的底层是Valu值默认为Object的匿名对象只保留K值的HashMap
2.遍历方式（同Map共同的三种)
foreach遍历、键值对对象找值通过键找值、通过键找值
见上方Map集合遍历
3.HashMap存储自定义类型
Map集合保证key是唯一的，value可以重复
因此作为key的元素，必须重写hashCode()和equals()方法

5.HashMap下层：LinkedHashMap

java.util.LinkedHashMap<k,v>

上层接口： HashMap—>Map接口
储存结构是：LinkedHashMap集合底层是哈希表+链表（保证迭代顺序）
LinkedHashSet的底层是Valu值默认为Object的匿名对象只保留K值的LinkedHashMap
1.LinkedHashSet专属特点：.
多了一条链表用于记录元素的存储顺序保证元素有序
2.遍历方式（同Map共同的三种)
foreach遍历、键值对对象找值通过键找值、通过键找值
见上方Map集合遍历

4.Map下层：Hashtable集合

java.util.Hashtable<k,v>

上层接口： Map接口
下层子类：Properties
1.Hashtable和Properties
Hashable（和Vector一样），在JDK1.2版本之后被更先进的HashMap（ArrayList）取代
不过Hashable的子类Properties依然活跃在历史舞台
Properties集合是一个唯一和IO流结合的集合
2.HashMap和Hashtable区别联系:
- Hashtable:底层是一个哈希表，线程安全(单线程集合，速度慢)
  HashMap:底层也是一个哈希表，线程不安全(多线程集合，速度快)
- Hashtable不能存储null值和null 键
  之前学的其他所有集合都可以
- Hashable（和Vector一样），在JDK1.2版本之后被更先进的HashMap（ArrayList）取代

4.Map下层：TreeMap集合

java.util.TreeMap<k,v>

上层接口： Map接口
储存结构是：TreeMap集合底层是红黑树
1.TreeMap的特点
TreeMap集合底层是红黑树,其键的自然顺序进行排序或者提供Comparator排序
自定义排序规则需要implements Comparable接口重写CompareTo()方法

2.遍历方式（同Map共同的三种)
foreach遍历、键值对对象找值通过键找值、通过键找值
见上方Map集合遍历

for (Object o : tempMap.keySet()) {
      
      
       System.out.println("key=" + o + " value=" + tempMap.get(o));
      }
      System.out.println("11111");

小码笔记15：List、Set、Map集合