java8 lambda常见用法总结

个人总结的一些关于java8 lambda stream相关的操作和写法，可以直接复制粘贴，亲自体验功能。

package test;

import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@ToString
@Data
@Accessors(chain = true)
public class people {
    private String name;
    private int age;
    private String sex;

    private static List<people> getPeopleList() {
        people p1 = new people().setName("张三").setAge(21).setSex("女");
        people p2 = new people().setName("李四").setAge(43).setSex("男");
        people p3 = new people().setName("赵五").setAge(35).setSex("男");
        people p4 = new people().setName("王六").setAge(15).setSex("女");
        ArrayList<people> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        return list;
    }

    //遍历数组
    public static void foreachTest() {
        List<people> list = getPeopleList();
        list.forEach(e -> e.age += 3);
        //System.out::println双冒号表示对该变量的对象执行此方法，可以写成list.forEach(e->System.out.println(e));
        list.forEach(System.out::println);
        HashMap<String, String> map = new HashMap<>();
        map.put("1", "hello");
        map.put("2", "world");
        map.forEach((k, v) -> System.out.println(k + "--" + v));
        
    }

    //过滤筛选，经过此方法会获得比原数组size小的数组
    public static void filterTest() {
        List<people> list = getPeopleList();
        list.stream().filter(e -> e.getSex().equals("男")).forEach(System.out::println);
    }

    //获取固定数量的前n个元素
    public static void limitTest() {
        List<people> list = getPeopleList();
        list.stream().limit(2).forEach(System.out::println);
    }

    //按照某个number字段进行排序，默认从小到大
    public static void sortedTest() {
        List<people> list = getPeopleList();
        list.stream().sorted((e, f) -> (e.getAge() - f.getAge())).forEach(System.out::println);
    }

    //获取数组中某个number字段最大或者最小的元素
    public static void maxOrMinTest() {
        List<people> list = getPeopleList();
        String s = list.stream().max(Comparator.comparing(people::getAge)).get().toString();
        System.out.println(s);
    }

    //遍历数组中每一个元素并操作
    public static void mapTest() {
        List<people> list = getPeopleList();
        list.stream().map(e -> (e.setAge(e.getAge() + 3))).forEach(System.out::println);
    }

    //计总数,只能用于number类型的数组，如果是object类型的数组，可以使用94行的statisticsTest方法演示来计数。
    public static void reduceTest() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Integer sum = list.stream().reduce((s, d) -> (s += d)).get();
        System.out.println(sum);
    }

    //可以将数组转化为其他类型的数据
    public static void collectTest() {
        List<people> list = getPeopleList();
        List<people> collect = list.stream().map(e -> (e.setAge(e.getAge() + 3))).collect(Collectors.toList());
        collect.forEach(System.out::println);
        String s = collect.stream().map(people::getName).collect(Collectors.joining(","));
        System.out.println(s);

    }

    //number数据的分析
    public static void statisticsTest() {
        List<people> list = getPeopleList();
        IntSummaryStatistics intSummaryStatistics = list.stream().mapToInt(e -> e.getAge()).summaryStatistics();
        System.out.println("年龄最大：" + intSummaryStatistics.getMax());
        System.out.println("年龄最小：" + intSummaryStatistics.getMin());
        System.out.println("平均年龄：" + intSummaryStatistics.getAverage());
        System.out.println("年龄总和：" + intSummaryStatistics.getSum());
        System.out.println("个数：" + intSummaryStatistics.getCount());

    }

    //去重，删除重复的元素(不是比较hash地址，对象元素会比较每一个属性值是否一样)
    public static void distinctTest() {
        List<people> list = getPeopleList();
        list.add(new people());
        list.add(new people());
        Long count = list.stream().distinct().count();
        System.out.println(count);
    }

    //将多个同种集合合成一个集合
    public static void flatMapTest() {
        Stream<List<Integer>> inputStream = Stream.of(
                Arrays.asList(1),
                Arrays.asList(2, 3, 5),
                Arrays.asList(4, 6, 5)
        );
        List<Integer> list = inputStream.flatMap((childList) -> childList.stream()).collect(Collectors.toList());
        list.forEach(System.out::println);
    }

    //判断，可以对符合peek要求的元素进行额外的处理
    public static void peekTest() {
        List<people> list = getPeopleList();
        list.stream().peek(a -> {
            if (a.getSex().equals("男")) {
                a.setAge(a.getAge() + 3);
            }
        })
                .forEach(System.out::println)
        ;
    }


    //allMatch：是不是Stream中的所有元素都满足给定的匹配条件
    public static void allMatchTest() {
        List<people> list = getPeopleList();
        System.out.println(list.stream().allMatch(a -> a.getAge() >= 30));
    }

    // anyMatch：Stream中是否存在任何一个元素满足匹配条件
    public static void anyMatchTest() {
        List<Integer> list = Arrays.asList(1, 3, 2, 0);
        System.out.println(list.stream().anyMatch(a -> a > 100));
        System.out.println(list.stream().anyMatch(a -> a > 2));
    }

    //noneMatch：是不是Stream中的所有元素都不满足给定的匹配条件
    public static void noneMatchTest() {
        List<Integer> list = Arrays.asList(1, 3, 2, 0);
        System.out.println(list.stream().noneMatch(a -> a > 100));
        System.out.println(list.stream().noneMatch(a -> a > 2));
    }

    public static void main(String[] args) {
        // foreachTest();
        // filterTest();
        // limitTest();
        // sortedTest();
        // maxOrMinTest();
        // mapTest();
        // reduceTest();
        // collectTest();
        // statisticsTest();
        // distinctTest();
        // flatMapTest();
        // peekTest();
        // allMatchTest();
        // anyMatchTest();
        // noneMatchTest();
    }
}