Java基础回顾系列-第三天-Lambda表达式

本文主要是介绍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() {@Overridepublic 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");// 32System.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;}@Overridepublic 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 contextPredicate<String> p = String::isEmpty;// Method invocation contextstream.filter(e -> e.getSize() > 10)...// Cast contextstream.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>() {@Overridepublic 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);// 归约// 可以将流中元素反复结合起来，得到一个值。返回 TInteger reduce1 = integerStream.reduce(0, Integer::sum);// 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>Optional<Integer> reduce = integerStream.reduce(Integer::sum);// 收集// 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法// Collectors API//list.collect(Collectors :: toList);}
}

这篇关于Java基础回顾系列-第三天-Lambda表达式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---