Map集合

一、Map集合
java.util.Map<k,v>
是一个双列集合，一个元素有一个键和一个值（key， value）
（1）、key和value的数据类型可以相同或者不同
（2）、key的值不能重复，value可以
（3）、key与value要相互对应
Map集合有两个子类：
HashMap、LinkedMap
HashMap特点：
存取元素顺序不一致

LinkedMap特点：
存取元素顺序一致

public static void main(String[] args) {
    LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<>();
    linkedHashMap.put("a","a");
    linkedHashMap.put("c","c");
    linkedHashMap.put("b","b");
        System.out.println(linkedHashMap);
        //元素是什么顺序，就怎么输出，有序的
        //{a=a, c=c, b=b}

    HashMap<String,String> hashMap = new HashMap<>();
    hashMap.put("a","a");
    hashMap.put("c","c");
    hashMap.put("b","b");
    System.out.println(hashMap);
    //无顺序输出
    //{a=a, b=b, c=c}
}

1、Map集合的常用方法
put、remove、get、containsKey

public static void main(String[] args) {
    method1();
}
private static void method1() {

    //创建一个Map集合,对键值对进行赋值,使用put
    Map<String,Integer> map = new HashMap<>();
    map.put("小明",20);
    map.put("小明",21);
    System.out.println(map);//{小明=21}

    map.put("小花",18);
    map.put("小李",19);
    map.put("小张",17);
    System.out.println(map);//{小明=21, 小李=19, 小花=18, 小张=17
    System.out.println("++++++++++++++");

    //使用remove
    Integer v= map.remove("小明");
    System.out.println(v);//21
    System.out.println(map);//{小明=21, 小李=19, 小张=17}


    //使用containsKey
    boolean m  = map.containsKey("小花");
    System.out.println(m);//true

    boolean bo = map.containsKey("小白");
    System.out.println(bo);//false
    System.out.println(map);//{小李=19, 小花=18, 小张=17}


    //使用get
    Integer in= map.get("小李");
    System.out.println(in);//19

    Integer in1 = map.get("小徐");
    System.out.println(in1);//null
}

2、Map遍历方法
（1）、键找值的方法
Set<> keySet():<>里面是一个键值

public static void main(String[] args) {
    Map<String,Integer> map = new HashMap<>();
    map.put("小明",20);
    map.put("小林",21);
    map.put("小张",18);
    System.out.println(map);//{小林=21, 小明=20, 小张=18}

    //使用set遍历集合，获取Map集合中的key
    Set<String> key = map.keySet();
    //使用迭代器遍历集合
    Iterator<String> it = key.iterator();
    while (it.hasNext()){
        String str = it.next();
        Integer value = map.get(str);
        System.out.println(str+"="+value);
    }
    System.out.println("-------------");

    //使用增强for
    for(String string : key){
        Integer value =map.get(string);
        System.out.println(string+"="+value);
    }
    System.out.println("+++++++++++++++++");

    //增强for的另一种
    for (String s : map.keySet()){
        Integer value = map.get(s);
        System.out.println(s+"="+value);
    }
}

(2)、Entry方法遍历集合
Set<Map.Entry<K,V>> entrySet()；
使用方法getKey()和getValue()获取键与值

public static void main(String[] args) {
    Map<String,Integer> map  = new HashMap<>();
    map.put("鲤鱼",10);
    map.put("草鱼",13);
    map.put("鲫鱼",12);
    System.out.println(map);//{鲫鱼=12, 草鱼=13, 鲤鱼=10}

    //使用Entry创建遍历对象
    Set<Map.Entry<String,Integer>> entries =map.entrySet();

    //使用迭代器遍历集合
    Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
    while (iterator.hasNext()){
        Map.Entry<String, Integer> next = iterator.next();
        String key = next.getKey();
        Integer value = next.getValue();
        System.out.println(key+"="+value);
    }

    System.out.println("+++++++++++++");

    //使用增强for
 for (Map.Entry<String,Integer> z : map.entrySet()){
     String key = z.getKey();
     Integer value = z.getValue();
     System.out.println(key+"="+value);
 }
}

3、自定义的键值对
要在自定义类中覆盖重写toString方法
要在自定义类中覆盖重写hashcode和equals方法

public static void main(String[] args) {
    method();//使用Set遍历集合
    method1();//使用Entry遍历集合
}
private static void method() {
    //这里key是String  value是person
    HashMap<String,person> hashMap = new HashMap<>();
    hashMap.put("湖人",new person("科比",22));
    hashMap.put("热火",new person("詹姆斯",22));
    hashMap.put("火箭",new person("姚明",22));
    hashMap.put("火箭",new person("麦迪",22));
    //因为key是String重复
    //输出结果会将姚明这个对象覆盖掉


    Set<String> set = hashMap.keySet();
    for (String key : hashMap.keySet()){
        person value = hashMap.get(key);
        System.out.println(key+"="+value);
    }
    System.out.println("+++++++++");

    for (String string :set){
        person value = hashMap.get(string);//注意是从hashMap集合中得到string
        System.out.println(string+"="+value);
    }
    System.out.println("+++++++++");

    //使用迭代器
    Iterator<String> iterator = set.iterator();
    while (iterator.hasNext()){
        String next = iterator.next();
       person value = hashMap.get(next);
        System.out.println(next+"="+value);
    }
}


public static void method1() {
    //这里key是person value是String
    HashMap<person, String> map = new HashMap<>();
    map.put(new person("小明", 15), "长沙");
    map.put(new person("小花", 18), "南京");
    map.put(new person("小彭", 15), "北京");
    map.put(new person("小六", 15), "北京");
    //key是person，没有重复
    //原样打印输出

    Set<person> people = map.keySet();
    for (person p : people) {
        String s = map.get(p);
        System.out.println(p + "=" + s);
    }
    System.out.println("+++++++++++++++");

    for(person pe :map.keySet()){
        String s1 = map.get(pe);
        System.out.println(pe+"="+s1);
    }
    System.out.println("+++++++++++++++");

    Iterator<person> iterator = people.iterator();
    while (iterator.hasNext()){
        person next = iterator.next();
        String value = map.get(next);
        System.out.println(next+"="+value);
    }

    System.out.println("+++++++++++++++");

    //上面使用了keySet方法遍历集合
    //使用Entry遍历集合
    
    Set<Map.Entry<person,String>> set = map.entrySet();

    //使用迭代器
    Iterator<Map.Entry<person, String>> iterator1 = set.iterator();
    while(iterator1.hasNext()){
        Map.Entry<person, String> next = iterator1.next();
        person pepo = next.getKey();
        String value = next.getValue();
        System.out.println(pepo+"="+value);
    }
    System.out.println("+++++++++++++++");

    for (HashMap.Entry<person,String> hashmap :set){
        person key = hashmap.getKey();
        String value = hashmap.getValue();
        System.out.println(key+"+"+value);
    }

}