Java基础回顾系列-第三天-Lambda表达式
该篇博文需重点了解：内建函数式接口
该篇博文需重点了解：内建函数式接口
该篇博文需重点了解：内建函数式接口
Lambda表达式
Lambda表达式的主要目的替换只有一个抽象方法的匿名内部类。
一个简单的类：
package javase.util;
interface IMessage {
void say(String str);
}
public class LambdaTest {
public static void main(String[] args) {
IMessage message = new IMessage() {
@Override
public void say(String str) {
System.out.println("消息发出:"+ str);
}
};
message.say("你好");
}
}
采用Lamdba表达式写法：
package javase.util;
@FunctionalInterface
interface IMessage {
// 只能有一个方法，这样的方法叫做函数式接口，注解@FunctionalInterface定义在接口上。
void say(String str);
}
public class LambdaTest {
public static void main(String[] args) {
// 针对有参数的情况
IMessage message = (str)->{
System.out.println("消息发出:"+ str);
};
message.say("你好");
}
}
Lambda方法的条件：符合函数式接口的接口
- 方法没有参数：
()->{语句}- 方法有参数：
(parm1, parm2,parm...)->{语句}- 如果只有一行语句返回：
(parm1, parm2,parm...)->语句
示例：有返回值的函数式接口Lambda实现
package javase.util;
@FunctionalInterface
interface IMessage {
String call();
}
public class LambdaTest {
public static void main(String[] args) {
IMessage message = ()->{
return "你好";
};
// 简化写法： IMessage message = ()->"你好";
System.out.println(message.call());
}
}
方法引用
不同的方法描述可以描述同一个方法。弥补了对引用的支持功能。
- 引用静态方法：类名称 :: 方法名称
- 引用某个实例化对象的方法：实例化对象 :: 普通方法
- 引用特定类型的方法：特定类 :: 普通方法
- 引用构造方法：类名称 :: new
引用静态方法
如引用String.valueOf(int i)方法
package javase.util;
// P描述的是参数，R描述的是返回值
@FunctionalInterface
interface IFunction<P,R> {
// 转换
public R change(P p);
}
public class LambdaTest {
public static void main(String[] args) {
// 引用静态方法
IFunction<Integer, String> function = String :: valueOf;
String change = function.change(100);
System.out.println(change);
}
}
利用方法引用这一概念可以为一个方法定义多个名字，但必须满足函数式接口。
引用实例化对象的方法
如引用字符串实例对象.toUpperCase()方法
package javase.util;
// R描述的是返回值
@FunctionalInterface
interface IFunction<R> {
// 转换
public R upper();
}
public class LambdaTest {
public static void main(String[] args) {
// 引用静态方法
IFunction<String> function = "Lambda" :: toUpperCase;
String upper = function.upper();
System.out.println(upper);
}
}
引用特定类型的方法
如String.compareTo(String anotherString)
package javase.util;
@FunctionalInterface
interface IFunction<P> {
// 转换
public int compare(P p1, P p2);
}
public class LambdaTest {
public static void main(String[] args) {
// 引用静态方法
IFunction<String> function = String :: compareTo;
int compare = function.compare("A", "a");// 32
System.out.println(compare);
}
}
引用构造方法
package javase.util;
@FunctionalInterface
interface IFunction<R> {
// 转换
public R create(String name, int age);
}
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return this.name+"=="+this.age;
}
}
public class LambdaTest {
public static void main(String[] args) {
// 引用静态方法
IFunction<Person> function = Person :: new;
Person person = function.create("张三", 12);
System.out.println(person);
}
}
内建函数式接口
参见：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/package-summary.html
| 接口 | 说明 |
|---|---|
Interface Function<T,R> | 输入参数且返回结果 |
Interface Consumer<T> | 输入参数但不返回结果 |
Interface Supplier<T> | 提供输入型函数接口，boolean |
Interface Predicate<T> | 断言型接口 |
注：以上接口泛型
T表示传入参数；泛型R表示输出结果(返回值)。
java.util.function开发包提供了功能接口为lambda表达式和方法引用提供目标类型。 每个功能接口都有一个抽象方法，称为该功能接口的功能方法，lambda表达式的参数和返回类型与之匹配或匹配。功能接口可以在多个上下文中提供目标类型，例如赋值上下文，方法调用或强制转换上下文：
// Assignment context
Predicate<String> p = String::isEmpty;
// Method invocation context
stream.filter(e -> e.getSize() > 10)...
// Cast context
stream.map((ToIntFunction) e -> e.getSize())...
Function基础接口
@FunctionalInterface
public interface Function<T,R>
此接口需接收一个值以及返回一个值。
R apply(T t) // 应用
package javase.util;
import java.util.function.Function;
public class LambdaTest {
public static void main(String[] args) {
// 使用String.startsWith(String str) 判断字符串是否以指定字符开头
Function<String, Boolean> function = "**Hello" :: startsWith;
// 执行
Boolean startsWith = function.apply("**");
System.out.println(startsWith);
}
}
DoubleToIntFunction 类型转换接口
@FunctionalInterface
public interface DoubleToIntFunction
Consumer消费型函数式接口
只能进行数据处理操作，而没有任何返回。
对类型为T的对象应用操作，包含方法：void accept(T t)
package javase.util;
import java.util.function.Consumer;
import java.util.function.Function;
public class LambdaTest {
public static void main(String[] args) {
Consumer consumer = System.out :: println;
consumer.accept("只输出，无返回");
}
}
Supplier供给型函数式接口
返回类型为T的对象，包含方法：
T get()
package javase.util;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
public class LambdaTest {
public static void main(String[] args) {
Supplier<String> supplier = "LAMBDA" :: toLowerCase;// 转小写
String s = supplier.get();// 获取
System.out.println(s);
}
}
Predicate断言型函数式接口
确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法：
boolean test(T t)
package javase.util;
import java.util.function.Predicate;
public class LambdaTest {
public static void main(String[] args) {
Predicate<String> predicate = "java" :: equalsIgnoreCase;
boolean test = predicate.test("JAVA"); // 断言
System.out.println(test);
}
}
Stream API
Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。
package javase.util;
import java.util.*;
import java.util.stream.Stream;
/**
* Stream API
*/
public class JavaAPIDemo {
public static void main(String[] args) {
// 创建 Stream方式一：通过集合
List<String> list = new LinkedList<>();
// 返回一个顺序流
Stream<String> stream = list.stream();
// 返回一个并行流
Stream<String> stringStream = list.parallelStream();
// 创建 Stream方式二：通过Arrays数组
Stream<String> stream1 = Arrays.stream(new String[]{"中", "国", "要", "强", "大"});
// 创建 Stream方式三：通过Stream的of()
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
// 创建 Stream方式四：创建无限流（不常用，一般用于生成数据时）
// 迭代：产生规律的数据，从0一直累加2一直输出，可使用limit限制记录数
Stream<Integer> iterate = Stream.iterate(0, f -> f + 2);
// 生成
Stream<Double> generate = Stream.generate(Math::random);
// 筛选与切片
// 从流中过滤某些元素
integerStream.filter(e -> e > 2).forEach(System.out::println);
// 截断流，使其元素不超过给定数量
integerStream.limit(3).forEach(System.out::println);
// 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
integerStream.skip(3).forEach(System.out :: println);
// 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
integerStream.distinct();
// 映射
// 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
Arrays.stream(new String[]{"a", "b", "c"}).map(str -> str.toUpperCase()).forEach(System.out :: println);
// 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
String[] arr1 = {"a", "b", "c", "d"};
String[] arr2 = {"e", "f", "c", "d"};
String[] arr3 = {"h", "j", "c", "d"};
// Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);
// 排序
// 产生一个新流，其中按自然顺序排序
integerStream.sorted().forEach(System.out :: println);
// 产生一个新流，其中按比较器顺序排序
integerStream.sorted(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
// 等同于如上写法
integerStream.sorted((o1, o2) -> o1.compareTo(o2));
// 匹配与查找
// 检查是否匹配所有元素
boolean b = integerStream.allMatch(e -> e > 3);
// 检查是否至少匹配一个元素
b = integerStream.anyMatch(e -> e > 3);
// 检查是否没有匹配所有元素
b = integerStream.noneMatch(e -> e > 3);
// 返回第一个元素
Optional<Integer> first = integerStream.findFirst();
// 返回当前流中的任意元素
Optional<Integer> any = integerStream.findAny();
// 返回流中元素总数
long count = integerStream.count();
// 返回流中最大值
integerStream.max((o1, o2) -> o1.compareTo(o2));
// 返回流中最小值
integerStream.min((o1, o2) -> o1.compareTo(o2));
// 内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
integerStream.forEach(System.out :: println);
// 归约
// 可以将流中元素反复结合起来，得到一个值。返回 T
Integer reduce1 = integerStream.reduce(0, Integer::sum);
// 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
Optional<Integer> reduce = integerStream.reduce(Integer::sum);
// 收集
// 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
// Collectors API
//list.collect(Collectors :: toList);
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
