一、简介：

Lamda表达式能帮助你编写更清楚、更简洁的代码。

 

二、案例

import org.junit.Test;
import java.util.*;
import java.util.stream.Collectors;

public class LamdaTest {

    public static List<Map<String,Integer>> list = new ArrayList<>();
    public static Map<String,Integer> map = new HashMap<>();
    public static Map<String,Integer> map1 = new HashMap<>();
    public static Map<String,Integer> map2 = new HashMap<>();
    public static Map<String,Integer> map3 = new HashMap<>();

    static {
        map.put("name",0);
        map1.put("name1",1);
        map2.put("name2",2);
        map3.put("3name3",3);
        list.add(map);
        list.add(map1);
        list.add(map2);
        list.add(map3);
    }

    /*
    filter：该方法只能返回boolean值，返回值不会被写入到集合中
    filter括号中的函数相当于if括号中的条件，要么true，要么false
    问题：获取list集合中存在多少个key为name的属性
     */
    @Test
    public void filter() {
        long count = list.stream().filter(s->{
            String key = s.keySet().iterator().next();
            return key.equals("name");
        }).count();
        System.out.println(count);
    }

    /*
    map：该方法可以返回任何类型,返回值会被写入到接收的集合中
    问题：获取list集合中的key转换为大写
     */
    @Test
    public void map(){
        List<Object> result = list.stream().map(s -> {
            String key = s.keySet().iterator().next();
            String t = key.toUpperCase();
            return t;
        }).collect(Collectors.toList());
        System.out.println(result.toString());
    }


    /*
    max：返回集合中最大的值
    问题：返回list集合中value最大的map对象
     */
    @Test
    public void max(){
        Map<String, Integer> max = list.stream().max(Comparator.comparing(s->{
            String key = s.keySet().iterator().next();
            Integer value = s.get(key);
            return value;
        })).get();
        System.out.println(max);
    }

    /*
    min：返回集合中最小的值
    问题：返回list集合中value最小的map对象
     */
    @Test
    public void min(){
        Map<String, Integer> min = list.stream().min(Comparator.comparing(s->{
            String key = s.keySet().iterator().next();
            Integer value = s.get(key);
            return value;
        })).get();
        System.out.println(min);
    }


    /*
    reduce：i表示累加值，j表示集合下一个元素
    问题：计算list集合中value的累加值
     */
    @Test
    public void reduce(){
        List<Integer> lists = list.stream().map(s->{
            String key = s.keySet().iterator().next();
            Integer value = s.get(key);
            return value;
        }).collect(Collectors.toList());

        Optional<Integer> reduce = lists.stream().reduce((i, j) -> {
            return i + j;
        });
        System.out.println(reduce.get());
    }


    /*
    问题：显示list集合中 key="name" 的年龄
     */
    @Test
    public void test1(){
        List<Integer> values = list.stream()
                .filter(s->{
                    return s.get("name")!=null;
                }).map(s -> {
                    Integer value = s.get("name");
                    return value;
                }).collect(Collectors.toList());
        System.out.println(values);
    }

    /*
    问题：获取list集合中key以n开头的map对象，并将满足条件的key的value设置为100,然后显示出来
     */
    @Test
    public void test2(){
        List<Object> objects = list.stream().filter(s -> {
            String key = s.keySet().iterator().next();
            return key.startsWith("n");
        }).map(s->{
            String key = s.keySet().iterator().next();
            s.put(key,100);
            return s;
        }).collect(Collectors.toList());
        System.out.println(objects);
    }

    /*
    问题：将list集合中的value排序输出
     */
    @Test
    public void test3(){
        List<Integer> sort = list.stream().map(s -> {
            String key = s.keySet().iterator().next();
            return s.get(key);
        }).collect(Collectors.toList()).stream().sorted().collect(Collectors.toList());
        System.out.println(sort);
    }
}