1 函数式接⼝

1.1 概念

函数式接⼝在Java中是指：有且仅有⼀个抽象⽅法的接⼝。

函数式接⼝，即适⽤于函数式编程场景的接⼝。⽽Java中的函数式编程体现就是Lambda，所以函数式接⼝就是可以适⽤于Lambda使⽤的接⼝。只有确保接⼝中有且仅有⼀个抽象⽅法，Java中的Lambda才能顺利地进⾏推导。

备注：“语法糖”是指使⽤更加⽅便，但是原理不变的代码语法。例如在遍历集合时使⽤的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应⽤层⾯来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是⼆者在原理上是不同的。

1.2 格式

只要确保接⼝中有且仅有⼀个抽象⽅法即可：

修饰符 interface 接⼝名称 {public abstract 返回值类型 ⽅法名称(可选参数信息);// 其他⾮抽象⽅法内容
}

由于接⼝当中抽象⽅法的public abstract是可以省略的，所以定义⼀个函数式接⼝很简单：

public interface MyFunctionalInterface {void myMethod();
}

1.3 @FunctionalInterface注解

与@Override注解的作⽤类似，Java 8中专⻔为函数式接⼝引⼊了⼀个新的注解：@FunctionalInterface。该注解可⽤于⼀个接⼝的定义上：

@FunctionalInterface
public interface MyFunctionalInterface {void myMethod();
}

⼀旦使⽤该注解来定义接⼝，编译器将会强制检查该接⼝是否确实有且仅有⼀个抽象⽅法，否则将会报错。需要注意的是，即使不使⽤该注解，只要满⾜函数式接⼝的定义，这仍然是⼀个函数式接⼝，使⽤起来都⼀样。

1.4 ⾃定义函数式接⼝

对于刚刚定义好的MyFunctionalInterface函数式接⼝，典型使⽤场景就是作为⽅法的参数：

public class Demo09FunctionalInterface {// 使⽤⾃定义的函数式接⼝作为⽅法参数private static void doSomething(MyFunctionalInterface inter) {inter.myMethod(); // 调⽤⾃定义的函数式接⼝⽅法}public static void main(String[] args) {// 调⽤使⽤函数式接⼝的⽅法doSomething(() -> System.out.println("Lambda执⾏啦!"));}
}

2 函数式编程

在兼顾⾯向对象特性的基础上，Java语⾔通过Lambda表达式与⽅法引⽤等，为开发者打开了函数式编程的⼤⻔。下⾯我们做⼀个初探。

2.1 Lambda的延迟执⾏

有些场景的代码执⾏后，结果不⼀定会被使⽤，从⽽造成性能浪费。⽽Lambda表达式是延迟执⾏的，这正好可以作为解决⽅案，提升性能。

性能浪费的⽇志案例

注：⽇志可以帮助我们快速的定位问题，记录程序运⾏过程中的情况，以便项⽬的监控和优化。

⼀种典型的场景就是对参数进⾏有条件使⽤，例如对⽇志消息进⾏拼接后，在满⾜条件的情况下进⾏打印输出：

public class Demo01Logger {private static void log(int level, String msg) {if (level == 1) {System.out.println(msg);}}public static void main(String[] args) {String msgA = "Hello";String msgB = "World";String msgC = "Java";log(1, msgA + msgB + msgC);}
}

这段代码存在问题：⽆论级别是否满⾜要求，作为 log ⽅法的第⼆个参数，三个字符串⼀定会⾸先被拼接并传⼊⽅法内，然后才会进⾏级别判断。如果级别不符合要求，那么字符串的拼接操作就⽩做了，存在性能浪费。

备注：SLF4J是应⽤⾮常⼴泛的⽇志框架，它在记录⽇志时为了解决这种性能浪费的问题，
并不推荐⾸先进⾏字符串的拼接，⽽是将字符串的若⼲部分作为可变参数传⼊⽅法中，仅在⽇志级别满⾜要求的情况下才会进⾏字符串拼接。例如： LOGGER.debug(“变量{}的取值为{}。”, “os”, “macOS”) ，其中的⼤括号 {} 为占位符。如果满⾜⽇志级别要求，则会将“os”和“macOS”两个字符串依次拼接到⼤括号的位置；否则不会进⾏字 符串拼接。这也是⼀种可⾏解决⽅案，但Lambda可以做到更好。

体验Lambda的更优写法

使⽤Lambda必然需要⼀个函数式接⼝：

@FunctionalInterface
public interface MessageBuilder {String buildMessage();
}

然后对log⽅法进⾏改造：

public class Demo02LoggerLambda {private static void log(int level, MessageBuilder builder) {if (level == 1) {System.out.println(builder.buildMessage());}}public static void main(String[] args) {String msgA = "Hello";String msgB = "World";String msgC = "Java";log(1, () -> msgA + msgB + msgC );}
}

这样⼀来，只有当级别满⾜要求的时候，才会进⾏三个字符串的拼接;否则三个字符串将不会进⾏拼接。

证明Lambda的延迟

下⾯的代码可以通过结果进⾏验证：

public class Demo03LoggerDelay {private static void log(int level, MessageBuilder builder) {if (level == 1) {System.out.println(builder.buildMessage());}}public static void main(String[] args) {String msgA = "Hello";String msgB = "World";String msgC = "Java";log(2, () -> {System.out.println("Lambda执⾏!");return msgA + msgB + msgC;});}
}

从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执⾏。从⽽达到节省性能的效果。

扩展：实际上使⽤内部类也可以达到同样的效果，只是将代码操作延迟到了另外⼀个对象当中通过调⽤⽅法来完成。⽽是否调⽤其所在⽅法是在条件判断之后才执⾏的。

2.2 使⽤Lambda作为参数和返回值

如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果⽅法的参数是⼀个函数式接⼝类型，那么就可以使⽤Lambda表达式进⾏替代。使⽤Lambda表达式作为⽅法参数，其实就是使⽤函数式接⼝作为⽅法参数。

例如java.lang.Runnable接⼝就是⼀个函数式接⼝，假设有⼀个startThread⽅法使⽤该接⼝作为参数，那么就可以使⽤Lambda进⾏传参。这种情况其实和Thread类的构造⽅法参数为 Runnable 没有本质区别。

public class Demo04Runnable {private static void startThread(Runnable task) {new Thread(task).start();}public static void main(String[] args) {startThread(() -> System.out.println("线程任务执⾏!"));}
}

类似地，如果⼀个⽅法的返回值类型是⼀个函数式接⼝，那么就可以直接返回⼀个Lambda表达式。当需要通过⼀个⽅法来获取⼀个java.util.Comparator接⼝类型的对象作为排序器时，就可以调该⽅法获取。

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {private static Comparator<String> newComparator() {return (a, b) -> b.length() - a.length();}public static void main(String[] args) {String[] array = { "abc", "ab", "abcd" };System.out.println(Arrays.toString(array));Arrays.sort(array, newComparator());System.out.println(Arrays.toString(array));}
}

其中直接return⼀个Lambda表达式即可。

3 常⽤函数式接⼝

JDK提供了⼤量常⽤的函数式接⼝以丰富Lambda的典型使⽤场景，它们主要在java.util.function包中被提供。下⾯是最简单的⼏个接⼝及使⽤示例。

3.1 Supplier接⼝

java.util.function.Supplier< T >接⼝仅包含⼀个⽆参的⽅法：T get()。⽤来获取⼀个泛型参数指定类型的对象数据。由于这是⼀个函数式接⼝，这也就意味着对应的Lambda表达式需要“对外提供”⼀个符合泛型类型的对象数据。

3.2 练习：求数组元素最⼤值

题⽬

使⽤ Supplier 接⼝作为⽅法参数类型，通过Lambda表达式求出int数组中的最⼤值。提示：接⼝的泛型请使⽤ java.lang.Integer 类。

解答

public class Demo02Test {// 定⼀个⽅法,⽅法的参数传递Supplier,泛型使⽤Integerpublic static int getMax(Supplier<Integer> sup) {return sup.get();}public static void main(String[] args) {int arr[] = {2, 3, 4, 52, 333, 23};// 调⽤getMax⽅法,参数传递Lambdaint maxNum = getMax(() -> {// 计算数组的最⼤值int max = arr[0];for (int i : arr) {if (i > max) {max = i;}}return max;});System.out.println(maxNum);}
}

3.3 Consumer接⼝

java.util.function.Consumer< T >接⼝则正好与Supplier接⼝相反，它不是⽣产⼀个数据，⽽是消费⼀个数据，其数据类型由泛型决定。

抽象⽅法：accept

Consumer 接⼝中包含抽象⽅法void accept(T t)，意为消费⼀个指定泛型的数据。基本使⽤如：

import java.util.function.Consumer;
public class Demo09Consumer {private static void consumeString(Consumer<String> function) {function.accept("Hello");}public static void main(String[] args) {consumeString(s -> System.out.println(s));}
}

当然，更好的写法是使⽤⽅法引⽤。

默认⽅法：andThen

如果⼀个⽅法的参数和返回值全都是Consumer类型，那么就可以实现效果：消费数据的时候，⾸先做⼀个操作，然后再做⼀个操作，实现组合。⽽这个⽅法就是Consumer接⼝中的default⽅法andThen。下⾯是JDK的源代码：

default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}

备注：java.util.Objects的requireNonNull静态⽅法将会在参数为null时主动抛出NullPointerException异常。这省去了重复编写 if 语句和抛出空指针异常的麻烦。

要想实现组合，需要两个或多个Lambda表达式即可，⽽ andThen 的语义正是“⼀步接⼀步”操作。例如两个步骤组合的情况：

import java.util.function.Consumer;
public class Demo10ConsumerAndThen {private static void consumeString(Consumer<String> one, Consumer<String> two) {one.andThen(two).accept("Hello");}public static void main(String[] args) {consumeString( s -> System.out.println(s.toUpperCase()),s -> System.out.println(s.toLowerCase()));}
}

运⾏结果将会⾸先打印完全⼤写的HELLO，然后打印完全⼩写的hello。当然，通过链式写法可以实现更多步骤的组合。

3.4 练习：格式化打印信息

题⽬

下⾯的字符串数组当中存有多条信息，请按照格式“ 姓名:XX。性别:XX。”的格式将信息打印出来。要求将打印姓名的动作作为第⼀个Consumer接⼝的Lambda实例，将打印性别的动作作为第⼆个Consumer接⼝的Lambda实例，将两个Consumer接⼝按照顺序“拼接”到⼀起。

public static void main(String[] args) {String[] array = {"迪丽热巴,⼥", "古⼒娜扎,⼥", "⻢尔扎哈,男"};}

解答

import java.util.function.Consumer;
public class DemoConsumer {public static void main(String[] args) {String[] array = { "迪丽热巴,⼥", "古⼒娜扎,⼥", "⻢尔扎哈,男" };printInfo(s -> System.out.print("姓名:" + s.split(",")[0]),s -> System.out.println("。性别:" + s.split(",")[1] + "。"),array);}private static void printInfo(Consumer<String> one, Consumer<String> two,String[] array) {for (String info : array) {one.andThen(two).accept(info); // 姓名:迪丽热巴。性别:⼥。}}
}

3.5 Predicate接⼝

有时候我们需要对某种类型的数据进⾏判断，从⽽得到⼀个boolean值结果。这时可以使java.util.function.Predicate< T >接⼝。

抽象⽅法：test

Predicate接⼝中包含⼀个抽象⽅法：boolean test(T t)。⽤于条件判断的场景：

import java.util.function.Predicate;
public class Demo15PredicateTest {private static void method(Predicate<String> predicate) {boolean veryLong = predicate.test("HelloWorld");System.out.println("字符串很⻓吗:" + veryLong);}public static void main(String[] args) {method(s -> s.length() > 5);}
}

条件判断的标准是传⼊的Lambda表达式逻辑，只要字符串⻓度⼤于5则认为很⻓。

默认⽅法：and

既然是条件判断，就会存在与、或、⾮三种常⻅的逻辑关系。其中将两个Predicate条件使⽤“与”逻辑连接起来实现“并且”的效果时，可以使⽤default⽅法and。其JDK源码为：

default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}

如果要判断⼀个字符串既要包含⼤写“H”，⼜要包含⼤写“W”，那么：

import java.util.function.Predicate;
public class Demo16PredicateAnd {private static void method(Predicate<String> one, Predicate<String> two) {boolean isValid = one.and(two).test("Helloworld");System.out.println("字符串符合要求吗:" + isValid);}public static void main(String[] args) {method(s -> s.contains("H"), s -> s.contains("W"));}
}

默认⽅法：or

与and的“与”类似，默认⽅法or实现逻辑关系中的**“或”**。JDK源码为：

default Predicate<T> or(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) || other.test(t);}

如果希望实现逻辑“字符串包含⼤写H或者包含⼤写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不变：

import java.util.function.Predicate;
public class Demo16PredicateAnd {private static void method(Predicate<String> one, Predicate<String> two) {boolean isValid = one.or(two).test("Helloworld");System.out.println("字符串符合要求吗:" + isValid);}public static void main(String[] args) {method(s -> s.contains("H"), s -> s.contains("W"));}
}

默认⽅法：negate

“与”、“或”已经了解了，剩下的“⾮”（取反）也会简单。默认⽅法 negate 的JDK源代码为：

default Predicate<T> negate() {return (t) -> !test(t);}

从实现中很容易看出，它是执⾏了test⽅法之后，对结果boolean值进⾏“!”取反⽽已。⼀定要在test⽅法调⽤之前调⽤negate⽅法，正如and和or⽅法⼀样：

import java.util.function.Predicate;
public class Demo17PredicateNegate {private static void method(Predicate<String> predicate) {boolean veryLong = predicate.negate().test("HelloWorld");System.out.println("字符串很⻓吗:" + veryLong);}public static void main(String[] args) {method(s -> s.length() < 5);}
}

3.6 练习：集合信息筛选

题⽬

数组当中有多条“姓名+性别”的信息如下，请通过Predicate接⼝的拼装将符合要求的字符串筛选
到集合ArrayList中，需要同时满⾜两个条件：

1. 必须为⼥⽣；
2. 姓名为4个字。

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class DemoPredicate {public static void main(String[] args) {String[] array = { "迪丽热巴,⼥", "古⼒娜扎,⼥", "⻢尔扎哈,男", "赵丽颖,⼥"};List<String> list = filter(array, s -> "⼥".equals(s.split(",")[1]),s -> s.split(",")[0].length() == 4);System.out.println(list);}private static List<String> filter(String[] array, Predicate<String> one,Predicate<String> two) {List<String> list = new ArrayList<>();for (String info : array) {if (one.and(two).test(info)) {list.add(info);}}return list;}
}

3.7 Function接⼝

java.util.function.Function<T,R>接⼝⽤来根据⼀个类型的数据得到另⼀个类型的数据，前者称为前置条件，后者称为后置条件。

抽象⽅法：apply

Function接⼝中最主要的抽象⽅法为：R apply(T t)，根据类型T的参数获取类型R的结果。

使⽤的场景例如：将String类型转换为Integer类型。

import java.util.function.Function;
public class Demo11FunctionApply {private static void method(Function<String, Integer> function) {int num = function.apply("10");System.out.println(num + 20);}public static void main(String[] args) {method(s -> Integer.parseInt(s));}
}

当然，最好是通过⽅法引⽤的写法。

默认⽅法：andThen

Function接⼝中有⼀个默认的andThen⽅法，⽤来进⾏组合操作。JDK源代码如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}

该⽅法同样⽤于“先做什么，再做什么”的场景，和Consumer中的andThen差不多：

import java.util.function.Function;
public class Demo12FunctionAndThen {private static void method(Function<String, Integer> one,Function<Integer, Integer> two) {int num = one.andThen(two).apply("10");System.out.println(num + 20);}public static void main(String[] args) {method(str->Integer.parseInt(str)+10, i -> i *= 10);}
}

第⼀个操作是将字符串解析成为int数字，第⼆个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了⼀起。

请注意，Function的前置条件泛型和后置条件泛型可以相同。

3.8 练习：⾃定义函数模型拼接

题⽬

请使⽤Function进⾏函数模型的拼接，按照顺序需要执⾏的多个函数操作为：

String str = “赵丽颖, 20”;

1. 将字符串截取数字年龄部分，得到字符串；
2. 将上⼀步的字符串转换成为int类型的数字；
3. 将上⼀步的int数字累加100，得到结果int数字。

解答

import java.util.function.Function;
public class DemoFunction {public static void main(String[] args) {String str = "赵丽颖, 20";int age = getAgeNum(str, s -> s.split(",")[1],s ->Integer.parseInt(s),n -> n += 100);System.out.println(age);}private static int getAgeNum(String str, Function<String, String> one,Function<String, Integer> two,Function<Integer, Integer> three) {return one.andThen(two).andThen(three).apply(str);}
}

4 Stream流

说到Stream便容易想到I/O Stream，⽽实际上，谁规定“流”就⼀定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引⼊了⼀个全新的Stream概念，⽤于解决已有集合类库既有的弊端。

4.1 引⾔

传统集合的多步遍历代码

⼏乎所有的集合（如Collection接⼝或Map接⼝等）都⽀持直接或间接的遍历操作。⽽当我们需要对集合中的元素进⾏操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如：

import java.util.ArrayList;
import java.util.List;
public class Demo01ForEach {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("张⽆忌");list.add("周芷若");list.add("赵敏");list.add("张强");list.add("张三丰");for (String name : list) {System.out.println(name);}}
}

这是⼀段⾮常简单的集合遍历操作：对集合中的每⼀个字符串都进⾏打印输出操作。

循环遍历的弊端

Java 8的Lambda让我们可以更加专注于做什么( What )，⽽不是怎么做( How )，这点此前已经结合内部类进⾏了对⽐说明。现在，我们仔细体会⼀下上例代码，可以发现：

• for循环的语法就是 “怎么做”
• for循环的循环体才是 “做什么”

为什么使⽤循环？因为要进⾏遍历。但循环是遍历的唯⼀⽅式吗？遍历是指每⼀个元素逐⼀进⾏处理，⽽并不是从第⼀个到最后⼀个顺次处理的循环。前者是⽬的，后者是⽅式。

试想⼀下，如果希望对集合中的元素进⾏筛选过滤：

1. 将集合A根据条件⼀过滤为⼦集B；
2. 然后再根据条件⼆过滤为⼦集C。

那怎么办？在Java 8之前的做法可能为：

import java.util.ArrayList;
import java.util.List;public class Demo02NormalFilter {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("张⽆忌");list.add("周芷若");list.add("赵敏");list.add("张强");list.add("张三丰");List<String> zhangList = new ArrayList<>();for (String name : list) {if (name.startsWith("张")) {zhangList.add(name);}}List<String> shortList = new ArrayList<>();for (String name : zhangList) {if (name.length() == 3) {shortList.add(name);}}for (String name : shortList) {System.out.println(name);}}
}

这段代码中含有三个循环，每⼀个作⽤不同：

1. ⾸先筛选所有姓张的⼈；
2. 然后筛选名字有三个字的⼈；
3. 最后进⾏对结果进⾏打印输出。

每当我们需要对集合中的元素进⾏操作的时候，总是需要进⾏循环、循环、再循环。这是理所当然的么？不是。循环是做事情的⽅式，⽽不是⽬的。另⼀⽅⾯，使⽤线性循环就意味着只能遍历⼀次。如果希望再次遍历，只能再使⽤另⼀个循环从头开始。那，Lambda的衍⽣物Stream能给我们带来怎样更加优雅的写法呢？

Stream的更优写法

下⾯来看⼀下借助Java 8的Stream API，什么才叫优雅：

import java.util.ArrayList;
import java.util.List;
public class Demo03StreamFilter {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("张⽆忌");list.add("周芷若");list.add("赵敏");list.add("张强");list.add("张三丰");list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);}
}

直接阅读代码的字⾯意思即可完美展示⽆关逻辑⽅式的语义：获取流、过滤姓张、过滤⻓度为3、逐⼀打印。代码中并没有体现使⽤线性循环或是其他任何算法进⾏遍历，我们真正要做的事情内容被更好地体现在代码中。

4.2 流式思想概述

注意：请暂时忘记对传统IO流的固有印象！

整体来看，流式思想类似于⼯⼚⻋间的“⽣产流⽔线”。

当需要对多个元素进⾏操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该⾸先拼好⼀个“模型”步骤⽅案，然后再按照⽅案去执⾏它。

这张图中展示了过滤、映射、跳过、计数等多步操作，这是⼀种集合元素的处理⽅案，⽽⽅案就是⼀种“函数模型”。图中的每⼀个⽅框都是⼀个“流”，调⽤指定的⽅法，可以从⼀个流模型转换为另⼀个流模型。⽽最右侧的数字3是最终结果。

这⾥的filter、map、skip都是在对函数模型进⾏操作，集合元素并没有真正被处理。只有当终结⽅法count执⾏的时候，整个模型才会按照指定策略执⾏操作。⽽这得益于Lambda的延迟执⾏特性。

备注：“Stream流”其实是⼀个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

Stream（流）是⼀个来⾃数据源的元素队列

• 元素是特定类型的对象，形成⼀个队列。 Java中的Stream并不会存储元素，⽽是按需计算。
• 数据源流的来源。可以是集合，数组等。

和以前的Collection操作不同，Stream操作还有两个基础的特征：

• Pipelining：中间操作都会返回流对象本身。这样多个操作可以串联成⼀个管道， 如同流式⻛格（fluent style）。这样做可以对操作进⾏优化，⽐如延迟执⾏(laziness)和短路( shortcircuiting)。
• 内部迭代：以前对集合遍历都是通过Iterator或者增强for的⽅式，显式的在集合外部进⾏迭代，这叫做外部迭代。Stream提供了内部迭代的⽅式，流可以直接调⽤遍历⽅法。

当使⽤⼀个流的时候，通常包括三个基本步骤：获取⼀个数据源（source）→ 数据转换 → 执⾏操作获取想要的结果，每次转换原有 Stream 对象不改变，返回⼀个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条⼀样排列，变成⼀个管道。

4.3 获取流

java.util.stream.Stream<T>是Java 8新加⼊的最常⽤的流接⼝。(这并不是⼀个函数式接⼝。)

获取⼀个流⾮常简单，有以下⼏种常⽤的⽅式：

• 所有的Collection集合都可以通过stream默认⽅法获取流；
• Stream接⼝的静态⽅法of可以获取数组对应的流。

根据Collection获取流

⾸先，java.util.Collection接⼝中加⼊了default⽅法stream⽤来获取流，所以其所有实现类均可获取流。

import java.util.*;
import java.util.stream.Stream;
public class Demo04GetStream {public static void main(String[] args) {List<String> list = new ArrayList<>();// ...Stream<String> stream1 = list.stream();Set<String> set = new HashSet<>();// ...Stream<String> stream2 = set.stream();Vector<String> vector = new Vector<>();// ...Stream<String> stream3 = vector.stream();}
}

根据Map获取流

java.util.Map接⼝不是Collection的⼦接⼝，且其K-V数据结构不符合流元素的单⼀特征，所以获取对应的流需要分key、value或entry等情况：

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
public class Demo05GetStream {public static void main(String[] args) {Map<String, String> map = new HashMap<>();// ...Stream<String> keyStream = map.keySet().stream();Stream<String> valueStream = map.values().stream();Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();}
}

根据数组获取流

如果使⽤的不是集合或映射⽽是数组，由于数组对象不可能添加默认⽅法，所以Stream接⼝中提供了静态⽅法of，使⽤很简单：

import java.util.stream.Stream;
public class Demo06GetStream {public static void main(String[] args) {String[] array = { "张⽆忌", "张翠⼭", "张三丰", "张⼀元" };Stream<String> stream = Stream.of(array);}
}

备注： of ⽅法的参数其实是⼀个可变参数，所以⽀持数组。

4.4 常⽤⽅法

流模型的操作很丰富，这⾥介绍⼀些常⽤的API。这些⽅法可以被分成两种：

• 延迟⽅法：返回值类型仍然是Stream接⼝⾃身类型的⽅法，因此⽀持链式调⽤。(除了终结⽅法外，其余⽅法均为延迟⽅法。)
• 终结⽅法：返回值类型不再是Stream接⼝⾃身类型的⽅法，因此不再⽀持类似 StringBuilder 那样的链式调⽤。本⼩节中，终结⽅法包括count和forEach⽅法。

备注：本⼩节之外的更多⽅法，请⾃⾏参考API⽂档。

逐⼀处理：forEach

虽然⽅法名字叫forEach，但是与for循环中的“for-each”昵称不同。

void forEach(Consumer<? super T> action);

该⽅法接收⼀个Consumer接⼝函数，会将每⼀个流元素交给该函数进⾏处理。

复习Consumer接⼝

java.util.function.Consumer<T>接⼝是⼀个消费型接⼝。
Consumer接⼝中包含抽象⽅法void accept(T t)，意为消费⼀个指定泛型的数据。

基本使⽤

import java.util.stream.Stream;
public class Demo12StreamForEach {public static void main(String[] args) {Stream<String> stream = Stream.of("张⽆忌", "张三丰", "周芷若");stream.forEach(name-> System.out.println(name));}
}

过滤：filter

可以通过filter⽅法将⼀个流转换成另⼀个⼦集流。⽅法签名：

Stream<T> filter(Predicate<? super T> predicate);

该接⼝接收⼀个Predicate函数式接⼝参数（可以是⼀个Lambda或⽅法引⽤）作为筛选条件。

复习Predicate接⼝

此前我们已经学习过java.util.stream.Predicate函数式接⼝，其中唯⼀的抽象⽅法为：

boolean test(T t);

该⽅法将会产⽣⼀个boolean值结果，代表指定的条件是否满⾜。如果结果为true，那么Stream流的filter⽅法将会留⽤元素；如果结果为false，那么filter⽅法将会舍弃元素。

基本使⽤

Stream流中的 filter ⽅法基本使⽤的代码如：

import java.util.stream.Stream;
public class Demo07StreamFilter {public static void main(String[] args) {Stream<String> original = Stream.of("张⽆忌", "张三丰", "周芷若");Stream<String> result = original.filter(s -> s.startsWith("张"));}
}

在这⾥通过Lambda表达式来指定了筛选的条件：必须姓张。

映射：map

如果需要将流中的元素映射到另⼀个流中，可以使⽤map⽅法。⽅法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接⼝需要⼀个Function函数式接⼝参数，可以将当前流中的T类型数据转换为另⼀种R类型的流。

复习Function接⼝

此前我们已经学习过java.util.stream.Function函数式接⼝，其中唯⼀的抽象⽅法为：

R apply(T t);

这可以将⼀种T类型转换成为R类型，⽽这种转换的动作，就称为“映射”。

基本使⽤

Stream流中的map⽅法基本使⽤的代码如：

import java.util.stream.Stream;
public class Demo08StreamMap {public static void main(String[] args) {Stream<String> original = Stream.of("10", "12", "18");Stream<Integer> result = original.map(str->Integer.parseInt(str));}
}

这段代码中，map⽅法的参数通过⽅法引⽤，将字符串类型转换成为了int类型（并⾃动装箱为Integer类对象）。

统计个数：count

正如旧集合Collection当中的 size ⽅法⼀样，流提供count⽅法来数⼀数其中的元素个数：

long count();

该⽅法返回⼀个long值代表元素个数（不再像旧集合那样是int值）。基本使⽤：

import java.util.stream.Stream;
public class Demo09StreamCount {public static void main(String[] args) {Stream<String> original = Stream.of("张⽆忌", "张三丰", "周芷若");Stream<String> result = original.filter(s -> s.startsWith("张"));System.out.println(result.count()); // 2}
}

取⽤前⼏个：limit

limit⽅法可以对流进⾏截取，只取⽤前n个。⽅法签名：

Stream<T> limit(long maxSize);

参数是⼀个long型，如果集合当前⻓度⼤于参数则进⾏截取；否则不进⾏操作。基本使⽤：

import java.util.stream.Stream;
public class Demo10StreamLimit {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);

如果流的当前⻓度⼤于n，则跳过前n个；否则将会得到⼀个⻓度为0的空流。基本使⽤：

import java.util.stream.Stream;
public class Demo11StreamSkip {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)

备注：这是⼀个静态⽅法，与 java.lang.String 当中的 concat ⽅法是不同的。

该⽅法的基本使⽤代码如：

import java.util.stream.Stream;
public class Demo12StreamConcat {public static void main(String[] args) {Stream<String> streamA = Stream.of("张⽆忌");Stream<String> streamB = Stream.of("张翠⼭");Stream<String> result = Stream.concat(streamA, streamB);}
}

4.5 练习：集合元素处理（传统⽅式）

题⽬

现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使⽤传统的for循环（或增强for循环）依次进⾏以下若⼲操作步骤：

1. 第⼀个队伍只要名字为3个字的成员姓名；存储到⼀个新集合中。
2. 第⼀个队伍筛选之后只要前3个⼈；存储到⼀个新集合中。
3. 第⼆个队伍只要姓张的成员姓名；存储到⼀个新集合中。
4. 第⼆个队伍筛选之后不要前2个⼈；存储到⼀个新集合中。
5. 将两个队伍合并为⼀个队伍；存储到⼀个新集合中。
6. 根据姓名创建 Person 对象；存储到⼀个新集合中。
7. 打印整个队伍的Person对象信息。

两个队伍（集合）的代码如下：

import java.util.ArrayList;
import java.util.List;
public class DemoArrayListNames {public static void main(String[] args) {//第⼀⽀队伍ArrayList<String> one = new ArrayList<>();one.add("迪丽热巴");one.add("宋远桥");one.add("苏星河");one.add("⽯破天");one.add("⽯中⽟");one.add("⽼⼦");one.add("庄⼦");one.add("洪七公");//第⼆⽀队伍ArrayList<String> two = new ArrayList<>();two.add("古⼒娜扎");two.add("张⽆忌");two.add("赵丽颖");two.add("张三丰");two.add("尼古拉斯赵四");two.add("张天爱");two.add("张⼆狗");// ....}
}

⽽Person类的代码为：

public class Person {private String name;public Person() {}public Person(String name) {this.name = name;}@Overridepublic String toString() {return "Person{name='" + name + "'}";}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

解答

既然使⽤传统的for循环写法，那么：

public class DemoArrayListNames {public static void main(String[] args) {List<String> one = new ArrayList<>();// ...List<String> two = new ArrayList<>();// ...// 第⼀个队伍只要名字为3个字的成员姓名;List<String> oneA = new ArrayList<>();for (String name : one) {if (name.length() == 3) {oneA.add(name);}}// 第⼀个队伍筛选之后只要前3个⼈;List<String> oneB = new ArrayList<>();for (int i = 0; i < 3; i++) {oneB.add(oneA.get(i));}// 第⼆个队伍只要姓张的成员姓名;List<String> twoA = new ArrayList<>();for (String name : two) {if (name.startsWith("张")) {twoA.add(name);}}// 第⼆个队伍筛选之后不要前2个⼈;List<String> twoB = new ArrayList<>();for (int i = 2; i < twoA.size(); i++) {twoB.add(twoA.get(i));}// 将两个队伍合并为⼀个队伍;List<String> totalNames = new ArrayList<>();totalNames.addAll(oneB);totalNames.addAll(twoB);// 根据姓名创建Person对象;List<Person> totalPersonList = new ArrayList<>();for (String name : totalNames) {totalPersonList.add(new Person(name));}// 打印整个队伍的Person对象信息。for (Person person : totalPersonList) {System.out.println(person);}}
}

运⾏结果为：

Person{name='宋远桥'}
Person{name='苏星河'}
Person{name='⽯破天'}
Person{name='张天爱'}
Person{name='张⼆狗'}

4.6 练习：集合元素处理（Stream⽅式）

题⽬

将上⼀题当中的传统for循环写法更换为Stream流式处理⽅式。两个集合的初始内容不变，Person类的定义也不变。

解答

等效的Stream流式处理代码为：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class DemoStreamNames {public static void main(String[] args) {List<String> one = new ArrayList<>();// ...List<String> two = new ArrayList<>();// ...// 第⼀个队伍只要名字为3个字的成员姓名;// 第⼀个队伍筛选之后只要前3个⼈;Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);// 第⼆个队伍只要姓张的成员姓名;// 第⼆个队伍筛选之后不要前2个⼈;Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);// 将两个队伍合并为⼀个队伍;// 根据姓名创建Person对象;// 打印整个队伍的Person对象信息。Stream.concat(streamOne,streamTwo).map(Person::new).forEach(System.out::println);}
}

运⾏效果完全⼀样。

5 ⽅法引⽤

在使⽤Lambda表达式的时候，我们实际上传递进去的代码就是⼀种解决⽅案：拿什么参数做什么操作。那么考虑⼀种情况：如果我们在Lambda中所指定的操作⽅案，已经有地⽅存在相同⽅案，那是否还有必要再写重复逻辑？

5.1 冗余的Lambda场景

来看⼀个简单的函数式接⼝以应⽤Lambda表达式：

@FunctionalInterface
public interface Printable {void print(String str);
}

在Printable接⼝当中唯⼀的抽象⽅法print接收⼀个字符串参数，⽬的就是为了打印显示它。那么通过Lambda来使⽤它的代码很简单：

public class Demo01PrintSimple {private static void printString(Printable data) {data.print("Hello, World!");}public static void main(String[] args) {printString(s -> System.out.println(s));}
}

其中printString⽅法只管调⽤Printable接⼝的print⽅法，⽽并不管print⽅法的具体实现逻辑会将字符串打印到什么地⽅去。⽽main⽅法通过Lambda表达式指定了函数式接⼝Printable的具体操作⽅案为：拿到String（类型可推导，所以可省略）数据后，在控制台中输出它。

5.2 问题分析

这段代码的问题在于，对字符串进⾏控制台打印输出的操作⽅案，明明已经有了现成的实现，那就是System.out对象中的println(String)⽅法。既然Lambda希望做的事情就是调⽤println(String)⽅法，那何必⾃⼰⼿动调⽤呢？

5.3 ⽤⽅法引⽤改进代码

能否省去Lambda的语法格式（尽管它已经相当简洁）呢？只要“引⽤”过去就好了：

public class Demo02PrintRef {private static void printString(Printable data) {data.print("Hello, World!");}public static void main(String[] args) {printString(System.out::println);}
}

请注意其中的双冒号 :: 写法，这被称为**“⽅法引⽤”**，⽽双冒号是⼀种新的语法。

5.4 ⽅法引⽤符

双冒号::为引⽤运算符，⽽它所在的表达式被称为⽅法引⽤。如果Lambda要表达的函数⽅案已经存在于某个⽅法的实现中，那么则可以通过双冒号来引⽤该⽅法作为Lambda的替代者。

语义分析

例如上例中，System.out对象中有⼀个重载的println(String)⽅法恰好就是我们所需要的。那么对于printString⽅法的函数式接⼝参数，对⽐下⾯两种写法，完全等效：

• Lambda表达式写法：s -> System.out.println(s);
• ⽅法引⽤写法：System.out::println

第⼀种语义是指：拿到参数之后经Lambda之⼿，继⽽传递给System.out.println⽅法去处理。

第⼆种等效写法的语义是指：直接让System.out中的println⽅法来取代Lambda。两种写法的执⾏效果完全⼀样，⽽第⼆种⽅法引⽤的写法复⽤了已有⽅案，更加简洁。

注：Lambda 中传递的参数⼀定是⽅法引⽤中的那个⽅法可以接收的类型，否则会抛出异常。

推导与省略

如果使⽤Lambda，那么根据 “可推导就是可省略” 的原则，⽆需指定参数类型，也⽆需指定的重载形式 – 它们都将被⾃动推导。⽽如果使⽤⽅法引⽤，也是同样可以根据上下⽂进⾏推导。

函数式接⼝是Lambda的基础，⽽⽅法引⽤是Lambda的孪⽣兄弟。

下⾯这段代码将会调⽤ println ⽅法的不同重载形式，将函数式接⼝改为int类型的参数：

@FunctionalInterface
public interface PrintableInteger {void print(int str);
}

由于上下⽂变了之后可以⾃动推导出唯⼀对应的匹配重载，所以⽅法引⽤没有任何变化：

public class Demo03PrintOverload {private static void printInteger(PrintableInteger data) {data.print(1024);}public static void main(String[] args) {printInteger(System.out::println);}
}

这次⽅法引⽤将会⾃动匹配到println(int)的重载形式。

5.5 通过对象名引⽤成员⽅法

这是最常⻅的⼀种⽤法，与上例相同。如果⼀个类中已经存在了⼀个成员⽅法：

public class MethodRefObject {public void printUpperCase(String str) {System.out.println(str.toUpperCase());}
}

函数式接⼝仍然定义为：

@FunctionalInterface
public interface Printable {void print(String str);
}

那么当需要使⽤这个printUpperCase成员⽅法来替代Printable接⼝的Lambda的时候，已经具有了MethodRefObject类的对象实例，则可以通过对象名引⽤成员⽅法，代码为：

public class Demo04MethodRef {private static void printString(Printable lambda) {lambda.print("Hello");}public static void main(String[] args) {MethodRefObject obj = new MethodRefObject();printString(obj::printUpperCase);}
}

5.6 通过类名称引⽤静态⽅法

由于在java.lang.Math类中已经存在了静态⽅法abs，所以当我们需要通过Lambda来调⽤该⽅法时，有两种写法。⾸先是函数式接⼝：

@FunctionalInterface
public interface Calcable {int calc(int num);
}

第⼀种写法是使⽤Lambda表达式：

public class Demo05Lambda {private static void method(int num, Calcable lambda) {System.out.println(lambda.calc(num));}public static void main(String[] args) {method(-10, n -> Math.abs(n));}
}

但是使⽤⽅法引⽤的更好写法是：

public class Demo06MethodRef {private static void method(int num, Calcable lambda) {System.out.println(lambda.calc(num));}public static void main(String[] args) {method(-10, Math::abs);}
}

在这个例⼦中，下⾯两种写法是等效的：

• Lambda表达式：n -> Math.abs(n)
• ⽅法引⽤：Math::abs

5.7 通过super引⽤成员⽅法

如果存在继承关系，当Lambda中需要出现super调⽤时，也可以使⽤⽅法引⽤进⾏替代。⾸先是函数式接⼝：

@FunctionalInterface
public interface Greetable {void greet();
}

然后是⽗类Human的内容：

public class Human {public void sayHello() {System.out.println("Hello!");}
}

最后是⼦类Man的内容，其中使⽤了Lambda的写法：

public class Man extends Human {@Overridepublic void sayHello() {System.out.println("⼤家好,我是Man!");}// 定义⽅法method,参数传递Greetable接⼝public void method(Greetable g) {g.greet();}public void show() {// 调⽤method⽅法,使⽤Lambda表达式method(() -> {// 创建Human对象,调⽤sayHello⽅法new Human().sayHello();});// 简化Lambdamethod(() -> new Human().sayHello());//使⽤super关键字代替⽗类对象method(() -> super.sayHello());}
}

但是如果使⽤⽅法引⽤来调⽤⽗类中的sayHello⽅法会更好，例如另⼀个⼦类Woman：

public class Man extends Human {@Overridepublic void sayHello() {System.out.println("⼤家好,我是Man!");}// 定义⽅法method,参数传递Greetable接⼝public void method(Greetable g) {g.greet();}public void show() {method(super::sayHello);}
}

在这个例⼦中，下⾯两种写法是等效的：

• Lambda表达式： () -> super.sayHello()
• ⽅法引⽤： super::sayHello

5.8 通过this引⽤成员⽅法

this代表当前对象，如果需要引⽤的⽅法就是当前类中的成员⽅法，那么可以使⽤ “this::成员⽅法” 的格式来使⽤⽅法引⽤。⾸先是简单的函数式接⼝：

@FunctionalInterface
public interface Richable {void buy();
}

下⾯是⼀个丈夫Husband类：

public class Husband {private void marry(Richable lambda) {lambda.buy();}public void beHappy() {marry(() -> System.out.println("买套房⼦"));}
}

开⼼⽅法beHappy调⽤了结婚⽅法marry，后者的参数为函数式接⼝Richable，所以需要⼀个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了，则可以对Husband丈夫类进⾏修改：

public class Husband {private void buyHouse() {System.out.println("买套房⼦");}private void marry(Richable lambda) {lambda.buy();}public void beHappy() {marry(() -> this.buyHouse());}
}

如果希望取消掉Lambda表达式，⽤⽅法引⽤进⾏替换，则更好的写法为：

public class Husband {private void buyHouse() {System.out.println("买套房⼦");}private void marry(Richable lambda) {lambda.buy();}public void beHappy() {marry(this::buyHouse);}
}

在这个例⼦中，下⾯两种写法是等效的：

• Lambda表达式：() -> this.buyHouse()
• ⽅法引⽤：this::buyHouse

5.9 类的构造器引⽤

由于构造器的名称与类名完全⼀样，并不固定。所以构造器引⽤使⽤类名称::new的格式表示。
⾸先是⼀个简单的Person类：

public class Person {private String name;public Person(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

然后是⽤来创建Person对象的函数式接⼝：

public interface PersonBuilder {Person buildPerson(String name);
}

要使⽤这个函数式接⼝，可以通过Lambda表达式：

public class Demo09Lambda {public static void printName(String name, PersonBuilder builder) {System.out.println(builder.buildPerson(name).getName());}public static void main(String[] args) {printName("赵丽颖", name -> new Person(name));}
}

但是通过构造器引⽤，有更好的写法：

public class Demo10ConstructorRef {public static void printName(String name, PersonBuilder builder) {System.out.println(builder.buildPerson(name).getName());}public static void main(String[] args) {printName("赵丽颖", Person::new);}
}

在这个例⼦中，下⾯两种写法是等效的：

• Lambda表达式：name -> new Person(name)
• ⽅法引⽤：Person::new

5.10 数组的构造器引⽤

数组也是Object的⼦类对象，所以同样具有构造器，只是语法稍有不同。如果对应到Lambda的使⽤场景中时，需要⼀个函数式接⼝：

@FunctionalInterface
public interface ArrayBuilder {int[] buildArray(int length);
}

在应⽤该接⼝的时候，可以通过Lambda表达式：

public class Demo11ArrayInitRef {private static int[] initArray(int length, ArrayBuilder builder) {return builder.buildArray(length);}public static void main(String[] args) {int[] array = initArray(10, length -> new int[length]);}
}

但是更好的写法是使⽤数组的构造器引⽤：

public class Demo12ArrayInitRef {private static int[] initArray(int length, ArrayBuilder builder) {return builder.buildArray(length);}public static void main(String[] args) {int[] array = initArray(10, int[]::new);}
}

在这个例⼦中，下⾯两种写法是等效的：

• Lambda表达式：length -> new int[length]
• ⽅法引⽤：int[]::new

JavaSE个人复习式整理知识点之函数式接⼝、Stream流、⽅法引⽤相关推荐

1. JavaSE个人复习式整理知识点之异常、线程

   异常.线程 1 异常 1.1 异常概念 1.2 异常体系 1.3 异常分类 1.4 异常的产⽣过程解析 2 异常的处理 2.1 抛出异常throw 2.2 Objects⾮空判断 2.3 声明异常th ...

2. 函数式编程-Stream流（来源三更草堂）

   函数式编程-Stream流 1. 概述 1.1 为什么学? 能够看懂公司里的代码 大数量下处理集合效率高 代码可读性高 消灭嵌套地狱 //查询未成年作家的评分在70以上的书籍 由于洋流影响所以作家和书 ...

3. 函数式编程-Stream流/lambda表达式/Optional/函数式接口/方法引用/高级用法

   函数式编程-Stream流 不会Lambda表达式.函数式编程?你确定能看懂公司代码?-java8函数式编程(Lambda表达式,Optional,Stream流)从入门到精通-最通俗易懂 1. 概述 ...

4. Java8函数式编程——Stream流

   函数式编程-Stream流 实例练习:https://javadaily.cn/post/2022020817/7f222b3057fb/ 1. 概述 1.1 为什么学? 能够看懂公司里的代码 大数量 ...

5. JAVA学习 API_day11(属性集, 函数式编程, stream流)

   属性集, 函数式编程, stream流 I/O流小结 1. 属性集 2. 函数式编程 3. stream流 I/O流小结 文件复制: BufferedInputStream/BufferedOutpu ...

6. Lambda表达式接口更新方法引用函数式接口Stream流

   Lambda表达式&接口更新&方法引用&函数式接口&Stream流 Lambda 1.程序启动三种不同的表现形式 2.Lambda表达式的标准格式 3.练习 Lambd ...

7. 函数式编程-Stream流

   1. 概述 1.1 为什么学? 能够看懂公司里的代码 大数量下处理集合效率高 代码可读性高 消灭嵌套地狱 //查询未成年作家的评分在70以上的书籍 由于洋流影响所以作家和书籍可能出现重复,需要进行去重 ...

8. java8/Stream流式计算从入门到精通/函数式编程实战

   摘要:Stream流式计算,本文讲解了Stream流式计算的概念,具体的使用步骤以及源码实现,最后讲解了使用Stream过程中需要注意的事项.Stream在公司项目中被频繁使用,在性能优化上具有广泛的 ...

9. 【Java10】lambda表达式（函数式编程），Stream流，File类，字节/字符流，乱码，缓冲/转换/序列化/打印流，Properties

   文章目录 1.lambda表达式标准语法:()->{} 2.lambda表达式简略语法:可推导即可省略 3.lambda表达式原理:lambda效率比匿名内部类高 4.两个函数式接口:Consu ...

10. 机器学习【期末复习总结】——知识点和算法例题（详细整理）

    机器学习[期末复习总结]--知识点和算法例题(详细整理) 1.什么是机器学习,什么是训练集,验证集和测试集?(摘自ML科普系列(一)) 机器学习: 对计算机一部分数据进行学习,然后对另外一些数据进行预 ...

最新文章

1. ELK套件FileBeat部署
2. linux 文件系统cache,终于找到一篇详解Linux文件系统Cache的文章
3. 数据结构及算法总结（概述）
4. Git修改已提交的commit
5. 【学生信息管理系统】-优化篇1
6. Ubuntu 安装 H3C iNode 客户端
7. iNFTnews | 元宇宙进行时：那些跑步入场的互联网大厂在如何谋篇布局？
8. Revit二次开发入门
9. 美妆类短视频如何定位？可以考虑三个方向，吸粉引流指日可待
10. PhotoZoom2020pro激活序列号秘钥下载8版安装教程
11. 战争英雄、同性恋和计算机科学的奠基人
12. 如何将分表汇总到总表_EXCEL如何将分表中的数据汇总到总表 - 卡饭网
13. Git 如何撤回已经push到远端上的代码
14. linux ahci 不重装,老电脑竟然忘记开AHCI了，教你种不用重装系统的解决方法
15. 2.海康威视-web3.0插件连接摄像头实现预览效果
16. mac电脑装虚拟机遇到的坑！
17. 群体遗传 | haplotype block | HaploBlocker参数介绍
18. 新型网络诈骗缘何层出不穷？
19. 科创板IPO上市条件
20. 华章8月书讯，夏日静心好读书

热门文章

1. 知识点滴- BC和BCE的区别
2. 移动电子商务：五个技术标准与Trustonic TEE解决方案【转】
3. 外贸邮箱能群发吗？用哪个外贸邮箱发开发信回复率高？
4. Python PyAutoGUI模块自动化控制鼠标和键盘
5. iOS数据库编程（Andy）
6. Python 爬取微信朋友圈的方法
7. 【Docker社区大会】WebAssembly：无需容器的 Docker——VMware技术总监 Daniel Lopez
8. QBitmap 单色图片
9. uboot dnw 源码分析
10. Block will be retained by an object strongly retained by the captured object