Lambda表达式&stream

Lambda表达式&stream

Lambda

背景

Java 是面向对象语言，除了部分简单数据类型，Java 中的一切都是对象，即使数组也是一种对象，每个类创建的实例也是对象。在 Java 中定义的函数或

方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。

在 Java 8 以前，若我们想要把某些功能传递给某个方法，总要去写匿名类。

代码示例：

list.sort(new Comparator<User>() { 
    @Override 
    public int compare(User o1, User o2) { 
        return o1.getId()-o2.getId(); 
    } 
}

​ 在上面的例子里，为了对集合集合进行排序，我们为 Comparator 接口创建了一个它的匿名内部类对象，重写接口中的方法,来实现排序功能。

简而言之，在 Java 里将普通的方法或函数像参数一样传值并不简单，为此，

Java 8 增加了一个语言级的新特性，名为 Lambda 表达式。

简介

Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。

Lambda 表达式的本质只是一个**“语法糖”**,由编译器推断并帮你转换包装为

常规的代码,因此你可以使用更少的代码来实现同样的功能。

结构

1）Lambda 表达式可以具有零个，一个或多个参数。

2）可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。

例如 (int a,int b)与 (a,b)相同。

3）参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String

a, int b, float c)。

4）空括号用于表示一组空的参数。例如 () -> 42。

5）当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。

例如 a -> return a*a。

6）Lambda 表达式的正文可以包含零条，一条或多条语句。

7）如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式的返回值类型要与匿名函数的返回类型相同。

8）如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。

Java 中的 Lambda 表达式通常使用 (argument) -> {body}语法书写，例如：

左侧：lambda 表达式的参数列表
右侧：lambda 表达式中需要执行的功能，即
lambda 体 (arg1, arg2…) -> {
body
} (type1 arg1, type2 arg2…) -> {
body
}
以下是一些 Lambda 表达式的例子：
无参数，无返回值

lambda 体中只有一行代码时，{}可以忽略

() -> System.out.println(“Hello World”);

无参数，有返回值

() -> { return 3.14};

有参数，无返回值

(String s) -> { System.out.println(s); }

有一个参数，无返回值

s -> { System.out.println(s); }

有多个参数，有返回值

(int a, int b) -> { return a + b; }

有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断

(a, b) -> { return a - b; }

功能接口

​ Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽 象方法接口。Java 8 也引入了一个注释，即@FunctionalInterface，当你注释 的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。

以下是自定义功能接口的示例：

@FunctionalInterface 
public interface WorkerInterface { 
    public void doSomeWork(); 
}

正如其定义所述，功能接口只能有一个抽象方法。如果我们尝试在其中添加一个抽象方法，则会抛出编译时错误。例如：

@FunctionalInterface 
public interface WorkerInterface { 
    public void doWork(); 
    public void doMoreWork();
}

案例：

@FunctionalInterface 
public interface Shape { 
    void area(int a,int b); 
}
Shape d = (a, b)->{System.out.println(a+b);}; 
d.area(1, 2);

package com.ffyc.lambda;
@FunctionalInterface//功能接口标签
public interface Oper {
    //void oper();
    int add(int a,int b);
}

package com.ffyc.lambda;


public class OperTest {
//    public void show(Oper oper){
//        oper.oper();
//    }
//    public static void main(String[] args) {
//        OperTest operTest=new OperTest();
//        operTest.show(()->{
//            System.out.println("what fa?");
//        });
//    }3
    public void test(Oper oper){
        oper.add(3, 5);
    }

    public static void main(String[] args) {
        OperTest operTest=new OperTest();
        operTest.test((a,b)->{
            System.out.println(a+b);
            return a+b;
        });
    }
}

stream

概念

​ Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把 它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后 编码效率与大大提高，并且可读性更强。

要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全

不同的概念.

简单案例：

public static void main(String[] args) { 
    List<Apple> applestore = new ArrayList();       applestore.add(new Apple(1,"red",500,"河南")); applestore.add(new Apple(2,"red",400,"陕西")); applestore.add(new Apple(3,"green",300,"上海")); applestore.add(new Apple(4,"green",200,"湖北")); applestore.add(new Apple(5,"green",100,"湖南"));
                                      }

我们的需求是在 applestore 集合中找出红色苹果手机.

使用 Stream 流快速实现操作

List<Apple> apples = applestore .stream() 
    .filter(a -> a.getColor()
    .equals("red")) 
    .collect(Collectors.toList());

这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想

要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。 同时可以将这些操作链接起来，达到一种流水线式的效果：

Java8 中的集合支持一个新的 Stream 方法，它会返回一个流。

流：简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

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

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

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

简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一

系列流操作，最后再构建成我们需要的数据集合。

语法

stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|+ 
    List<Integer> list = widgets.stream() 
    					.filter(b -> b.getColor() == RED) 
    					.sorted((x,y) -> x.getWeight() - y.getWeight()) 		.sum();

获取流

使用 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();

流操作

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

List<Apple> apples = applestore .stream() 获得流 
.filter(a -> a.getColor().equals("red")) 中间操作 .collect(Collectors.toList()); 终端操作

简化一下就是：

数据源 => 中间操作 => 终端操作 => 结果

诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。

中间操作

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

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

distinct: 去除重复元素

limit(n): 获取 n 个元素

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

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

终端操作

forEach: 遍历流中的元素

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

Min:返回流中元素最小值

Max:返回流中元素最大值

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

Reduce:所有元素求和

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

回 true，否则返回 false

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

回 true，否则返回 false

findFirst：返回流中第一个元素

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

//代码演示1
package com.ffyc.stream;

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        Integer[] integers={4,3,6,2,5,1,8,4,2,7};
        Arrays.stream(integers)
                .distinct()//去重{4,3,6,2,5,1,8,7}
                .filter((e)->{
                    return e<8;
                })//过滤
                .sorted((e,g)->{//或者这么写sorted()就行了
                    return e-g;
                })//排序{1,2,3,4,5,6,7,8}
                .limit(6)//获取n个元素{1,2,3,4,5,6}
                .skip(2)//跳过n个元素{3,4,5,6}
                .forEach((e)->{//遍历
                    System.out.println(e);
                });
    }
}

//代码演示2
package com.ffyc.stream;

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

public class Demo2 {
    public static void main(String[] args) {
        Integer[] integers={4,3,6,2,5,1,8,4,2,7};
        Integer max=Arrays.stream(integers)
                .distinct()//去重{4,3,6,2,5,1,8,7}
                .max((a,b)->{return  a-b;})//获取最大值
                .get();
        System.out.println(max);
        Integer min=Arrays.stream(integers)
                .distinct()//去重{4,3,6,2,5,1,8,7}
                .min((a,b)->{return  a-b;})//获取最小值
                .get();
        System.out.println(min);

        Object[] objects=Arrays.stream(integers)
                .distinct()
                .toArray();//将流中的元素倒入一个数组
        System.out.println(Arrays.toString(objects));
        long count=Arrays.stream(integers)
                        .distinct()
                        .count();//返回流中元素的总个数
        System.out.println(count);
        Integer sum=Arrays.stream(integers)
                .distinct()
                .reduce((a,b)->{return  a+b;})//所有元素求和
                .get();
        System.out.println(sum);
        boolean falg=Arrays.stream(integers)
                .distinct()
                .anyMatch((e)->{return e<5;});//接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false
        System.out.println(falg);
        boolean falg1=Arrays.stream(integers)
                .distinct()
                .allMatch((e)->{return e<5;});//接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
        System.out.println(falg1);
        Integer first=Arrays.stream(integers)
                .distinct()
                .findFirst()//返回流中第一个元素
                .get();
        System.out.println(first);
        Set<Integer> set=Arrays.stream(integers)
                .collect(Collectors.toSet());//将流中的元素倒入一个集合,Collection 或 Map
        System.out.println(set);
    }
}

//代码演示3
package com.ffyc.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class Demo3 {
    /*
       Stream 流 是java8推出的新功能,  与IO流完全不同的.
       提供了对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该做什么.

       java中的集合,数组主要是存储数据,而Stream主要作用是对集合进行操作.
             获取流             流的中间操作                   终端操作
       数据集合-->Stream-->filter-->Stream-->sorted-->流-->tolist/sum/max--->result

       就是一个对集合进行遍历操作的高级迭代器.
     */

       //获取流   中间操作 终端操作
    public static void main(String[] args) {

        Car car1=new Car(101,"宝马1","红色");
        Car car2=new Car(102,"宝马2","黑色");
        Car car3=new Car(103,"宝马3","蓝色");
        Car car4=new Car(104,"宝马4","白色");
        Car car5=new Car(105,"宝马5","绿色");

        Car[] cars = {car1,car2,car3,car4,car5};

     List<Car> listcar =   Arrays.stream(cars)
                       .sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
                       .filter((c)->{ return c.getColor().equals("红色");})
                       .collect(Collectors.toList());
        System.out.println(listcar);

       /* Set<Car> setcar =   Arrays.stream(cars)
                .sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
                .collect(Collectors.toSet());
        System.out.println(setcar);*/

     Map<Integer,String> carmap =  Arrays.stream(cars)
                .sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
                .collect(Collectors.toMap(Car::getNum, Car::getColor));
        System.out.println(carmap);

      List<Integer> listnum =  Arrays.stream(cars)
              .map(Car::getNum)//将其映射成一个新的元素
              .collect(Collectors.toList());
        System.out.println(listnum);




    }
}

//Car类
package com.ffyc.stream;

public class Car {

     private int num;
     private String name;
     private String color;

    public Car(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public Car(int num, String name, String color) {
        this.num = num;
        this.name = name;
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}