原创转载请注明出处:http://agilestyle.iteye.com/blog/2427512
先看一个简单的例子
package org.fool.java8.completable; import java.util.Arrays; import java.util.List; import java.util.Random; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.stream.Stream; import static java.util.stream.Collectors.toList; public class CompletableFutureTest4 { private final static Random RANDOM = new Random(System.currentTimeMillis()); public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executorService = Executors.newFixedThreadPool(2); // CompletableFuture.supplyAsync(CompletableFutureTest4::get, executorService) // .thenApply(CompletableFutureTest4::multiply) // .whenComplete((v, t) -> { // Optional.ofNullable(v).ifPresent(System.out::println); // Optional.ofNullable(t).ifPresent(Throwable::printStackTrace); // }); System.out.println("===========main start no block============"); List<Integer> productionIds = Arrays.asList(1, 2, 3, 4, 5); // Stream<CompletableFuture<Double>> completableFutureStream = // productionIds.stream().map(i -> CompletableFuture.supplyAsync(() -> queryProduction(i), executorService)); // // Stream<CompletableFuture<Double>> multiplyFutures = completableFutureStream.map(future -> future.thenApply(CompletableFutureTest4::multiply)); // // List<Double> result = multiplyFutures.map(CompletableFuture::join).collect(toList()); List<Double> result = productionIds.stream() .map(i -> CompletableFuture.supplyAsync(() -> queryProduction(i), executorService)) .map(future -> future.thenApply(CompletableFutureTest4::multiply)) .map(future -> future.thenApply(CompletableFutureTest4::subtract)) .map(CompletableFuture::join).collect(toList()); System.out.println(result); System.out.println("=========main end no block=========="); } private static double get() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } double result = RANDOM.nextDouble(); System.out.println(Thread.currentThread().getName() + ":" + result); return result; } private static double queryProduction(int i) { return CompletableFutureTest4.get(); } private static double multiply(double value) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } return value * 10d; } private static double subtract(double value) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } return value - 1; } }
Note: 将列表中的数字,统一放到一个线程池中处理, 先get,接着multiply,然后substract,最后join
Console Output
thenApply
private static void testThenApply() { CompletableFuture.supplyAsync(() -> 1) .thenApply(i -> Integer.sum(i, 10)) .whenComplete((v, t) -> System.out.println(v)); }
Console Output
handle
private static void testHandle() { CompletableFuture.supplyAsync(() -> 1) .handle((v, t)-> Integer.sum(v, 10)) .whenComplete((v, t) -> System.out.println(v)); }
Console Output
thenRun
private static void testThenRun() { CompletableFuture.supplyAsync(() -> 1) .handle((v, t)-> Integer.sum(v, 10)) .whenComplete((v, t) -> System.out.println(v)) .thenRun(() -> System.out.println("action ended...")); }
Console Output
thenAccept
private static void testThenAccept() { CompletableFuture.supplyAsync(() -> 1) .thenApply(i -> Integer.sum(i, 10)) .thenAccept(System.out::println); }
Console Output
thenCompose
private static void testThenCompose() { CompletableFuture.supplyAsync(() -> 1) .thenCompose(i -> CompletableFuture.supplyAsync(() -> 10 * i)) .thenAccept(System.out::println); }
Console Output
thenCombine
private static void testThenCombine() { CompletableFuture.supplyAsync(() -> 1) .thenCombine(CompletableFuture.supplyAsync(() -> 2), (r1, r2) -> r1 + r2) .thenAccept(System.out::println); }
Console Output
thenAcceptBoth
private static void testThenAcceptBoth() { CompletableFuture.supplyAsync(() -> 1) .thenAcceptBoth(CompletableFuture.supplyAsync(() -> 2), (r1, r2) -> { System.out.println(r1); System.out.println(r2); System.out.println(r1 + r2); }); }
Console Output
相关推荐
- 常用方法包括 `filter()`、`map()`、`reduce()`、`collect()` 等,可以方便地进行数据过滤、转换和聚合操作。 - 并行流(Parallel Streams)利用多核处理器优势,实现高效的数据处理。 3. **日期和时间 API...
理解API的基本结构和常用端点是使用GitLab API Service Provider的前提。 2. **OAuth2认证**: 要与GitLab API交互,通常需要进行OAuth2认证。GitLab API Service Provider会处理授权流程,获取访问令牌,并在后续...
总的来说,Java API在前端开发中的应用主要体现在后端服务的构建上,包括数据处理、通信协议、安全机制、性能优化等方面。熟悉这些Java API的前端开发者能够更好地理解和配合后端工作,提高整体项目的开发效率和质量...
"third-party-api-sim"这个项目可能是一个模拟第三方API的工具或者一个教学示例,它专注于帮助开发者理解和学习如何有效地集成和使用第三方API。这个项目标签为"Java",意味着它是用Java编程语言实现的。 首先,让...
- 常用方法包括`filter()`, `map()`, `reduce()`, `collect()`等,支持并行和串行操作。 4. **Optional类**: - `Optional<T>`用于表示可能为`null`的值,防止空指针异常。 - 它提供了`isPresent()`, `get()`, `...
Java 8引入了CompletableFuture,配合ExecutorService,可以轻松实现非阻塞调用。第三方库如Retrofit也提供了异步调用的支持。 7. **测试API调用**:单元测试和集成测试对于API调用的代码至关重要。JUnit和Mockito...
常用的操作有map(映射),filter(过滤),reduce(聚合)等。通过Stream API,开发者可以编写出简洁且高效的代码来处理大量数据。 4. **日期与时间API**: 在Java 8之前,日期和时间处理相对复杂,Java 8引入了...
7. **并发API增强**:Java 1.8进一步优化了并发处理,如`ForkJoinPool`和`CompletableFuture`,提供了并行计算的新方式,使得异步编程更为简单。 8. ** Nashorn JavaScript引擎**:Java 8引入了一个新的脚本引擎...
例如,`java.util.ArrayList`和`java.util.HashMap`是开发中最常用的集合类,`java.io`包提供了输入输出操作,`java.nio`包则引入了非阻塞I/O。 2. **泛型**:Java 1.5引入的泛型提高了代码的类型安全性和可读性,...
1. **网络请求库**:在Java中,常用的网络请求库有HttpURLConnection(Java标准库)、Apache HttpClient、OkHttp以及Spring的RestTemplate。开发者可能会使用这些库来构建向服务器发送请求的逻辑。 2. **JSON解析**...
smart-doc是一款同时支持JAVA REST API和Apache Dubbo RPC接口文档生成的工具,smart-doc在业内率先提出基于JAVA泛型定义推导的理念,完全基于接口源码来分析生成接口文档,不采用任何注解侵入到业务代码中。...
本篇将围绕JDK API 1.8中文版本,详细解析其关键特性、重要更新以及常用类库的使用。 首先,JDK 1.8是Java发展历程中的一个重要里程碑,它引入了许多创新性特性和功能,例如Lambda表达式、函数式接口、Stream API、...
- `CompletableFuture`:提供了异步编程的支持,允许组合多个异步任务。 以上只是JDK 1.8 API中的一部分关键知识点,实际使用中,开发者还需要深入理解和掌握异常处理、I/O流、网络编程、反射、注解等更多内容。...
例如,`java.util`包中的ArrayList和HashMap是常用的集合类,`java.io`包提供了处理文件和流的工具。 2. **Lambda表达式** JDK 1.8引入了lambda表达式,这是函数式编程的重要特性,简化了匿名内部类的使用,使得...
SpringBoot接口 - 如何生成接口文档之集成Smart-Doc上文我们看到可以通过Swagger系列可以快速生成API文档, 但是这种API文档生成是需要在接口上添加注解等,这表明这是一种侵入式方式; 那么有没有非侵入式方式呢, ...
8. **并发改进**:JDK 8对并发包`java.util.concurrent`进行了优化,如`ForkJoinPool`和`CompletableFuture`。Spring Boot在异步处理和任务调度方面,可以结合JDK 8的并发特性实现高效并行执行。 9. **类型注解...
8. **并发更新类**:`java.util.concurrent`包中新增了`ConcurrentHashMap`的几个子类,如`ConcurrentSkipListMap`和`ConcurrentSkipListSet`,以及`Exchanger`和`CompletableFuture`,提供了更高效的并发控制和异步...
5. HashMap和HashSet:两种常用的Map和Set实现,HashMap提供键值对的快速查找,HashSet存储不重复元素。 三、函数式编程 Java 1.8引入了函数式编程概念,主要体现在以下几个方面: 1. Lambda表达式:一种简洁的匿名...
3. **异步处理**:为了保持用户界面的响应性,避免阻塞UI线程,可能会采用异步处理API请求,如Java 8的CompletableFuture或使用ExecutorService来执行耗时操作。 4. **MVC模式**(Model-View-Controller):...
13.4 异步编排CompletableFuture 254 13.5 异步Web服务实现 257 13.6 请求缓存 259 13.7 请求合并 261 14 如何扩容 266 14.1 单体应用垂直扩容 267 14.2 单体应用水平扩容 267 14.3 应用拆分 268 14.4 数据库拆分 ...