java——lambda&Stream流

Lambda 表达式的结构：
 Lambda 表达式可以具有零个，一个或多个参数。
可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。例如 (int a,int b)与 (a,b)相同。
参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。
空括号用于表示一组空的参数。例如 () -> 42。
当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。 例如 a -> return a*a。
Lambda 表达式的正文可以包含零条，一条或多条语句。
如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式的返回值类型要与匿名函数的返回类型相同。
如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。
Java 中的 Lambda 表达式通常使用 (argument) -> {body}语法书写。
功能接口（Functional interface） 
Functional interface功能函数接口，只能定义一个抽象方法，可以用使用@FunctionalInterface来检测接口是否能使用lambda接口，当我们要使用lambda接口时，实现的接口里只能有一个抽象方法，因为需要自动类型推断。

public interface Demo {
 
    //当我们要使用lambda接口时，实现的接口里只能有一个抽象方法，因为需要自动类型推断
    //void show();
 
    public int sum(int a,int b);
}
 
package lambda;
 
public class DemoTest {
 
    public void test(Demo demo){
        //demo.show();
        demo.sum(3,4);
    }
 
    public static void main(String[] args) {
        DemoTest demoTest=new DemoTest();
 
        //创建一个匿名内部类对象，重写接口中的show方法，将匿名对象传递到test方法中
        /*demoTest.test(new Demo() {
            @Override
            public void show() {
                System.out.println("这是实现Demo接口中的show方法");
            }
        });*/
 
        /*demoTest.test(()->{
            System.out.println("这是实现Demo接口中的show方法");
        });*/
 
        /*demoTest.test((a,b)->{
            int c=a+b;
            return c;
        });*/
 
        demoTest.test((a,b)->{
            return a+b;
        });
    }
}

​

Stream流

定义

stream流，是java8新推出的功能，提供了对数据集合操作的各种方法，我们只需要申明式的告诉其应该做什么，与IO流完全不同。

java中的集合、数组主要是对存储数据，而stream主要是对集合进行操作。就是一个对集合进行遍历的操作的高端迭代器。

简单来说，stream就是“从支持数据处理操作的源,生成的元素序列”。

元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

数据源 :获取数据的源，比如集合。

数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。

我们通过一个集合的 stream 方法获取一个流，然后对流进行一 系列流操作，最后再构建成我们需要的数据集合。

获取流

使用 Collection 接口下的 stream()：

List<String> list = new ArrayList<>();

Stream<String> stream = list.stream();

使用 Arrays 中的 stream() 方法，将数组转成流：

Integer[] nums = new Integer[10];

Stream<Integer> stream = Arrays.stream(nums);

使用 Stream 中的静态方法：of()：

Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

使用 BufferedReader.lines() 方法，将每行内容转成流：

BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));

Stream<String> lineStream = reader.lines();

流操作

流操作可以分为两类：中间操作和终端操作。

中间操作

filter：过滤流中的某些元素,

sorted(): 自然排序，流中元素需实现 Comparable 接口

distinct: 去除重复元素

limit(n): 获取 n 个元素

skip(n): 跳过 n 元素，配合 limit(n)可实现分页

map(): 将其映射成一个新的元素

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class Demo1 {
   
    public static void main(String[] args) {
        Integer[] integer= {3,2,5,7,9,4,1,6,8,4,4,2,2};
 
        Arrays.stream(integer)
                .filter(a -> a<8&&a>2)//筛选流中的某些元素
                .sorted((a,b) -> { return a-b; })//对流进行自然排序，需要实现Comparable接口
                .distinct()//去除重复的元素
                .skip(1)//跳过n个元素，可配合limit()实现分页
                .limit(4)//获取n个元素
                .forEach(e -> System.out.print(e));//遍历流中的元素
        System.out.println();
 
        Integer max=Arrays.stream(integer)//返回一个Stream对象
                .distinct()
                .max((a,b)->{return a-b;})//返回流中最大元素
                //.min((a,b)->{return a-b;})//返回流中最小元素
                .get();
        System.out.println(max);
 
        Integer sum=Arrays.stream(integer)//返回一个Stream对象
                .distinct()
                .reduce((a,b)->{return a+b;})//返回流中元素和
                .get();
        System.out.println(sum);
 
        Object[] objects=Arrays.stream(integer)
                .distinct()
                .toArray();//将流中的元素放入一个数组
        System.out.println(Arrays.toString(objects));
 
        boolean bl=Arrays.stream(integer)
                .distinct()
                .allMatch(a->{return a<6;});//判断流中是否有元素满足条件
                //.allMatch()//判断流中所有元素是否有满足条件
        System.out.println(bl);
 
        long n=Arrays.stream(integer)
                .distinct()
                .count();//返回流中的元素的总个数
        System.out.println(n);
 
        List<Integer> list=Arrays.stream(integer)
                .distinct()
                .collect(Collectors.toList());//将流中的元素放入一个集合，Collection或Map
        System.out.println(list);
 
 
    }
 
}

终端操作

forEach: 遍历流中的元素

toArray:将流中的元素倒入一个数组

Min:返回流中元素最小值

Max:返回流中元素最大值

count:返回流中元素的总个数

Reduce:所有元素求和

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false

allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false

findFirst：返回流中第一个元素

collect:将流中的元素倒入一个集合,Collection 或 Map

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
public class AnimalTest {
    /*
     */
    public static void main(String[] args) {
        Animal animal1=new Animal(4,"金毛");
        Animal animal2=new Animal(5,"柯基");
        Animal animal3=new Animal(2,"拉布拉多");
        Animal animal4=new Animal(6,"哈士奇");
 
        Animal[] animals={animal2,animal1,animal4,animal3};
 
        List<Animal> list=Arrays.stream(animals)
                .sorted((c1,c2)->{return c1.age-c2.age;})
                .filter(c->{return c.name.equals("哈士奇");})//过滤流中的某些元素
                .collect(Collectors.toList());//将流中的元素放入一个集合，Collection或Map
        System.out.println(list);
 
        Map<Integer,String> map=Arrays.stream(animals)
                .sorted((c1,c2)->{return c1.age-c2.age;})
                .collect(Collectors.toMap(Animal::getAge,Animal::getName));//将流中的元素放入一个集合，Collection或Map
        System.out.println(map);
 
        List<String> stringList=Arrays.stream(animals)
                .sorted((c1,c2)->{return c1.age-c2.age;})
                .map(Animal::getName)//将其映射成一个新的元素，即将对象中所需元素提取出来当做新元素放入新的集合中
                .collect(Collectors.toList());
        System.out.println(stringList);
    }
}
package stream;
 
public class Animal {
    int age;
    String name;
 
    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Animal{" +
                "age=" + age +
                ", name=" + name +
                '}';
    }
}