Lambda表达式
面向对象过分强调“必须通过对象的形式来做事情”,而函数式思想则尽量忽略面向对象的复杂语法——强调做什么,而不是以什么形式做。
本质是匿名内部类的简化书写格式
标准格式
- 一些参数
- 一个箭头
- 一段代码
Lambda表达式的标准格式为:
(参数类型 参数名称) -> { 代码语句 }
格式说明
- 小括号内的语法与传统方法参数列表一致:无参数则留空;多个参数则用逗号分隔。
- -> 是新引入的语法格式,代表指向动作。
- 大括号内的语法与传统方法体要求基本一致。
省略格式
省略规则
在Lambda标准格式的基础上,使用省略写法的规则为:
- 小括号内参数的类型可以省略;
- 如果小括号内有且仅有一个参,则小括号可以省略;
- 如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号、return关键字及语句分号。
备注:掌握这些省略规则后,请对应地回顾本章开头的多线程案例。
可推导即可省略
Lambda的前提条件
- 使用Lambda必须具有接口,且要求接口中有且仅有一个抽象方法。
无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口,只有当接口中的抽象方法存在且唯一
时,才可以使用Lambda。 - 使用Lambda必须具有接口作为方法参数。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。
备注
有且仅有一个抽象方法的接口,称为“函数式接口”。
函数式接口
函数式接口在Java中是指:有且仅有一个抽象方法的接口。
函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可
以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。
备注:
从应用层面来讲,Java中的Lambda可以看做是匿名内部类的简化格式,但是二者在原理上不同。
格式
只要确保接口中有且仅有一个抽象方法即可:
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}
由于接口当中抽象方法的 public abstract 是可以省略的,所以定义一个函数式接口很简单:
public interface MyFunctionalInterface {
void myMethod();
}
自定义函数式接口
对于刚刚定义好的 MyFunctionalInterface
函数式接口,典型使用场景就是作为方法的参数:
public class Demo07FunctionalInterface {
// 使用自定义的函数式接口作为方法参数
private static void doSomething(MyFunctionalInterface inter) {
inter.myMethod(); // 调用自定义的函数式接口方法
}
public static void main(String[] args) {
// 调用使用函数式接口的方法
doSomething(() -> System.out.println("Lambda执行啦!"));
}
}
FunctionalInterface注解
与 @Override
注解的作用类似,Java 8中专门为函数式接口引入了一个新的注解: @FunctionalInterface
。该注
解可用于一个接口的定义上:
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。不过,
即使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。
常用函数式接口
JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景,它们主要在 java.util.function 包中被提供。
Consumer接口
java.util.function.Consumer<T>
接口,是消费一个数据,其数据类型由泛型参数决定。
抽象方法
accept
:Consumer 接口中包含抽象方法 void accept(T t)
: 消费一个指定泛型的数据
//给你一个字符串,请按照大写的方式进行消费
import java.util.function.Consumer;
public class Demo08Consumer {
public static void main(String[] args) {
String str = "Hello World";
//1.lambda表达式标准格式
fun(str,(String s)->{
System.out.println(s.toUpperCase());
});
//2.lambda表达式简化格式
fun(str,s-> System.out.println(s.toUpperCase()));
}
/*
定义方法,使用Consumer接口作为参数
fun方法: 消费一个String类型的变量
*/
public static void fun(String s,Consumer<String> con) {
con.accept(s);
}
}
Predicate接口
有时候我们需要对某种类型的数据进行判断,从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T>
接口。
抽象方法:test
Predicate
接口中包含一个抽象方法: boolean test(T t)
。用于条件判断的场景:
//1.练习:判断字符串长度是否大于5
//2.练习:判断字符串是否包含"H"
public class Demo09Predicate {
private static void method(Predicate<String> predicate,String str) {
boolean veryLong = predicate.test(str);
System.out.println("字符串很长吗:" + veryLong);
}
public static void main(String[] args) {
method(s -> s.length() > 5, "HelloWorld");
}
}
条件判断的标准是传入的Lambda表达式逻辑,只要字符串长度大于5则认为很长。总结来说,就是用这个接口作为方法的一个参数,用lambda表达式可以直接将接口中的方法实现。
Stream流
在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的
弊端。
获取流方式
java.util.stream.Stream<T>
是Java 8新加入的最常用的流接口。
获取一个流非常简单,有以下几种常用的方式:
- 所有的 Collection 集合都可以通过 stream 默认方法获取流;
- Stream 接口的静态方法 of 可以获取数组对应的流。
方式1 : 根据Collection获取流
首先, java.util.Collection
接口中加入了default
方法 stream
用来获取流,所以其所有实现类均可获取流。
java.util.Collection
默认方法: 必须由Collection接口的实现类(ArrayList/LinkedList/HashSet/LinkedHashSet)对象调用
public default Stream<T> stream(): 获取Collection集合对象对应的Stream流对象
方式2: 根据数组获取流
如果使用的不是集合或映射而是数组,由于数组对象不可能添加默认方法,所以 Stream 接口中提供了静态方法of
java.util.stream.Stream
静态方法
public static <T> Stream<T> of(T ... t): 把方法的可变参数指定的具体数据,转换成Stream流对象
参数:
T ... t: 可变参数 传递数组,参数列表,不传递
public class Demo05GetStream {
public static void main(String[] args) {
//获取List集合的Stream对象
List<String> list = new ArrayList<>();
Stream<String> s1 = list.stream();
System.out.println(s1);
//获取Set集合的Stream对象
Set<Integer> set = new HashSet<>();
Stream<Integer> s2 = set.stream();
System.out.println(s2);
Map<String,String> map = new HashMap<>();
//Map键的Set集合
Set<String> set2 = map.keySet();
Stream<String> s3 = set2.stream();
System.out.println(s3);
//Map值的Collection集合
Collection<String> coll = map.values();
Stream<String> s4 = coll.stream();
System.out.println(s4);
//Map键值对的Set集合
Set<Map.Entry<String, String>> set3 = map.entrySet();
Stream<Map.Entry<String, String>> s5 = set3.stream();
System.out.println(s5);
System.out.println("----------");
String[] arr = {"Hello","World","java"};
Stream<String> s6 = Stream.of(arr);
System.out.println(s6);
Stream<String> s7 = Stream.of("Hello", "World", "java");
System.out.println(s7);
}
}
备注: of 方法的参数其实是一个可变参数,所以支持数组。
常用方法
流模型的操作很丰富,下面是一些常用的API。这些方法可以被分成两种:
- 终结方法:返回值类型不再是 Stream 接口自身类型的方法,因此不再支持类似 StringBuilder 那样的链式调
用。本小节中,终结方法包括 count 和 forEach 方法。 - 非终结方法:返回值类型仍然是 Stream 接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余
方法均为非终结方法。)
forEach : 逐一处理
虽然方法名字叫 forEach ,但是与for循环中的“for-each”昵称不同,该方法并不保证元素的逐一消费动作在流中是
被有序执行的。
void forEach(Consumer<? super T> action);
该方法接收一个 Consumer 接口函数,会将每一个流元素交给该函数进行处理。例如:
import java.util.stream.Stream;
public class Demo15StreamForEach {
public static void main(String[] args) {
Stream<String> stream = Stream.of("大娃","二娃","三娃","四娃","五娃","六娃","七娃","爷
爷","蛇精","蝎子精");
//Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
stream.forEach((String str)->{System.out.println(str);});
}
}
注意,上方代码注释的原因是stream流只能被使用一次,不能循环使用
filter:过滤
可以通过 filter 方法将一个流转换成另一个子集流。方法声明:
Stream<T> filter(Predicate<? super T> predicate);
该接口接收一个 Predicate 函数式接口参数(可以是一个Lambda)作为筛选条件。
基本使用
Stream流中的 filter 方法基本使用的代码如:
public class Demo16StreamFilter {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
}
}
count:统计个数
正如旧集合 Collection 当中的 size 方法一样,流提供 count 方法来数一数其中的元素个数:
public class Demo16StreamFilter {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
System.out.println(result.count()); // 2
}
}
limit:取用前几个
limit 方法可以对流进行截取,只取用前n个。
Stream<T> limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象
参数是一个long型,如果集合当前长度大于参数则进行截取;否则不进行操作。
import java.util.stream.Stream;
public class Demo18StreamLimit {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.limit(2);
System.out.println(result.count()); // 2
}
}
skip:跳过前几个
如果希望跳过前几个元素,可以使用 skip 方法获取一个截取之后的新流
Stream<T> skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象
如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。基本使用:
import java.util.stream.Stream;
public class Demo19StreamSkip {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.skip(2);
System.out.println(result.count()); // 1
}
}
concat:组合
如果有两个流,希望合并成为一个流,那么可以使用 Stream 接口的静态方法 concat :
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b): 把参数列表中的两个
Stream流对象a和b,合并成一个新的Stream流对象
备注:这是一个静态方法,与 java.lang.String 当中的 concat 方法是不同的。
该方法的基本使用代码如:
import java.util.stream.Stream;
public class Demo20StreamConcat {
public static void main(String[] args) {
Stream<String> streamA = Stream.of("张无忌");
Stream<String> streamB = Stream.of("张翠山");
Stream<String> result = Stream.concat(streamA, streamB);
}
}