本文已参与周末学习计划，点击链接查看详情:活动链接

前言

Java Lambda表达式的一个重要用法是简化某些匿名内部类,个人感受是java 8的一个语法糖，其允许把函数作为一个方法的参数（函数作为参数传递进方法中）,使用Lambda表达式不仅可以使代码变的更加简洁紧凑，而且代码量很少，简直不要太香。本文就是一个记录和学习的总结，不会讨论底层原理，只到使用级别。

集合支持的新方法

• Collection：forEach()，stream()，removeIf()，spliterator()，parallelStream()
• List：sort()，replaceAll()
• Map：forEach()，getOrDefault()，replaceAll()，putIfAbsent()，remove()，replace() ，computeIfAbsent()，computeIfPresent()，compute()，merge()

List排序

需求：List集合里面是对象，然后我们需要根据对象里面的首字母排序，达到结果按姓名排序，首先建一个Test对象，然后把对象装到List里面，然后利用Lambda排序，代码如下：

public static class Test {
        private String name;

        public Test(String name) {
            this.name = name;

        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

    }

    public static void main(String[] args) {
        List<Test> list = new ArrayList<>();
        list.add(new Test("lch"));
        list.add(new Test("abc"));
        list.add(new Test("xyz"));
        System.out.println("排序前的list：" + JSON.toJSON(list).toString());
        //1.按姓名排序 (p1, p2) -> p1.getName().compareTo(p2.getName())这段在idea是灰色的说明可以再简写，按option+enter直接简如下
        Collections.sort(list, (p1, p2) -> p1.getName().compareTo(p2.getName()));
        //2.终极再简写
        Collections.sort(list, Comparator.comparing(Test::getName));
        System.out.println("排序后的list：" + JSON.toJSON(list).toString());
    }
复制代码

运行结果：

排序前的list：[{"name":"lch"},{"name":"abc"},{"name":"xyz"}]
排序后的list：[{"name":"abc"},{"name":"lch"},{"name":"xyz"}]
复制代码

List循环

需求：循环List然后找出满足条件的记录，保存到新的List输出。

 List<String> list = new ArrayList<>();
        list.add("lch");
        list.add("abc");
        list.add("xyz");
        List<String> list1 = new ArrayList<>();
        list.forEach(e -> {
            if (e.equals("lch")) {
                list1.add(e);
            }
        });
        System.out.println("只打印指定字符的list："+JSON.toJSON(list1).toString());
复制代码

运行结果：

只打印指定字符的list：["lch"]
复制代码

List的removeIf()方法

需求：还是上文的需求，现在循环，要求删除值是lch的保留剩下的值。

List<String> list = new ArrayList<>();
list.add("lch");
list.add("abc");
list.add("xyz");
// 删除值是lch的
list.removeIf(e -> e.equals("lch"));
System.out.println("删除lch的值后的list："+JSON.toJSON(list).toString());
复制代码

运行结果：

删除lch的值后的list：["abc","xyz"]
复制代码

List的replaceAll()

需求：把长度大于2的记录，内容全部转为大写。

List<String> list = new ArrayList<>();
list.add("lch");
list.add("abc");
list.add("xyz");
list.add("a");
list.add("it");
// 删除值是lch的
list.replaceAll(e -> {
    if (e.length() > 2) {
        return e.toUpperCase();
    }
    return e;
});
System.out.println("长度大于2转大写后的值后的list：" + JSON.toJSON(list).toString());
复制代码

运行结果：

长度大于2转大写后的值后的list：["LCH","ABC","XYZ","a","it"]
复制代码

Map的循环

需求：循环打印map

Map<String, String> map = new HashMap<>();
map.put("1", "one");
map.put("2", "two");
map.put("3", "three");
//循环map 转 JSONObject
map.forEach((k,v)-> System.out.println("循环输出k="+k+",value为："+v));
复制代码

运行结果：

循环输出k=1,value为：one
循环输出k=2,value为：two
循环输出k=3,value为：three
复制代码

map的getOrDefault()

需求：取map中key对应的valus值，如果不存在返回默认值。

Map<String, String> map = new HashMap<>();
map.put("1", "one");
map.put("2", "two");
map.put("3", "three");
//查询Map中指定的值，不存在时使用默认值
System.out.println("取map的key为3的value，返回值为：" + map.getOrDefault("3", "zero"));
System.out.println("取map的key为4的value，返回值为：" + map.getOrDefault("4", "zero"));

复制代码

运行结果：

取map的key为3的value，返回值为：three
取map的key为4的value，返回值为：zero
复制代码

map的putIfAbsent()，replaceAll(），merge(),compute()方法

需求：直接见代码

Map<String, String> map = new HashMap<>();
map.put("1", "one");
map.put("2", "two");
map.put("3", "three");
//不存在放值 存在不放值
map.putIfAbsent("3", "III");
map.putIfAbsent("5", "five");
System.out.println("map执行完putIfAbsent值：" + JSON.toJSONString(map));
//循环转大写
map.replaceAll((k, v) -> v.toUpperCase());
System.out.println("map循环转大写的值：" + JSON.toJSONString(map));
//拼接
map.merge("3", " OOO", (v1, v2) -> v1+v2);
System.out.println("map拼接merge的值：" + JSON.toJSONString(map));
//如果为空放k v  如果不为空 直接拼接
map.compute("10", (k,v) -> v==null ? "ten" : v.concat("ten"));
map.compute("1", (k,v) -> v==null ? "one" : v.concat("III"));
System.out.println("map的compute值：" + JSON.toJSONString(map));
复制代码

运行结果

map执行完putIfAbsent值：{"1":"one","2":"two","3":"three","5":"five"}
map循环转大写的值：{"1":"ONE","2":"TWO","3":"THREE","5":"FIVE"}
map拼接merge的值：{"1":"ONE","2":"TWO","3":"THREE OOO","5":"FIVE"}
map的compute值：{"1":"ONEIII","2":"TWO","3":"THREE OOO","5":"FIVE","10":"ten"}
复制代码

map的computeIfAbsent()方法

需求：实现一个多值映射，Map的定义可能是Map<K,Set>，需要向Map中放入值，不用lambda之前的代码这样写。

Map<Integer, Set<String>> map = new HashMap<>();
// Java7及以前的实现方式
if (map.containsKey(1)) {
    //存在更新
    map.get(9).add("lch");
} else {
    //不存在初始化再put到map中去
    Set<String> valueSet = new HashSet<>();
    valueSet.add("lch");
    map.put(9, valueSet);
}
System.out.println("不用lambda放值结果：" + JSON.toJSON(map).toString());
//等同于
Map<Integer, Set<String>> map1 = new HashMap<>();
map1.computeIfAbsent(9, v -> new HashSet<>()).add("lch");
System.out.println("map的computeIfAbsent值为：" + JSON.toJSON(map1).toString());
复制代码

运行结果：

不用lambda放值结果：{"9":["lch"]}
map的computeIfAbsent值为：{"9":["lch"]}
复制代码

总结

简单总结了lambda表达式对List和Map的支撑，下次重点学习和总结stream，也就是Java函数式编程的主角。今天先到这了 good night！