java的Map集合

Map集合

java.util.Map<k,v>集合
特点：
1.Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）
2.Map集合找那个的元素，key和value可以相同也可以不同
3.Map集合中的元素，key是不允许重复的，value是可以重复的
4.Map集合中的元素，key和value是一一对应的

Map集合常用子类

HashMap集合

特点：
1.HashMap集合底层是哈希表：查询的速度特别的块
JDK1.8之前：数组+单向链表
JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）：提高查询的速度

2.HashMap集合是一个无序的集合，存储的元素和取出的元素的顺序有可能不一致

LinkedHashMap集合

java.util.LinkedHashMap<k,v>集合 继承了HashMap<k,v>集合

特点：
1.LinkedHashMap集合底层是哈希表+链表
2.LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序一致的。

Map接口中常用的方法

1.public V put(K key, V volue):把指定的键与制定的值添加到Map集合中。
返回值：V
存储键值对的时候，key不重复，返回值v是null
存储键值对的时候，key重复，则会使用新的value替代map中重复的volue，返回被替代的value值

private static void show01(){
        //创建Map集合对象，多态
        Map<String,String> map = new HashMap<>();

        map.put("水果","甜的");
        map.put("苹果","香的");
        System.out.println(map.put("香蕉","软的")); 
        System.out.println(map.put("香蕉","喝的"));

        System.out.println(map);
    }

null
软的
{苹果=香的, 香蕉=喝的, 水果=甜的}

2.public V remove(Oblect key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
返回值:v
key存在，v返回被删除的值；
key不存在，v返回null。

private static void show01(){
        //创建Map集合对象，多态
        Map<String,String> map = new HashMap<>();

        map.put("水果","甜的");
        map.put("苹果","香的");
        map.put("香蕉","软的");
        map.put("香蕉","喝的");
        System.out.println(map);
        System.out.println(map.remove("苹果"));
        System.out.println(map.remove("白菜"));
        System.out.println(map);
    }

{苹果=香的, 香蕉=喝的, 水果=甜的}
香的
null
{香蕉=喝的, 水果=甜的}

3.public V get(Oblect key):根据指定的键，在Map集合中获取对应的值。
返回值:v
key存在，v返回对应的值；
key不存在，v返回null。

 private static void show01(){
        //创建Map集合对象，多态
        Map<String,String> map = new HashMap<>();

        map.put("水果","甜的");
        map.put("苹果","香的");
        map.put("香蕉","软的");
        map.put("香蕉","喝的");
        System.out.println(map);
        System.out.println(map.get("苹果"));
        System.out.println(map.get("白菜"));
        
    }

{苹果=香的, 香蕉=喝的, 水果=甜的}
香的
null

遍历Map集合

1.使用keySet（）方法：吧Map集合中所有的key取出来后存储到Set集合中。然后通过迭代器、增强for循环的方式遍历。

使用步骤：
（1）使用Map集合中的方法keySet()，把Map集合中所有的key取出来，存储到一个set集合当中
（2）遍历set集合，获取Map集合中的每一个key。
（3）通过Map集合中的方法get（key），通过key找到value。

  private static void show01(){
        //创建Map集合对象，多态
        Map<String,String> map = new HashMap<>();

        map.put("水果","甜的");
        map.put("苹果","香的");
        map.put("香蕉","软的");
        map.put("香蕉","喝的");
        System.out.println(map);
        Set<String> set = map.keySet();
        for(String m:set){
            String n = map.get(m);
            System.out.println(m+"="+n);
        }

    }

{苹果=香的, 香蕉=喝的, 水果=甜的}
苹果=香的
香蕉=喝的
水果=甜的

1.使用Entry对象遍历
实现步骤“
（1）使用Map中的entySet（）方法把集合内部的多个Entry对象取出来存储到一个set集合当中
（2）遍历Set集合，获取set集合中的每一个Entry对象
（3）使用Entry中的方法：getKey（）获取key值，getValue（）获取value值

private static void show01(){
    //创建Map集合对象，多态
    Map<String,String> map = new HashMap<>();

    map.put("水果","甜的");
    map.put("苹果","香的");
    map.put("香蕉","软的");
    map.put("香蕉","喝的");
    System.out.println(map);
     Set<Map.Entry<String, String>> set = map.entrySet();
    Iterator<Map.Entry<String, String>> it = set.iterator();
    while (it.hasNext()){
        Map.Entry<String, String> en =  it.next();
        String n = en.getKey();
        String m =en.getValue();
        System.out.println(n+"="+m);
    }
    for(Map.Entry<String, String> e: set){
        System.out.println(e.getKey()+"="+e.getValue());
    }
}

Entry键值对对象

Map.Entry<K,V>：在Map接口中有一个内部接口Entry
作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象，键与值的映射关系）

步骤：
1.Set<Map.Entry<K,v>>entySet()：把集合内部的多个Entry对象取出来存储到一个set集合当中
2.遍历Set集合，获取set集合中的每一个Entry对象
3.Entry中的方法：
getKey（）获取key值
getValue（）获取value值

Hash Map存储自定义类型键值

1.key为String类型：value为stu（学生类，包括姓名和年龄）类型
String 必须重写hashCode方法和equals方法，可以保证key唯一
value可以重复（同年龄同名称视为同一个人）

private static void show02(){
        //创建Map集合

        Map<String,stu> map = new HashMap<>();
        //往集合中添加值
        map.put("水果",new stu("张三",18));
        map.put("苹果",new stu("李四",19));
        map.put("香蕉",new stu("张飞",24));
        map.put("香蕉",new stu("赵云",32));
        System.out.println(map);
        //通过keySet增强for循环遍历
        Set<String> set = map.keySet();
        for(String n: set){
            stu m = map.get(n);
            System.out.println(n+"="+m);
        }
    }

{苹果=stu{name='李四', age=19}, 香蕉=stu{name='赵云', age=32}, 水果=stu{name='张三', age=18}}
苹果=stu{name='李四', age=19}
香蕉=stu{name='赵云', age=32}
水果=stu{name='张三', age=18}

1.key为stu（学生类，包括姓名和年龄）类型，value为String类型
Map集合必须保证key唯一，因此stu类必须重写hashCode方法和equals方法

private static void show03(){
        //创建Map集合

        Map<stu,String> map = new HashMap<>();
        //往集合中添加值
        map.put(new stu("张飞",24),"水果");
        map.put(new stu("李四",19),"苹果");
        map.put(new stu("张飞",24),"香蕉");
        map.put(new stu("赵云",32),"香蕉");
        System.out.println(map);
        //通过keySet增强for循环遍历
        Set<Map.Entry<stu, String>> entries = map.entrySet();
        for(Map.Entry<stu, String>  key: entries){
            stu k = key.getKey();
            String v = key.getValue();
            System.out.println(k+"="+v);
        }
    }

{stu{name='李四', age=19}=苹果, stu{name='赵云', age=32}=香蕉, stu{name='张飞', age=24}=香蕉}
stu{name='李四', age=19}=苹果
stu{name='赵云', age=32}=香蕉
stu{name='张飞', age=24}=香蕉

LinkHashMap

继承了HashMap，有序的集合，底层原理哈希表+链表

 private static void show04(){
        //创建Map集合

        Map<stu,String> map = new LinkedHashMap<>();
        //往集合中添加值
        map.put(new stu("张飞",24),"水果");
        map.put(new stu("李四",19),"苹果");
        map.put(new stu("张飞",24),"香蕉");
        map.put(new stu("赵云",32),"香蕉");
        System.out.println(map);
        //通过keySet增强for循环遍历
        Set<Map.Entry<stu, String>> entries = map.entrySet();
        for(Map.Entry<stu, String>  key: entries){
            stu k = key.getKey();
            String v = key.getValue();
            System.out.println(k+"="+v);
        }
    }

{stu{name='张飞', age=24}=香蕉, stu{name='李四', age=19}=苹果, stu{name='赵云', age=32}=香蕉}
stu{name='张飞', age=24}=香蕉
stu{name='李四', age=19}=苹果
stu{name='赵云', age=32}=香蕉

与上面的结果对比有序。

Hashtable 集合

Hashtable ：implement Map<k,v>接口
底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢。不能存储null，

HashMap：底层也是哈希表，是一个线程不安全的集合，是多线程集合，速度快，可以存储null

Hashtable 和Vector集合都被更先进的集合取代了
但Hashtable 的子类Properties一人活跃在舞台
Properties集合是一个唯一和IO流相结合的集合