package 集合;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Map {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        //初始化数据
        Test01(map);
        //单项测试
        Test02(map);
        System.out.println(map);
    }

    private static void Test02(HashMap<Integer, String> map) {

        //暂不明作用!
        //map.compute();

        //暂不明作用!
        if (false) {
            String s = map.computeIfAbsent(1, Map -> map.get(2));
            System.out.println(s);
        }
        //暂不明作用!
        //map.computeIfPresent();

        //暂不明作用!
        //map.replaceAll();

        //暂不明作用!
        //map.forEach();

        //清空map
        //map.clear();


        //如果此映射包含指定键的映射，则返回 true
        if (false) {
            boolean b = map.containsKey(1);
            if (b) {
                System.out.println("存在1这个Key");
            } else {
                System.out.println("不存在1这个Key");
            }
        }

        //如果此地图将一个或多个键映射到指定的值，则返回 true
        if (false) {
            boolean b = map.containsValue("英雄联盟0");
            if (b) {
                System.out.println("存在英雄联盟0");
            } else {
                System.out.println("不存在英雄联盟0");
            }
        }

        //entrySet()返回set集合
        if (false) {
            //返回set集合
            Set<java.util.Map.Entry<Integer, String>> entries = map.entrySet();
            //toString遍历集合
            if (false) {
                System.out.println(entries);
            }

            //使用set迭代器遍历Set
            if (false) {
                Iterator<java.util.Map.Entry<Integer, String>> it = entries.iterator();
                //让指针指向下一个元素
                while (it.hasNext()) {
                    //获取这个元素内容
                    java.util.Map.Entry<Integer, String> next = it.next();
                    System.out.print(next + " ");
                }
                System.out.println();
            }
        }

        //将指定的对象与此映射进行比较以获得相等性 比较的是对象 手写比较的就是对象类型!
        if (false) {
            boolean b = map.equals("");
            if (b) {
                System.out.println("对象相等");
            } else {
                System.out.println("对象不相等");
            }
        }

        /**
         *Key如果不为null 则会优先匹配Key对应的Value
         *Key找不到的时候才会用Value查找
         * Key和Value查到返回 Value值 查不到返回空
         */
        if (false) {
            //优先查询Key
            if (false) {
                String lol = map.getOrDefault(3, "英雄联盟0");
                System.out.println(lol);
            }
            //查询Value 并且返回
            if (true) {
                String lol = map.getOrDefault(null, "英雄联盟0");
                System.out.println(lol);
            }
        }

        if (false) {
            int i = map.hashCode();
            System.out.println("哈希值为:\t" + i);
        }


        //如果此地图不包含键值映射，则返回 true
        if (false) {
            boolean b = map.isEmpty();
            if (b) {
                System.out.println("map为空");
            } else {
                System.out.println("map不为空");
            }
        }


        //返回此地图中包含的键的Set视图
        if (false) {
            Set<Integer> i = map.keySet();
            if (false) {
                //输出Set视图
                System.out.println(i);
            }
            //根据Set迭代器+map的get(Key)来变量map元素
            if (true) {
                Iterator<Integer> it = i.iterator();
                while (it.hasNext()) {
                    Integer n = it.next();
                    System.out.print(n + " " + map.get(n) + "\t");
                }
                System.out.println();
            }
        }

        //将map的所有内容添加到本对象后面
        if (false) {
            //定义对象二
            HashMap<Integer, String> IntStrMap = new HashMap<>();
            IntStrMap.put(100, "王者荣耀");
            IntStrMap.put(1001, "王者荣耀");
            //复制
            map.putAll(IntStrMap);
        }

        /**
         * 查询Key的值  如果存在则返回Key对应的Value值
         *若Key不存在则将Key和Value插入map
         */
        //可以去重
        if (false) {
            //不存在213 直接尾插到map
            if (true) {
                map.putIfAbsent(213, "abc");
            }
            //存在1, 则返回Key对应的Value值  不插入
            if (true) {
                String s = map.putIfAbsent(1, "abc");
                System.out.println(s);
            }
        }

        //如果存在从该地图中删除一个键的映射
        if (false) {
            String remove = map.remove(1);
            //返回删除的元素
            System.out.println(remove);
        }

        //当Key 与 Value值完全匹配时才会删除元素
        if (false) {
            boolean b = map.remove(1, "英雄联盟1");
            if (b) {
                System.out.println("英雄联盟2删除成功");
            } else {
                System.out.println("英雄联盟2删除失败");
            }
        }

        //当Key与Value完全匹配时       修改Value为新的Value值
        if (false) {
            boolean b = map.replace(1, "英雄联盟1", "342");
            if (b) {
                System.out.println("完全匹配修改成功");
            } else {
                System.out.println("未能完全匹配");
            }
        }

        //返回此地图中键值映射的数量。
        if (false) {
            int size = map.size();
            System.out.println(size);
        }


        //返回Collection视图
        if (false) {
            Collection<String> values = map.values();
            //System.out.println(values);
            //迭代器遍历
            Iterator<String> it = values.iterator();
            while (it.hasNext()) {
                System.out.print("第一个元素为: " + it.next() + "\t");
            }
            System.out.println();
        }
    }

    private static void Test01(HashMap<Integer, String> map) {
        for (int i = 0; i < 5; i++) {
            //添加元素
            map.put(i, "英雄联盟" + i);
        }
    }
}