Java Lambda表达式与Stream流

Lombda表达式与Stream流

1、lombda表达式是jdk1.8的新特性，

Java中的lambda无法单独出现，它需要一个函数式接口来盛放，lambda表达式方法体其实就是函数接口的实现.

函数式接口:简单来说，函数式接口是只包含一个方法的接口

@FunctionalInterface
public interface Test {
    void outPrint();
}

java 8提供 @FunctionalInterface作为注解,这个注解是非必须的，只要接口符合函数式接口的标准（即只包含一个方法的接口），虚拟机会自动判断， 但 最好在接口上使用注解@FunctionalInterface进行声明，以免团队的其他人员错误地往接口中添加新的方法。

2、语法

() -> {}

左侧

（）方法参数，可以写成（x,y）也可以这样（Integer x,Integer y）

只有一个参数时(x)可以省略括号 x;

中间

->

右侧

{} 方法代码块

没有返回值 {System.out.println()}；可以省略花括号System.out.println()。

有返回值 {

return 类的实例点 接口的方法名；

}

无参数，无返回值1

public class Test01 {
    public static void main(String[] args) {
        Test test = () -> {
            System.out.println("Lambda表达式");
        };
        test.outPrint();
    }
}

无参数，无返回值2

public class Test01 {
    public static void main(String[] args) {
        Test test = () -> System.out.println("Lmbda表达式");
    }
}

有参数，无返回值1

public class Test01 {
    public static void main(String[] args) {
        Test test = (x,y) -> {
            System.out.println(x+y);
        };
        test.outPrint(1,2);
    }
}

有参，数无返回值2

public class Test01 {
    public static void main(String[] args) {
        Test test = (Integer x,Integer y) -> {
            System.out.println(x+y);
        };
        test.outPrint(1,2);
    }
}

有参，数无返回值3

public class Test01 {
    public static void main(String[] args) {
        Test test = x -> {
            System.out.println(x);
        };
        test.outPrint(1);
    }
}

有参数，有返回值

public class Test01 {
    public static void main(String[] args) {
        Test test = (x,y)-> {
            return x + y;
        };
        System.out.println(test.outPrint(1,2));
    }
}

多用于线程

public class Test01 {
    public static void main(String[] args) {
        Runnable runnable = () -> {
            System.out.println("这是一个Lambda表达式的Runnable的线程");
        };
        runnable.run();
    }
}

Stream流

stream流同样是Java8的的新特性，可以看作迭代器，对数据进行处理。

在Java8之前，通常用 普通循环、for 循环 或者 Iterator 迭代来重排序合并数据，或者通过重新定义 Collections.sorts的 Comparator 方法来实现，这两种方式对 大数量系统来说，效率不理想。

stream流的步骤，创建一个流、中间操作、结束操作

**数据源：**流的来源可以是数组、集合、 I/O channel， 产生器generator 等

1、创建流

 //1.Collection 提供了两个方法   stream()与parallelStream()

        List<String> list = new ArrayList<>();
        //获取一个顺序流
        Stream<String> stream = list.stream();
        //获取一个并行流
        Stream<String> parallelStream = list.parallelStream();

        //2.通过Arraysz中stream()获取一个数组流
        Integer[] nums = new Integer[10];
        Stream<Integer> stream1 = Arrays.stream(nums);

        //3.通过stream类中静态方法 of()
        Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6);

        //4.创建无限流
        //迭代
        Stream<Integer> stream3 = Stream.iterate(0,(x) -> x+2).limit(10);
        stream3.forEach(System.out::println);

        //生成
        Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
        stream4.forEach(System.out::println);

2、中间操作

forEach迭代

stream4.forEach(System.out::println); //打印输出

filter过滤

//过滤掉学生年纪小于等于18的
List<Student> list1 = new ArrayList<>();
        list1.add(new Student(1,"张三",18));
        list1.add(new Student(2,"李四",20));
        list1.add(new Student(3,"王五",22));
        Stream<Student> studentStream = list1.stream();
        List<Student> list2 = studentStream.filter(student -> student.getAge() > 19).collect(Collectors.toList());
        System.out.println(list2.toString());//  打印输出
long count = studentStream.filter(student -> student.getAge() > 19).count(); //统计

sorted排序

sorted()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：定制排序，自定义Comparator排序器

// 学生年龄从大到小排序
List<Student> list2 = studentStream.sorted((o1, o2) ->{
                    if(o1.getAge() < o2.getAge()){
                        return o1.getAge() - o2.getAge();
                    }else {
                        return o2.getAge() - o1.getAge();
                    }
                }).collect(Collectors.toList());
        System.out.println(list2.toString());

//简写
 List<Student> list2 = studentStream.sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());

map映射

 //将年龄为24的学生的年龄设置为20
 List<Student> list2 = studentStream.map(
                student -> {
                    if(student.getAge() == 24){
                        student.setAge(20);
                    }
                    return student;
                }).collect(Collectors.toList());
        System.out.println(list2.toString());

peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值；而peek接收的是Consumer表达式，没有返回值。

 List<Student> list2 = studentStream.peek(
                student -> {
                    if(student.getAge() == 24){
                        student.setAge(20);
                    }
                }).collect(Collectors.toList());
        System.out.println(list2.toString());

限制条数 limit

//设置年龄为24学生的年龄为20，再把2个学生装在List中
List list2 = studentStream.peek(
                student -> {
                    if(student.getAge() == 24){
                        student.setAge(20);
                    }
                }).limit(2).collect(Collectors.toList());
        System.out.println(list2.toString());

终止操作

allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
findFirst：返回流中第一个元素
findAny：返回流中的任意元素
count：返回流中元素的总个数
max：返回流中元素最大值
min：返回流中元素最小值

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
 
boolean allMatch = list.stream().allMatch(e -> e > 10); //false
boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true
boolean anyMatch = list.stream().anyMatch(e -> e > 4);  //true
 
Integer findFirst = list.stream().findFirst().get(); //1
Integer findAny = list.stream().findAny().get(); //1
 
long count = list.stream().count(); //5
Integer max = list.stream().max(Integer::compareTo).get(); //5
Integer min = list.stream().min(Integer::compareTo).get(); //1

收集操作

stream.collect(Collectors.toList()  //返回一个list集合
stream.collect(Collectors.toSet())  //返回一个set
stream.collect(Collectors.toMap(Student::getName, Student::getAge)); //返回一个map