（java总结）Map集合-蒲公英云

package Demo33;
import java.util.HashMap;
import java.util.Map;
/*
java.util.Map<K,V>集合
    Map的特点：
        1、Map集合是一个双列集合，一个元素包含俩个值()
        2、Map集合中的元素，key和value的数据类型可以相同，可以不同
        3、Map集合中的元素，key是不允许重复的，value是可以重复的
        4、Map集合中的元素，key和value是意义对应的
java.util.HashMap<K,V>集合 implements Map<K,V>接口
    HashMap集合的特点：
         1、HashMap集合底层是哈希表，查询速度特别的快
            数组+单向列表/红黑树(链表的长度超过8):提高查询速度
         2、hashMap集合是一个无需的集合，在存储元素和取出元素的顺序肯呢个不一致
java.util.LinkedHashMap<K,V>集合 extends HashMap<K,V>集合
     LinkedHashMap的特点：
         1、LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
         2、LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一样的
 */
public class CollectionMap {
    public static void main(String[] args) {
        show1();
        show2();
        show3();
    }
    private static void show3() {
        Map<String, String> map2 = new HashMap<>();
        map2.put("杨过","小龙女");
        map2.put("杨逍","纪晓芙");
        map2.put("张无忌","赵敏");
        String s3 = map2.get("杨过");
        System.out.println("s3" + s3);
    }
    /*public V put(K key, V value):把指定的键与值添加到Map集合中
            返回值：V
                存储键值对的时候，key不重复，返回的v是null
                存储键值对的时候，key不重复，会使用新的value替换map中重复的value，返回被替换的value
     */
    private static void show1() {
        //创建Map集合的对象
        Map<String, String> map = new HashMap<>();
        //集合中没有和沉香一样的，就返回空
        String v1 = map.put("沉香", "小玉1");//null
        System.out.println(v1);
        System.out.println(map);
        System.out.println("=================");
        String v2 = map.put("沉香", "小玉2");
        //会使用新的value替换map中重复的value，返回被替换的value
        System.out.println(v2);//小玉1
        System.out.println(map);
        System.out.println("===================");
    }
        private static void show2() {
            Map<String, String> map1 = new HashMap<>();
            map1.put("杨过","小龙女");
            map1.put("杨逍","纪晓芙");
            map1.put("张无忌","赵敏");
            System.out.println(map1);
            //有键值对就删除，并返回对应的value，没有就返回null
            String s1 = map1.remove("杨过");
            System.out.println("s1"+s1);
        }
}
package Demo33;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
Map集合中的第一种遍历方式： 通过键找值set<K> keySet()
Map集合中的方法：
    set<K> keySet() 返回此映射中包含的键的set视图
实现步骤：
    1、使用Map集合中的方法keySet(),把Map集合所有的key取出来，存储到一个Set集合中
    2、遍历Set集合，获取Map集合中的每一个Key
    3、通过Map集合中的方法get(Key),通过key找value
 */
public class DemoKeySet {
    public static void main(String[] args) {
       //创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("张天爱",178);
        map.put("王丽坤",188);
        //1、使用Map集合中的方法keySet，把Map集合所有的key取出来，存储到一个Set集合中
        Set<String> set = map.keySet();
        //2、遍历Set集合，获取Map集合中的每一个Key
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String key = it.next();
            //3、通过Map集合中的方法get(Key),通过key找value
            Integer value = map.get(key);
            System.out.println(key + value);
        }
        System.out.println("=================");
        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println(key + value);
        }
    }
}
package Demo33;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
Map集合遍历第二种方式：
    Map集合的方法：
        Set<Map.Entry<K,V>> entrySet() 返回此映射包含的映射管的的set视图
    实现步骤：
        1、使用Map集合中的方法entrySet(), 把Map集合中多个Entry对象取出来，存储到一个set集合中
        2、使用Set集合，获取每一个Entry对象
        3、使用Entry对象中的方法getKey()和getValue获取键与值
 */
public class DemoEntrySet {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("张天爱",178);
        map.put("王丽坤",188);
        //1、使用Map集合中的方法entrySet(), 把Map集合中多个Entry对象取出来，存储到一个set集合中
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        // 2、遍历Set集合，获取每一个Entry对象
        //使用迭代器遍历Set集合
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()){
            Map.Entry<String, Integer> entry = it.next();
            //3、使用Entry对象中的方法getKey()和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + value);
        }
        System.out.println("==================");
        for (Map.Entry<String, Integer> entry : set) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+value);
        }
    }
}
package Demo33;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class DemoHashMapSavePerson {
    public static void main(String[] args) {
        show1();
        System.out.println("==================");
        show2();
    }
   /* HashMap存储自定义类型键值
    key:Person类型
    Person类型自己重写了hashCode方法和equals方法，尅保证key唯一
    value： String类型
     */
    private static void show2() {
        HashMap<Person, String> map = new HashMap<>();
       map.put(new Person("女王",18),"英国");
       map.put(new Person("秦始皇",18),"秦国");
       map.put(new Person("普京",18),"俄罗斯");
       map.put(new Person("女王",18),"毛里求斯");
    //使用entrySet
        Set<Map.Entry<Person, String>> set = map.entrySet();
        for (Map.Entry<Person, String> entry : set) {
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + value);
        }
    }
    /*
    HashMap存储自定义类型键值
    key: String类型
        String类型重写了hashCode方法和equals方法，尅保证key唯一
    value： Person类型
        value可以重复
     */
    private static void show1() {
        //K是字符串 V是Person
        //字符串重写了toString方法
        HashMap<String, Person> map = new HashMap<>();
        map.put("北京",new Person("张三",18));
        map.put("上海",new Person("李四",19));
        map.put("广州",new Person("王五",17));
        map.put("北京",new Person("赵六",16));
    //使用keySet
        Set<String> set = map.keySet();
        for (String key : set) {
            Person value = map.get(key);
            System.out.println(key + value);
        }
    }
}
package Demo33;
import java.util.Objects;
public class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
package Demo33;
import java.util.HashMap;
import java.util.LinkedHashMap;
/*
java.util.LinkedHashMap<K,V> extends HashMap<K,V>
Map接口的哈希表和链接列表实现，具有可预知的迭代顺着
底层原理：
    哈希表+链表(记录元素顺序)
 */
public class DemoLinkedHashMap {
    public static void main(String[] args) {
        HashMap<String,String> map = new LinkedHashMap<>();
        map.put("a","a");
        map.put("c","c");
        map.put("b","b");
        map.put("a","d");
        System.out.println(map);//key不允许重复，有序的
    }
}