The\u00a0Completable<\/a> Future\u00a0subject in Java is a powerful feature in Java 8 as a type of the java.util.concurrent package. CompletableFuture in Java 8 offers where they can write asynchronous, non-blocking code, to manage difficult operations that could function simultaneously.<\/p>\n\n\n\n The The The The Once both The exceptionally () process in the CompletableFuture API is intended to know exemptions that happens at the time of the execution of a CompletableFuture. The exceptionally() receives a Function that has Throwable as an input and gives a value of the similar kind as the unique CompletableFuture. This value is used to comprehensive the future if an exclusion is thrown at the time of asynchronous computation.<\/p>\n\n\n\n Exception handling in The The Compare Java 23 vs Java 22<\/a> to understand how the new version enhances performance and adds new features.<\/p>\n<\/blockquote>\n\n\n\n CompletableFuture is an adaptable tool in Java for the management of asynchronous software design. While it delivers many benefits such as non-blocking implementation and tractability, it even offers difficulty and above if not used sensibly. If you\u2019re seeking to execute unconventional Java features in the projects, it\u2019s helpful to hire Java developers<\/a> who are knowledgeable in using CompletableFuture and concurrent programming tools.<\/p>\n\n\n\n Read more:<\/strong><\/p>\n\n\n\nCompletableFuture<\/code> is particularly useful in scenarios where:<\/p>\n\n\n\n\n
Advantages and Disadvantages<\/h3>\n\n\n\n
A) Advantages<\/h4>\n\n\n\n
\n
B) Disadvantages<\/h4>\n\n\n\n
\n
Various Methods in CompletableFuture<\/h2>\n\n\n\n
1. thenApply()<\/h3>\n\n\n\n
thenApply()<\/code> a method is used to process and transform the result of a CompletableFuture once it is completed. This technique takes a Meaning as a dispute, which is useful to the result of the CompletableFuture. For instance, if you have a task that returns a string, you can use thenApply() to append additional text to that string.<\/p>\n\n\n\nCompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"Hello\")\n .thenApply(result -> result + \" World\");\nSystem.out.println(future.join()); \/\/ Output: Hello World\n<\/pre>\n\n\n\n
2. thenAccept()<\/h3>\n\n\n\n
thenAccept()<\/code> method is a terminal operation in the CompletableFuture<\/code> pipeline that consumes the result of a CompletableFuture<\/code> once it is completed. Unlike thenApply()<\/code>, which transforms the result, thenAccept()<\/code> simply processes the result without returning any value. This method is particularly useful when you need to perform an action based on the result, such as logging, printing, or updating a UI component, but do not need to pass the result down the chain. Since thenAccept()<\/code> consumes the result without transforming it, it accepts a Consumer<\/code> as its argument. This allows you to define any action that should be performed when the CompletableFuture<\/code> completes successfully.<\/p>\n\n\n\nCompletableFuture.supplyAsync(() -> \"Hello\")\n .thenAccept(result -> System.out.println(\"Result: \" + result));\n<\/pre>\n\n\n\n
thenAccept()<\/code> method is often used in scenarios where the result of a computation needs to be processed, but no further computation is required. It ensures that the result is handled appropriately without further chaining of CompletableFuture<\/code> methods.<\/p>\n\n\n\n2.1 Key Characteristics<\/h4>\n\n\n\n
\n
CompletableFuture<\/code> API, thenAccept()<\/code> does not block the main thread. The action provided to thenAccept()<\/code> is executed asynchronously when the preceding CompletableFuture<\/code> completes.<\/li>\n\n\n\nthenAccept()<\/code> does not return a new CompletableFuture<\/code>, it acts as a terminal operation in the asynchronous pipeline. This makes it ideal for cases where you want to perform a side effect (like logging or updating a UI) but do not need further processing.<\/li>\n\n\n\nthenAccept()<\/code> is to perform side effects, such as interacting with external systems, updating state, or triggering events.<\/li>\n\n\n\nthenAccept()<\/code> will not be executed. If you need to handle exceptions similarly, you would use exceptionally()<\/code> or handle()<\/code> in conjunction with thenAccept()<\/code>.<\/li>\n<\/ul>\n\n\n\n3. thenCombine()<\/h3>\n\n\n\n
thenCombine()<\/code> method is used to combine the results of two CompletableFuture<\/code> instances once both are completed. The thenCombine()<\/code> method accepts two arguments:<\/p>\n\n\n\n\n
CompletableFuture<\/code> to be combined with the first.<\/li>\n\n\n\nBiFunction<\/code> that defines how the results of both CompletableFuture<\/code> instances should be combined.<\/li>\n<\/ul>\n\n\n\nCompletableFuture<\/code> instances are complete, the BiFunction is executed with the results of both futures, producing a new result. This mutual result is later closed in a new CompletableFuture, which is further bound or administered.<\/p>\n\n\n\nCompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> \"Hello\");\nCompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> \"World\");\nCompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + \" \" + result2);\nSystem.out.println(combinedFuture.join()); \/\/ Output: Hello World\n<\/pre>\n\n\n\n
3.1 Key Characteristics<\/h4>\n\n\n\n
\n
thenCombine()<\/code> is to combine the results of two independent CompletableFuture<\/code> instances. This is particularly useful when multiple asynchronous tasks need to be completed before proceeding with further computation.<\/li>\n\n\n\nBiFunction<\/code> interface is used to define the logic for combining the results.<\/li>\n\n\n\nthenCombine()<\/code> ensures that both CompletableFuture<\/code> instances complete before the combination logic is applied. The order in which the futures are complete does not matter, as the combination is only performed once both are done.<\/li>\n\n\n\n4. exceptionally()<\/h3>\n\n\n\n
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {\n if (true) {\n throw new RuntimeException(\"Exception occurred!\");\n }\n return \"Result\";\n}).exceptionally(ex -> \"Handled Exception: \" + ex.getMessage());\nSystem.out.println(future.join()); \/\/ Output: Handled Exception: Exception occurred!\n<\/pre>\n\n\n\n4.1 Key Characteristics<\/h4>\n\n\n\n
\n
exceptionally()<\/code> is to handle exceptions that occur during the asynchronous computation. It provides a fallback mechanism that ensures the CompletableFuture<\/code> can still complete successfully, albeit with an alternative result.<\/li>\n\n\n\nCompletableFuture<\/code> API, exceptionally()<\/code> operates asynchronously. It does not block the main thread and ensures that the exception-handling logic is applied as soon as the exception occurs.<\/li>\n\n\n\nexceptionally()<\/code> method allows you to control how your application recovers from errors. You can log the exception, provide a default value, or trigger other recovery mechanisms to maintain the flow of your program.<\/li>\n\n\n\nexceptionally()<\/code> returns a new CompletableFuture<\/code>, it can be chained with other methods in the CompletableFuture<\/code> API, allowing you to continue processing even after an error has occurred.<\/li>\n\n\n\nexceptionally()<\/code> block is never executed, and the original result is returned. This ensures that the error-handling logic is only applied when necessary.<\/li>\n<\/ul>\n\n\n\nException Handling in CompletableFuture<\/h2>\n\n\n\n
CompletableFuture<\/code> can be done using methods like exceptionally()<\/code>, handle()<\/code>, and whenComplete()<\/code>. These methods allow you to recover from exceptions or handle them gracefully without disrupting the workflow.<\/p>\n\n\n\n1. Using handle()<\/h3>\n\n\n\n
handle()<\/code> method allows you to process the result or handle an exception.<\/p>\n\n\n\nCompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {\n if (true) {\n throw new RuntimeException(\"Error occurred!\");\n }\n return \"Success\";\n}).handle((result, ex) -> {\n if (ex != null) {\n return \"Handled Error: \" + ex.getMessage();\n }\n return result;\n});\nSystem.out.println(future.join()); \/\/ Output: Handled Error: Error occurred!\n<\/pre>\n\n\n\n2. Using whenComplete()<\/h3>\n\n\n\n
whenComplete()<\/code> method allows you to act as the CompletableFuture is complete, regardless of whether it is completed successfully or exceptionally.<\/p>\n\n\n\nCompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {\n if (true) {\n throw new RuntimeException(\"Exception occurred!\");\n }\n return \"Success\";\n}).whenComplete((result, ex) -> {\n if (ex != null) {\n System.out.println(\"Exception: \" + ex.getMessage());\n } else {\n System.out.println(\"Result: \" + result);\n }\n});\nfuture.join(); \/\/ Output: Exception: Exception occurred!\n<\/pre>\n\n\n\n\n
Conclusion<\/h2>\n\n\n\n