目录
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>(){
@Override
public 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，否则返回 false
boolean result1=Arrays.stream(array)
.distinct().anyMatch((e)->{
return e>4;
});
System.out.println(result1);
// allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返true，否则返回 false
boolean 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);
}
}
