Lambda表达式
-
出现的背景
Java 是一流的面向对象语言，除了部分简单数据类型，Java 中的一切都是 对象，即使数组也是一种对象，每个类创建的实例也是对象。在 Java 中定义的函数或方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。
在 Java 8 以前，若我们想要把某些功能传递给某个方法，总要去写匿名类，例：
/*为了对集合集合进行排序，我们为 Comparator 接口创建 了一个它的匿名内部类对象，重写接口中的方法,来实现排序功能.*/
list.sort(new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
return o1.getId()-o2.getId();
}
}
在 Java 里将普通的方法或函数像参数一样传值并不简单，为此， Java 8 增加了一个语言级的新特性，名为Lambda 表达式。
Lambda表达式简介
- Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段 可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵 活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。
- Java 中的 Lambda 表达式通常使用 (argument) -> {body}语法书写，例如：
/*左侧：lambda 表达式的参数列表
右侧：lambda 表达式中需要执行的功能，即 lambda 体
(arg1, arg2...) -> { body }
(type1 arg1, type2 arg2...) -> { body }*/
//以下是一些 Lambda 表达式的例子：
public class LambdaInterfaceDemo {
public static void main(String[] args) {
/*
Lambda表达式本质是一个 ”语法糖“ 可以简化代码，让程序员可以用更少的语句实现相同的功能
思想是把函数当作参数一样传递
当接口中只有一个抽象方法时，才可以用Lambda表达式，否责无法推断是哪一个方法
*/
// LambdaInterface lambdaInterface = ()->{//无参数，无返回值
// System.out.println("test");
// };
// int b=10;
// LambdaInterface lambdaInterface = (a)->{//有一个参数，无返回值
// System.out.println("test"+a);
// };
int a1=10,a2=20;
LambdaInterface lambdaInterface=(a,b)->{//有多个参数，但是不用写参数类型，jvm会自动推断
return a+b;
};
System.out.println("a1+a2="+lambdaInterface.test(a1,a2));
}
}
Lambda 表达式的结构
- Lambda 表达式可以具有零个，一个或多个参数。
- 可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。例如 (int a,int b)与 (a,b)相同。
- 参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。、
- 空括号用于表示一组空的参数。例如 () -> 1。
- 当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。例如 a -> return a*a。
- Lambda 表达式的正文可以包含零条，一条或多条语句。
- 如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式的返回值类型要与匿名函数的返回类型相同。
- 如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。
什么是功能接口（Functional interface）
- Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽 象方法接口。Java 8 也引入了一个注释，@FunctionalInterface，当你注释 的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。
//以下是自定义功能接口的示例：
@FunctionalInterface// 可以用Lambda表达式的功能接口 标签
public interface LambdaInterface {
int test(int a,int b);//被上面标签标记的接口只能有一个抽象方法，否则会编译错误
// void test1();
}
Lambda 表达式的例子
public class Demo {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
arrayList.add("s");
arrayList.add("g");
arrayList.add("w");
// arrayList.sort(new Comparator<String>() {
// @Override
// public int compare(String o1, String o2) {
// return o1.compareTo(o2);
// }
// });//排序匿名内部类写法
arrayList.sort((o1,o2)->{return o1.compareTo(o2);});//排序Lambda表达式写法
System.out.println(arrayList);//[a, g, s, w]
// arrayList.forEach(new Consumer<String>() {//遍历匿名内部类写法
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
arrayList.forEach((e)->{System.out.println(e);});//遍历Lambda写法
/*
结果：
a
g
s
w
*/
}
}
Stream流
什么是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 循环）。
同时可以将这些操作链接起来，达到一种流水线式的效果：
什么是流呢？
-
简单定义：从支持数据处理操作的源,生成的元素序列
-
元素列表：和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。
-
数据源：获取数据的源，比如集合。
-
数据处理操作：流更偏向于数据处理和计算，比如 filter、map、find、sort 等。 简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。
例：
Integer[] integers = {6, 8, 3, 4, 4, 1, 5, 2, 2};
Stream<Integer> stream1 = Arrays.stream(integers);
List<Integer> list = stream1
.sorted((o1,o2)->{ return o2-o1; })//o2-o1倒序,o1-o2正序 排序
.distinct()//去重复元素
.skip(2)//从0开始跳过两个元素
.limit(4)//限制获取到的元素个数
.collect(Collectors.toList());//返回我们所需的集合类型
获取流
- 使用 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()
List<Integer> alist = Stream
.of(1,2,3,4,5,6,7)//参数类型是可变参数
.filter((e)->{return e>1;})//过滤，拿到满足条件的元素
.collect(Collectors.toList());//把流转换为集合赋给alist
System.out.println(alist);//[2, 3, 4, 5, 6, 7]
流操作
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
代码示例：
public class Demo {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("abcde");
arrayList.add("bcdef");
arrayList.add("oajfd");
arrayList.add("pwfds");
arrayList.add("kkpoi");
Stream<String> stream = arrayList.stream();//创建流对象，将集合中的元素存放到Stream流对象中
System.out.println();
stream
.filter((e)->{return e.contains("kk");})//中间操作，返回Stream对象
.forEach((e1)-> System.out.println(e1) );//终端操作，返回我们想要的结果
//map中间操作 例：
ArrayList<Apple> arrayList1 = new ArrayList<>();
arrayList1.add(new Apple("red",101,500));
arrayList1.add(new Apple("red",102,800));
arrayList1.add(new Apple("yellow",103,550));
arrayList1.add(new Apple("red",104,600));
arrayList1.add(new Apple("green",105,400));
Stream<Apple> stream2 = arrayList1.stream();
stream2
.map(Apple::getNum)//把Color映射成Num，然后返回流对象遍历输出
.forEach(e-> System.out.println(e));//遍历输出
/*
结果：
101
102
103
104
105 */
//map终端操作 例：
Stream<Apple> stream3 = arrayList1.stream();
Map<Integer,String> mapApple= stream3
.filter(e->{return e.getColor().equals("red");})
.collect(Collectors.toMap(Apple::getNum,Apple::getColor));
System.out.println(mapApple);
/*
结果：{101=red, 102=red, 104=red}
*/
}
}
604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
