Map的几个高级技巧性使用方法

Map的几个高级技巧性使用方法

高级使用1：

v getOrDefault(Object key, defaultValue);

例如：我们定义一个HashMap，用来存储一个数组中的数字已经其出现的次数

@Test
public void test01() {
    //定义一个hashmap,我们存储一个数组中的数字已经其出现的次数
    int[] nums = {1,2,3,1,3,4,6,7,9,9,1,3,4,5};
    //1. 存储<k,v>时，如果key不存在，则设置其key对应的value值为1，否则，加原来的基础上加1
    Map<Integer,Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i],map.getOrDefault(nums[i],0) + 1);
    }

    map.forEach((key,value) -> {
        System.out.print(key + ": ");
        System.out.println(value);
    });
}

输出结果：

1: 3
2: 1
3: 3
4: 2
5: 1
6: 1
7: 1
9: 2

高级使用2：

default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
    ...
}

我们在复杂map操作（put操作）时候有的时候不知道此时当前key对应的value值是否存在，这里，我们如果使用常规的代码编写，代码量比较大

例如我们定义一个场景：存在一个数组，我们需要将当前数组中相同的数存储到一个对应List集合中

常规实现：

@Test
public void test02() {
    //复杂map的使用场景：首先我们说复杂map，即map的value值为一个list集合或者是一个Set集合，对象或者是其他的集合
    //给定一个场景：现在存在一个数组，我们需要将当前数组中相同的数存储到一个对应List集合中
    int[] nums = {1,2,3,1,3,4,6,7,9,9,1,3,4,5};
    Map<Integer, List<Integer>> map = new HashMap<>();
    //普通的写法
    for (int i = 0; i < nums.length; i++) {
        if (!map.containsKey(nums[i])) {
            ArrayList<Integer> list = new ArrayList<>();
            list.add(nums[i]);
            map.put(nums[i],list);
        }else {
            map.get(nums[i]).add(nums[i]);
        }
    }
    map.forEach((key,value) -> {
        System.out.print(key + ": ");
        System.out.println(value);
    });
}

使用computeIfAbsent方法实现：

@Test
public void  test03() {
    int[] nums = {1,2,3,1,3,4,6,7,9,9,1,3,4,5};
    Map<Integer, List<Integer>> map = new HashMap<>();
    //我们使用map的computeIfAbsent解决
    for (int i = 0; i < nums.length; i++) {
        //返回值是该key对应的集合list
        map.computeIfAbsent(nums[i], key -> new ArrayList<Integer>());
        map.get(nums[i]).add(nums[i]);
    }

    map.forEach((key,value) -> {
        System.out.print(key + ": ");
        System.out.println(value);
    });
}

输出结果：

1: [1, 1, 1]
2: [2]
3: [3, 3, 3]
4: [4, 4]
5: [5]
6: [6]
7: [7]
9: [9, 9]

高级使用3：Map按照value值进行排序

map.entrySet().stream().sorted(Comparator<? super T> comparator)

给定一个map，存储一个nums数组中每一个数字存储的次数，最后将这个map按照value值，即出现的次数进行排序

第一种方式：返回的是降序以后的新的map

@Test
public void test04() {
    int[] nums = {1,2,3,1,3,4,6,7,9,9,1,3,4,5};
    Map<Integer,Integer> map = new LinkedHashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i],map.getOrDefault(nums[i],0) + 1);
    }
    //对map的value进行排序，并返回降序以后的map集合
    LinkedHashMap<Integer, Integer> collect = map.entrySet().stream().sorted((entry1, entry2) -> {
        return entry2.getValue() - entry1.getValue();
    }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,(oldValue, newValue) -> oldValue, LinkedHashMap::new));

    collect.forEach((key,value) -> {
        System.out.println(key + ": " + value);
    });
}

输出结果：

1: 3
3: 3
4: 2
9: 2
2: 1
6: 1
7: 1
5: 1

第二种方式：返回的是value降序的集合（List）

@Test
public void test05() {
    int[] nums = {1,2,3,1,3,4,6,7,9,9,1,3,4,5};
    Map<Integer,Integer> map = new LinkedHashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i],map.getOrDefault(nums[i],0) + 1);
    }

    //按照map的value进行排序，并返回最后的value的降序的集合
    List<Integer> collect = map.entrySet().stream()
        .sorted((entry1, entry2) -> entry2.getValue().compareTo(entry1.getValue()))
        .map(entry -> entry.getValue())
        .collect(Collectors.toList());


    collect.forEach(System.out::println);
}

输出结果：

3
3
2
2
1
1
1
1