java静态方法调用mapper java 静态map

Map

双列结合的根接口
    1.以键值对形式保存数据
        一个key 对应一个value
    2.键保持唯一

    HashSet和HashMap之间的关系
    底层都是哈希算法 根据面向对象来分析 一套算法 两个类使用
    HashSet底层是依赖HashMap去实现的
    添加到Set中的值 实际上 是 添加到Map中的 键的 位置

    HashMap: 有去重功能(操作的是键)(value不具备这项功能)
    TreeMap: 有排序功能(操作的是键)(value不具备这项功能)

Map的添加方法

// map 的添加方法
        HashMap<String, Integer> map = new HashMap<>();
        Integer put = map.put("Java", 21);
        Integer put2 = map.put("Javaya", 19);
        Integer put3 = map.put("Javaya", 28);
        // Javaya 的 19 被 28 覆盖了
        // put方法 返回的是 被覆盖的值
        System.out.println(put);
        System.out.println(put2);
        System.out.println(put3);

是否包含key

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        //是否包含key
        boolean containsKey = mao.containsKey("a");
        System.out.println(containsKey);

是否包含value

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        boolean containsValue = map.containsValue(19)
        System.out.println(containsValue);

通过key 获取对应的value

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        Integer i1 = map.get(a);
        Integer i1 = map.get(b);
        System.out.println(i1);
        System.out.println(i2);

获取所有key的Set集合

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        Set<String> keySet = map.KeySet();
        System.out.println(keySet);

获取所有value的集合

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        Collection<Integer> values = map.values();
        System.out.println(values);

通过key删除整个键值对

Integer remove = map.remove("c");
    System.out.println(remove);

清空Map

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        map.clear();
        System.out.println(map);

创建一个学生类 里面保存姓名和年龄
    写上构造方法 set/get方法 重写toString方法

//创建一个Map key保存学生 value保存户籍
    HashMap<Student, String> hashMap = new HashMap<>();
        hashMap.put(new Student("a", 21), "温州");
        hashMap.put(new Student("b", 22), "安徽");
        hashMap.put(new Student("c", 23), "河南");
        hashMap.put(new Student("c", 23), "河北");
        System.out.println(hashMap);

    发现打印结果 c 有两个 且 一个户籍是 河南 一个户籍是河北
    如果想保持键的唯一性的话
    就需要去重
    这里去重就相当于Set集合去重
    需要重写hashCode 和 equals方法
    重写之后 key相同 value就会被新的值覆盖

用迭代器遍历Map

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        //通过keySet遍历
        Set<String> KeySet = map.KeySet();
        Iterator<String> iterator = keySet.iterator();
        while(iterator.hasNext()){
            String key = iterator.next();
            //根据key 取出 value
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }

用增强for循环(foreach)来遍历

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        //通过增强for循环
        //获取key的所有set集合
        Set<Sring> keySet = map.KeySet();
        for(String key : keySet){
            // 通过key取出value
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }

通过获取键值对对象是Set集合 来遍历

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            // 获取Entry 对象
            Entry<String, Integer> entry = iterator.next();
            // 获取key
            String key = entry.getKey();
            // 获取value
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }

增强for循环 Entry遍历

HashMap<String, Integer> map = new HashMap<>();
        map.put("a", 21);
        map.put("b", 20);
        map.put("c", 22);
        map.put("d", 19);
        Set<Entry<String,Integer>> entrySet = map.entrySet();
        for (Entry<String, Integer> entry : entrySet) {
            Integer value = entry.getValue();
            String key = entry.getKey();
            System.out.println(key + " = " + value);
        }

// 键盘输入字符串 统计字符串中每个字符出现的次数 

    System.out.println("请输入字符串");
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        char[] charArray = string.toCharArray();
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < charArray.length; i++) {
            // 将每一个字符 存入map中
            // 判断要存的字符 是否存在于 map 中
            char key = charArray[i];
            if (!map.containsKey(key)) {
                // 不存在这个key 记录一次
                map.put(charArray[i], 1);
            }else {
                // 存在这个key
                // 利用key把对应的值 取出来 + 1
                Integer value = map.get(key);
                value = value + 1;
                // 再存回去 覆盖原来 值的 部分
                map.put(key, value);
            }

        }
        System.out.println(map);

linkedHashMap

特点: 有序(怎么存的 怎么打印)

LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        map.put("a", 18);
        map.put("b", 19);
        map.put("c", 20);
        map.put("d", 21);
        System.out.println(map);

TreeSet

特点: 有排序功能(操作的是键)(value不具备这项功能)

// 创建一个TreeMap key保存学生 value 保存 户籍
    // 按年龄排序
    TreeMap<Student, String> map = new TreeMap<>();
        map.put(new Student("a", 11), "安徽");
        map.put(new Student("b", 13), "浙江");
        map.put(new Student("c", 17), "河南");
        map.put(new Student("d", 16), "江苏");
        System.out.println(map);

        //使用TreeMap时 系统会自动帮你排序
        //所以打印出来的结果就是按年龄从小打到打印

Collections类中的方法(静态方法)

随机交换集合中的值

ArrayList<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(13);
        list.add(10);
        list.add(11);
        Collections.shuffle(list);
        System.out.println(list);

排序

ArrayList<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(13);
        list.add(10);
        list.add(11);
        Collections.sort(list);
        System.out.println(list);

ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("ygs",10));
        list.add(new Student("sxd",12));
        list.add(new Student("hzn",8));
        //排序 实现comparable 接口 只要排的是对象 都需要编写排序规则
        Collections.sort(list);
        System.out.println(list);

二分查找(前提: 有序)

ArrayList<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(13);
        list.add(10);
        list.add(11);
        int index = Collections.binarySearch;
        System.out.println(index);

反转

ArrayList<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(13);
        list.add(10);
        list.add(11);
        Collections.reverse(list);
        System.out.println(list);