关于java:Java-8-新特性总结

40次阅读

共计 9901 个字符，预计需要花费 25 分钟才能阅读完成。

1. 行为参数化

在 Java 8 之前，能作为参数进行传递的只能是一个确切类型的变量，比方：根本数据类型的变量，或者某个对象的援用变量。在面向对象程序设计中，对象次要蕴含两局部，属性和行为，在此，行为能够了解为就是对象中的办法。

Java 8 中的行为参数化，做到了能够把办法在调用链上进行传递。行为参数化是一个很有用的模式，它可能轻松地适应一直变动的需要。

对汇合进行排序是一个常见的编程工作。同一个汇合列表，在不同的需要下可能排序规定不同，将排序行为参数化就能够应答这种变动的需要。

List<Integer> list = new ArrayList<>();
Collections.sort(list, (o1, o2) -> o1.compareTo(o2)); // 升序
Collections.sort(list, (o1, o2) -> o2.compareTo(o1)); // 倒序

2. Lambda 表达式

Lambda 表达式能够了解为简洁地示意可传递的 匿名函数 的一种形式：它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个能够抛出的异样列表。

匿名
—— 因为它不像一般的办法那样有一个明确的名称。
函数
—— 因为 Lambda 函数不像办法那样属于某个特定的类。但和办法一样，Lambda 有参数列表、函数主体、返回类型，还可能有能够抛出的异样列表。
传递
—— Lambda 表达式能够作为参数传递给办法或存储在变量中。
简洁
—— 无需像匿名类那样写很多模板代码。

2.1 语法规定

(parameters) -> expression

或

(parameters) -> {statements;}

2.2 函数接口

个别在函数式接口上应用 Lambda 表达式，函数式接口就是 只定义一个形象办法 的接口，比方：Runnable 接口的定义：

@FunctionalInterface
public interface Runnable {public abstract void run();
}

2.3 函数描述符

函数式接口的形象办法叫作函数描述符。在应用 Lambda 表达式的时候，Lambda 表达式的签名必须和函数式接口的函数描述符匹配能力失常应用。比方：

() -> void 代表了参数列表为空，且返回 void 的形象办法。这正是 Runnable 函数式接口中的形象办法。所以就能够在应用 Runnable 的中央应用这个 Lambda 表达式。

在 Java 8 的 API 中，函数式接口带有 @FunctionalInterface 的标注。这个标注用于示意该接口会设计成一个函数式接口。

2.4 付诸实践

从文件中一次读取一行内容，代码模板：

public static String processFile() throws IOException {try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {return br.readLine();   // 性能代码
    }
}

如果一次读取两行内容，代码模板：

public static String processFile() throws IOException {try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {return br.readLine() + br.readLine();   // 性能代码}
}

把 processFile 的行为参数化。而后须要一种办法把行为作为参数传递给 processFile，以便它能够利用 BufferedReader 执行不同的行为。

第 1 步：定义参数化行为

String result = processFile((BufferedReader br) -> br.readLine() + br.readLine());

(BufferedReader br) -> br.readLine() + br.readLine() 就是要定义的行为。

第 2 步：定义函数式接口

@FunctionalInterface
public interface BufferedReaderProcessor {String process(BufferedReader b) throws IOException;
}

函数式接口用来传递参数化的行为。

第 3 步：定义行为如何执行

public static String processFile(BufferedReaderProcessor p) throws IOException {try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {return p.process(br); // 性能代码
    }
}

第 4 步：传递 Lambda 表达式

String oneLine = processFile((BufferedReader br) -> br.readLine());
String twoLine = processFile((BufferedReader br) -> br.readLine() + br.readLine());

通过传递不同的 Lambda 重用 processFile 办法，并以不同的形式解决文件。

2.5 内置的函数式接口

下面展现了如何利用函数式接口来传递 Lambda，但须要本人定义函数式接口能力应用。Java 8 中曾经提供了一些常见的函数式接口，能够重用它们来传递不同的 Lambda，如果有现成的函数式接口，那么就不必咱们本人定义并创立接口类了。

Predicate 接口
java.util.function.Predicate<T> 接口定义了一个名叫 test 的形象办法，它承受泛型 T 对象，并返回一个 boolean 值。

@FunctionalInterface
public interface Predicate<T>{boolean test(T t);
}

Consumer 接口
java.util.function.Consumer<T> 定义了一个名叫 accept 的形象办法，它承受泛型 T 的对象，没有返回（void）。

FunctionalInterface
public interface Consumer<T>{void accept(T t);
}

Function 接口
java.util.function.Function<T, R> 接口定义了一个叫作 apply 的办法，它承受一个泛型 T 的对象，并返回一个泛型 R 的对象。

@FunctionalInterface
public interface Function<T, R>{R apply(T t);
}

Java 类型要么是援用类型（比方 Byte、Integer、Object、List），要么是原始类型（比方 int、double、byte、char）。然而泛型（比方 Consumer<T> 中的 T）只能绑定到援用类型。这是由泛型外部的实现形式造成的。因而，在 Java 里有一个将原始类型转换为对应的援用类型的机制。这个机制叫作装箱（boxing）。相同的操作，也就是将援用类型转换为对应的原始类型，叫作拆箱（unboxing）。Java 还有一个主动装箱机制来帮忙程序员执行这一工作：装箱和拆箱操作是主动实现的。

但这在性能方面是要付出代价的。装箱后的值实质上就是把原始类型包裹起来，并保留在堆里。因而，装箱后的值须要更多的内存，并须要额定的内存搜寻来获取被包裹的原始值。Java 8 为咱们后面所说的函数式接口带来了专门的版本，以便在输出和输入都是原始类型时防止主动装箱的操作。比方：IntPredicate。其余的还有 DoublePredicate、IntConsumer、LongBinaryOperator、IntFunction 等，这里就不一一举例子了。上面是 Java 8 提供的罕用的函数式接口：

3. 流式数据处理

Java 8 中提供了流，用来实现对汇合的申明式操作，就像数据库语言 SQL 那样，只须要指定具体的需要，比方：查找，分组等。能够把流看成遍历数据集的高级迭代器。此外，流还能够通明地
并行处理，无需写任何多线程代码等。流的应用个别包含三件事：

  1. 一个数据源（如汇合）来执行一个查问；
  2. 一个两头操作链，造成一条流的流水线；
  3. 一个终端操作，执行流水线，并能生成后果。

3.1 筛选和切片

3.1.1 用谓词筛选

Streams 接口反对 filter 办法。该操作会承受一个谓词（一个返回 boolean 的函数）作为参数，并返回一个包含所有合乎谓词的元素的流。

Arrays.asList("a", "b", "c", "z", "d").stream().filter(s -> s.equals("a")).forEach(System.out::println);

3.1.2 筛选去重元素

流还反对一个叫作 distinct 的办法，它会返回一个元素各异（依据流所生成元素的 hashCode 和 equals 办法实现）的流。

Arrays.asList(1, 2, 1, 3, 3, 2, 4).stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);

3.1.3 截短流

流反对 limit(n) 办法，该办法会返回一个不超过给定长度的流。

Arrays.asList("ab", "bc", "cd").stream().filter(s -> s.length() > 1).limit(2).forEach(System.out.println);

3.1.4 跳过元素

流还反对 skip(n) 办法，返回一个扔掉了前 n 个元素的流。如果流中元素有余 n 个，则返回一个空流。

Arrays.asList("a", "b", "c", "d", "e", "f").stream().skip(10).forEach(System.out.println);

3.2 映射

一个十分常见的数据处理需要就是从某些对象中抉择属性信息。就像在 SQL 里，能够从表中抉择一列。Stream 也通过 map 和 flatMap 办法提供了相似的工具。

3.2.1 对元素利用函数

流反对 map 办法，它会承受一个函数作为参数。这个函数会被利用到每个元素上，并将其映射成一个新的元素（应用映射一词，是因为它和转换相似，但其中的细微差别在于它是“创立一个新版本”而不是去“批改”）。

Arrays.asList("aaa", "bb", "c", "zzzz", "dd").stream().map(String::lengh).forEach(System.out.println);

3.2.2 将多个流交融

对字符串数组 [“ab”, “bc”, “cd”, “zd”, “dz”] 进行字符去重输入，输入后果为 a b c d z

应用 map 办法：

Stream<String[]> mapStream = Arrays.asList("ab", "bc", "cd", "zd", "dz").stream().map(s -> s.split(""));
mapStream.distinct().forEach(System.out::println);

输入后果：

[Ljava.lang.String;@7ba4f24f
[Ljava.lang.String;@3b9a45b3
[Ljava.lang.String;@7699a589
[Ljava.lang.String;@58372a00
[Ljava.lang.String;@4dd8dc3

未能达到预期后果。

应用 flatMap 办法：

Stream<String> flatMapStream = Arrays.asList("ab", "bc", "cd", "zd", "dz").stream().flatMap(s -> Stream.of(s.split("")));
flatMapStream.distinct().forEach(System.out::println);

输入后果：

a
b
c
d
z

达到预期输入后果。
总结，flatmap 办法能够把一个流中的每个值都换成一个流，而后把所有的流连接起来成为一个流。通过下面 map 办法 和 flatMap 办法可能比拟直观的看到这一点。

3.3 查找和匹配

表白数据集中的某些元素是否匹配一个给定的属性。Stream API 通过 allMatch、anyMatch、noneMatch、findFirst 和 findAny 办法提供了这样的实现。

3.3.1 查看谓词是否至多匹配一个元素

anyMatch 办法能够表白“流中是否有一个元素能匹配给定的谓词”。

boolean b = Arrays.asList("a", "b", "c", "d", "z").stream().anyMatch(e -> e.equals("b"));

b 的后果是 true。

3.3.3 查看谓词是否匹配所有元素

allMatch 办法的工作原理和 anyMatch 相似，但它会看看流中的元素是否都能匹配给定的谓词。

boolean b = Arrays.asList("a", "b", "c", "d", "z").stream().allMatch(e -> e.equals("b"));

b 的后果是 false。

和 allMatch 绝对的是 noneMatch。它能够确保流中没有任何元素与给定的谓词匹配。

boolean b = Arrays.asList("a", "b", "c", "d", "z").stream().noneMatch(e -> e.equals("f"));

b 的后果是 true。

anyMatch、allMatch 和 noneMatch 这三个操作都用到了咱们所谓的短路，这就是大家相熟的 Java 中 && 和 || 运算符短路在流中的版本。

3.3.3 查找任意一个元素

findAny 办法将返回以后流中的任意元素。

Optional<String> any = Arrays.asList("a", "b", "c", "d", "z").stream().findAny();

3.3.4 查找第一个元素

有些流有一个呈现程序（encounter order）来指定流中我的项目呈现的逻辑程序（比方由 List
或排序好的数据列生成的流）。对于这种流，你可能想要找到第一个元素。为此有一个 findFirst
办法，它的工作形式相似于 findany。

Optional<String> first = Arrays.asList("a", "b", "c", "d", "z").stream().findFirst();

为什么会同时有 findFirst 和 findAny 呢？答案是并行。找到第一个元素在并行上限度更多，如果不关怀返回的元素是哪个，请应用 findAny，因为它在应用并行流时限度较少。

3.4 归约

把一个流中的元素组合起来，应用 reduce 操作来表白更简单的需要。此操作须要将流中所有元素重复联合起来，失去一个值，比方一个 Integer。这样的操作能够被归类为归约操作（将流归约成一个值）。

3.4.1 元素求和

int sum = numbers.stream().reduce(0, (a, b) -> a + b);

或

int sum = numbers.stream().reduce(0, Integer::sum);

3.4.2 最大值和最小值

Optional<Integer> max = numbers.stream().reduce(Integer::max);
Optional<Integer> min = numbers.stream().reduce(Integer::min);

3.4.3 map 和 reduce 组合

int count = menu.stream().map(d -> 1).reduce(0 , (a, b) -> a + b);

map 和 reduce 的连贯通常称为 map-reduce 模式，因 Google 用它来进行网络搜寻而出名，因为它很容易并行化。

3.5 构建流

3.5.1 由汇合构建流

Stream<String> stream = Arrays.asList("a", "b", "c", "d", "z").stream();

3.5.2 由值创立流

应用静态方法 Stream.of，通过显式值创立一个流。它能够承受任意数量的参数。

Stream<String> stream = Stream.of("Java 8", "Lambdas", "In", "Action");

3.5.3 由数组创立流

int[] numbers = {2, 3, 5, 7, 11, 13};
IntStream stream = Arrays.stream(numbers);

3.5.4 由文件生成流

计算 data.txt 文件中的单词数量。

long uniqueWords = 0;
try (Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
            .distinct()
            .count();} catch (IOException e) {
}
System.out.println(uniqueWords);

4. 并行流

Stream 接口能够通过调用 parallelStream 办法来把汇合转换为并行流，或者对程序流应用 parallel 办法来把其转化为并行流。并行流是一个把内容分成多个数据块，并用不同的线程别离解决每个数据块的流。这样一来，就能够主动把给定操作的工作负荷调配给多核处理器的所有内核，让它们都忙起来。

对程序流应用 parallel 办法：

Stream.of("AAA", "BBB", "CCC").parallel().forEach(s -> System.out.println("Output:" + s));

对收集源应用 parallelStream 办法：

Arrays.asList("AAA", "BBB", "CCC").parallelStream().forEach(s -> System.out.println("Output:" + s));

5. CompletableFuture：组合式异步编程

5.1 异步执行工作

supplyAsync 办法承受一个生产者（Supplier）作为参数，返回一个 CompletableFuture 对象，该对象实现异步执行后会读取生产者办法的执行后果。生产者办法会交由 ForkJoinPool 池中的某个执行线程（Executor）运行，也能够应用 supplyAsync 办法的重载版本，传递第二个参数指定不同的执行线程执行生产者办法。

CompletableFuture.supplyAsync(this::sendMsg);

默认都应用固定数目的线程，具体线程数取决 Runtime.getRuntime().availableProcessors() 的返回值。

CompletableFuture.supplyAsync(this::sendMsg, Executors.newFixedThreadPool(10));

5.2 减少回调

CompletableFuture.supplyAsync(this::sendMsg)
                      .thenAccept(this::notify);

应用 thenAccept 办法实现异步工作的回调，接管一个 Consumer 函数式接口。

5.3 链式回调

如果想持续将值从一个回调传递到另一个回调，thenAccept 办法做不到，因为不会返回值。这个时候能够是用 thenApply 办法。

CompletableFuture.supplyAsync(this::findReceiver)
                     .thenApply(this::sendMsg)
                     .thenAccept(this::notify);

5.4 thenCompose 办法

假如咱们有一个 sendMsgAsync 返回 CompletionStage，如果持续应用 thenApply 最终会失去嵌套 CompletionStage。

CompletableFuture.supplyAsync(this::findReceiver)  
                 .thenApply(this::sendMsgAsync);

// Returns type CompletionStage<CompletionStage<String>>

下面嵌套的 CompletionStage 是咱们不心愿的，这个时候能够应用 thenCompose 办法。

CompletableFuture.supplyAsync(this::findReceiver)  
                 .thenCompose(this::sendMsgAsync);

// Returns type CompletionStage<String>

5.5 独立线程执行回调

async 后缀的回调办法能够将回调提交给 ForkJoinPool.commonPool() 来应用独立的线程执行，而不是应用与后任雷同的线程。

假如咱们想一次向同一个接收者发送两条音讯。

CompletableFuture<String> receiver  
            = CompletableFuture.supplyAsync(this::findReceiver);

receiver.thenApply(this::sendMsg);  
receiver.thenApply(this::sendOtherMsg);

在下面的示例中，所有内容都将在同一个线程上执行。这导致最初一条音讯期待第一条音讯实现。

通过应用 async 后缀，每条音讯都作为独自的工作提交给 ForkJoinPool.commonPool()。这样能够实现在计算实现后异步执行两个回调。当有多个回调依赖于同一个计算时，异步版本会很不便。

CompletableFuture<String> receiver  
            = CompletableFuture.supplyAsync(this::findReceiver);

receiver.thenApplyAsync(this::sendMsg);  
receiver.thenApplyAsync(this::sendMsg);

5.6 异样解决

exceptionally 办法能够实现如果后面的计算因异样而失败，能够对失败进行降级解决，返回失败代替后果。这样，后续回调能够持续以代替后果作为输出。

CompletableFuture.supplyAsync(this::failingMsg)  
                 .exceptionally(ex -> new Result(Status.FAILED))
                 .thenAccept(this::notify);

5.7 回调取决于多个计算

有时，可能创立一个依赖于两次计算结果的回调会十分有帮忙。这时能够应用 thenCombine。thenCombine 容许 BiFunction 依据两个 CompletionStages 的后果注册一个回调。

CompletableFuture<String> to =  
    CompletableFuture.supplyAsync(this::findReceiver);

CompletableFuture<String> text =  
    CompletableFuture.supplyAsync(this::createContent);

to.thenCombine(text, this::sendMsg);

6. 默认办法

Java 程序的接口是将相干办法依照约定组合到一起的形式。实现接口的类必须为接口中定义的每个办法提供一个实现，或者从父类中继承它的实现。然而，一旦类库的设计者须要更新接口，向其中退出新的办法，这种形式就会呈现问题。

Java 8 中的接口反对在申明办法的同时提供实现，通过两种形式能够实现这种操作。其一，Java 8 容许在接口内申明静态方法。其二，Java 8 引入了一个新性能，叫默认办法，通过默认办法你能够指定接口办法的默认实现。换句话说，接口能提供办法的具体实现。因而，实现接口的类如果不显式地提供该办法的具体实现，就会主动继承默认的实现。比方：Collection 接口中的 stream 办法：

default Stream<E> stream() {return StreamSupport.stream(spliterator(), false);
}

默认办法由 default 修饰符润饰，并像类中申明的其余办法一样蕴含办法体。

参考

《Java 8 实战》
https://www.deadcoderising.co…

正文完
java
发表至： java
2022-07-12
 0
Java-爬虫服务器被屏蔽不要慌咱们换一台服务器
关于java:Java12新特性及代码示例
关于java:jvm类文件结构
关于java:ThreadLocal不好用那是你没用对