目录

Lambda表达式

Lambda表达式的由来

Lambda表达式简介

Lambda表达式的结构

Stream流

什么是Stream流？

什么是流呢？

Stream流操作

中间操作

终端操作

---

Lambda表达式

Lambda表达式的由来

Java是面向对象语言，除了部分简单数据类型，Java中的一切都是对象，即使数组也是一种对象。

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

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

简而言之，在Java里将普通的方法像参数一样传值并不简单，为此，Java8增加了一个语言级的新特性，名为Lambda表达式。

Lambda表达式简介

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

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

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

Lambda表达式的结构

• Lambda表达式可以具有零个，一个或多个参数。
• 可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。例如：(int a,int b)与(a,b)相同。
• 参数用小括号括起来，用逗号分隔。例如(a,b)或(int a,int b)或(String a,int b,float c)。
• 空括号用于表示一组空的参数。例如：()->42。
• 当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。例如：a->returna*a
• Lambda表达式的正文可以包含零条，一条或多条语句。
• 如果Lambda表达式的正文只有一条语句，则大括号可不用写，且表达式的返回值类型要与匿名函数的返回类型相同。
• 如果Lambda表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。

import javax.swing.*;
import java.util.ArrayList;public class lambda {public static void main(String[] args) {ArrayList<String> arrayList = new ArrayList<>();arrayList.add("a");arrayList.add("b");arrayList.add("c");//当排序时，需要定义排序规则//arrayList.sort(new StringComparator());arrayList.sort((a, b) -> {//用Lambda表达式实现return a.compareTo(b);});//匿名内部类， 为了减少类的创建//此处功能核心compareTo方法，但是java是面向对象的,方法是不能独立的存在的,必须将方法包装在对象中/* arrayList.sort(new Comparator<string>(){@Overridepublic int compare(string ol, string o2){return o1.compareTo(o2);}});*/System.out.println(arrayList);//集合遍历arrayList.forEach((e)->{//用Lambda表达式实现System.out.println(e);});}
}

Stream流

什么是Stream流？

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

此外与stream与lambada表达示结合后编码效率与大大提高，并且可读性更强。

要澄清的是java8中的stream 与 InputStream 和 OutputStream 是完全不同的概念。

什么是流呢？

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

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

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

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

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

Stream流操作

简单来说就是：

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

1、获取流，把集合/数组转为Stream对象

package De;import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;public class Demo1 {public static void main(String[] args) {//1、将集合转为流ArrayList<Integer> arrayList=new ArrayList<>();arrayList.add(1);arrayList.add(2);arrayList.add(3);arrayList.add(4);Stream<Integer> stream=arrayList.stream();//将集合转为流//2、将数组转为流Integer[] array=new Integer[]{1,2,3,4};Stream<Integer> stream1= Arrays.stream(array);//把数组转为流//3、调用Stream.of方法转为流Stream stream2=Stream.of(1,2,3,4,5);}
}

2、经过流操作

流的操作分为：中间操作: 流的各种数据处理终端操作: 把流转为最终结果(数组/集合/单值)

中间操作

filter：过滤流中的某些元素
sorted()：自然排序，流中元素需实现 Comparable 按口
distinct： 去除重复元素
limit(n)：获取 n 个元素
skip(n)：跳过n元素，配台limit(n)可实现分页
map:将对象中某个属性的值映射到一个新集合中

public static void main(String[] args) {Integer[] array=new Integer[]{1,2,3,4};Arrays.stream(array).skip(1)//跳过指定数量个元素.limit(2)//取出指定数量个元素.forEach((e) ->{System.out.println(e);});System.out.println("------");Arrays.stream(array).filter((e)->{//过滤return e>0;}).sorted((o1, o2) -> {return o2-o1;}).distinct()//去重.forEach((e)->{System.out.println(e);});}

 

终端操作

把流转为最终结果(数组/集合/单值)

Min:返回流中元素最小值
Max:返回流中元素最大值
count:返回流中元素的总个数
Reduce:所有元素求和
anyMatch:按收一个 Predicate 函数，只要流中有一个元素满足条件则返true，否则返回 false
allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返true，否则返回 false
findFirst:返回流中第一个元素

package De;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Demo2 {public static void main(String[] args) {Integer[] array=new Integer[]{1,2,3,4,4,5,6};//Min:返回流中元素最小值Integer min=Arrays.stream(array).distinct().min((o1, o2) -> {return o1-o2;}).get();System.out.println(min);//Max:返回流中元素最大值Integer max=Arrays.stream(array).distinct().max((o1, o2) -> {return o1-o2;}).get();System.out.println(max);//count:返回流中元素的总个数long count=Arrays.stream(array).distinct().count();System.out.println(count);//Reduce:所有元素求和long sum=Arrays.stream(array).distinct().reduce((o1, o2) -> {return o1+o2;}).get();System.out.println(sum);//anyMatch:按收一个 Predicate 函数，只要流中有一个元素满足条件则返true，否则返回 falseboolean result1=Arrays.stream(array).distinct().anyMatch((e)->{return e>4;});System.out.println(result1);// allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返true，否则返回 falseboolean result=Arrays.stream(array).distinct().allMatch((e)->{return e>4;});System.out.println(result);//findFirst:返回流中第一个元素Integer res=Arrays.stream(array).distinct().findFirst().get();System.out.println(res);}
}

如果对于一个对象而言，同样也适用。

public class Demo2 {public static void main(String[] args) {student s1=new student(101,"张三",20);student s2=new student(102,"李四",21);student s3=new student(103,"王五",22);student s4=new student(104,"老刘",20);student s5=new student(105,"杨一",24);ArrayList<student> students=new ArrayList<>();students.add(s1);students.add(s2);students.add(s3);students.add(s4);students.add(s5);//sorted()：自然排序，流中元素需实现 Comparable 按口List<student> students1=students.stream().sorted((s,y)->{return s.getNum()-y.getNum();}).collect(Collectors.toList());System.out.println(students1);//filter：过滤流中的某些元素List<student> students2=students.stream().filter((s)->{return s.getAge()>22;}).collect(Collectors.toList());System.out.println(students2);// map:将对象中某个属性的值映射到一个新集合中Object[] array1=students.stream().map(student::getNum).toArray();System.out.println(Arrays.toString(array1));//List list=students.stream().map(student::getNum)//)//将对象中某个属性的值映射到一个新集合中.collect(Collectors.toList());System.out.println(list);
}
}