java8lambda表达式

一.出现的背景

java是一个面向对象的语言,  java中的很多都是面向对象的语言,它里面定义的函数和方法都不可以向参数一样传递,必须包装起来才可以进行传递,java8之前都有一直在使用匿名内部类的方法,所以增加了一种Lambda表达式的方法

二.概念

Lambda 表达式是一个匿名函数，也就是一段可以传递的代码（将代码段像数据一样传递）。

"语法糖":简单来说就是让语言更加简单,对它的功能并不影响

三.结构

Arrays.sort(cars,(o1,o2)->{//这里o1和o2不需要机子定义类型,因为java语言为机子推断

            return o1.getNum()-o2.getNum();
        });

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 表达式的正文有一条以上的语句必须包含在大括号（代码块）

中，且表达式的返回值类型要与匿名函数的返回类型相同

注意:目前可以先不管那么多写法上的规则,就老老实实的按上面代码块找那个的那种够写法写,肯定错不了

四.功能接口Functional interface

代码实现:

@FunctionalInterface  //表示一个功能函数接口,接口中只能定义一个抽象方法
public interface Oper {
    int add(int a,int b);
//使用Lambda表达式中,只能有一个抽象方法,因为要进行类型推断
   // void show1();
}

五,什么是Stream

Stream:可以把它看作是遍历数据集的高级迭代器,它允许你以声明式的方式处理数据集合。

 java8 中的 stream 与 IO流中的是完全不同的概念

 ArrayList<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(3);
        list.add(2);
        list.add(1);
        list.add(6);
        list.add(3);
        /*list.stream()//获取流对象

流:

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

获取流:

list.stream()

stream.of

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

数据处理操作 :进行 数据处理和计算，比如 filter、map、find、sort 等。

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

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

 ArrayList<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(3);
        list.add(2);
        list.add(1);
        list.add(6);
        list.add(3);
        /*list.stream()//获取流对象
                .distinct()//去重
         .filter((e)->{return e<4;})//对流对象过滤操作,继续返回一个流对象
                .sorted((a,b)->{return a-b;})//排序操作
                .limit(2)//限制取出的个数
                .skip(1)//跳过指定的数量
                .forEach((e)->{//遍历输出
                    System.out.println(e);
                });*/

流操作

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

中间操作:

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

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

distinct: 去除重复元素

limit(n): 获取 n 个元素

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

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

  .distinct()//去重
         .filter((e)->{return e<4;})//对流对象过滤操作,继续返回一个流对象
                .sorted((a,b)->{return a-b;})//排序操作
                .limit(2)//限制取出的个数
                .skip(1)//跳过指定的数量
                .forEach((e)->{//遍历输出

终端操作:

forEach: 遍历流中的元素

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

Min:返回流中元素最小值

Max:返回流中元素最大值

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

Reduce:所有元素求和

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

回 true，否则返回 false

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

回 true，否则返回 false

findFirst：返回流中第一个元素

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

以一个Car为例:

 

public class streamdemo2 {
    public static void main(String[] args) {
        Car car1 = new Car("宝马1", 1,"红色");
        Car car2 = new Car("宝马2", 2,"蓝色");
        Car car3 = new Car("宝马3", 3,"黑色");
        Car car4 = new Car("宝马4", 4,"白色");

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

        List<Car> list = Arrays.stream(cars)//to set 没有重复的集合
                .sorted((a,b)->{return a.getNum()-b.getNum();})
                .filter((e)->{return e.getColor().equals("蓝色");})
                .collect(Collectors.toList());//将其存到集合中
        System.out.println(list);

        Map<Integer,String> map = Arrays.stream(cars)
                .sorted((a,b)->{return a.getNum()-b.getNum();})
        .collect(Collectors.toMap(Car::getNum,Car::getName));
        System.out.println(map);

        List<Integer> list1  = Arrays.stream(cars)
                .map(Car::getNum)
                .collect(Collectors.toList());//将对象中的元素取出来
        System.out.println(list1);也可以存到set集合中,没有冲阿福元素
    }
}