Lambda 和 Stream

目录

一、 Lambda 表达式

1.1.出现的背景

1.2表达式简介

1.3表达式的结构

二、Stream流

2.1什么是 Stream？

2.2获取流

2.3流操作

2.3.1中间操作

2.3.2终端操作

 

---

一、 Lambda 表达式

1.1.出现的背景

Java 是面向对象语言，除了部分简单数据类型，Java 中的一切都是对象，即使数组也是一种对象。在 Java 中定义的方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。

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

代码示例：

list.sort(new Comparator<User>() {
//使用匿名内部类 来重写compare()方法，进而实现排序功能。
@Override
public int compare(User o1, User o2) {
return o1.getId()-o2.getId();
}
}

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

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

Java 8

增加了一个语言级的新特性，名为 Lambda

1.2表达式简介

Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。

使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。

Lambda 表达式的本质只是一个 "语法糖" ,由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。

1.3表达式的结构

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 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。

注意：

Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽象方法接口。Java 8 也引入了一个注释，即@FunctionalInterface，

当你注释的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误

public class Demo {
    public static void main(String[] args) {
        Student student1 = new Student(101,"jim1", "男");
        Student student2 = new Student(102,"jim2", "男");
        Student student3 = new Student(103,"jim3", "男");
        Student student4 = new Student(104,"jim4", "男");
        Student[] students = new Student[4];
        students[0] = student2;
        students[1] = student4;
        students[2] = student1;
        students[3] = student3;
        Arrays.sort(students,(o1,o2)->{
            return o1.getNum()-o2.getNum();
        });
        System.out.println(Arrays.toString(students));
    }
}

二、Stream流

2.1什么是 Stream？

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把

它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后

编码效率与大大提高，并且可读性更强

 

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

2.2获取流

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

2.3流操作

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

List<Apple> apples = applestore .stream()               获得流

.filter(a -> a.getColor().equals("red"))                      中间操作

.collect(Collectors.toList());                                     终端操作

2.3.1中间操作

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

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

distinct: 去除重复元素

limit(n): 获取 n 个元素

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

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

public class StreamDemo1 {
    public static void main(String[] args) {
        Stream.of(2,3,5,4,1,6,3)//获取流 
                .distinct()//去掉相同的元素
                .sorted()//对流进行排序
                .filter((a)->{//去除不满足条件的元素
                    return a>2;
                }).skip(2) //跳过两个元素
                .limit(1)  //只读取一个元素
                .forEach((e)->{//将每个元素遍历出来
                    System.out.println(e);
                });
    }
}

2.3.2终端操作

forEach: 遍历流中的元素

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

Min:返回流中元素最小值

Max:返回流中元素最大值

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

Reduce:所有元素求和

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

回 true，否则返回 false

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

回 true，否则返回 false

findFirst：返回流中第一个元素

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

public class StreamDemo2 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList<Integer>(5);
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
      Integer i=  arrayList.stream().max((a,b)->{//返回流中的最大值
            return a-b;
        }).get();
        System.out.println(i);
        long a=  arrayList.stream().count();//返回流中的个数
        System.out.println(a);
        Integer b=  arrayList.stream().reduce((m,n)->{//返回所有元素的和
            return m+n;
        }).get();
        System.out.println(b);
       boolean flag =arrayList.stream().anyMatch((z)->{//只要有一个满足条件就返回true
            return z>3;
        });
        System.out.println(flag);
    }
}