Creates an already completed CompletableFuture with a predefined result. Usually, this may act as the starting stage in your computation.
public boolean complete(T value)public static <U> CompletableFuture<U> completedFuture(U value)List<String> userList = ...
CompletableFuture<List<String>> f = CompletableFuture.completedFuture(userList);public static CompletableFuture<Void> performAllItemsBackup(Stream<Item> items) {
ExecutorService pool = Executors.newFixedThreadPool(3);
try {
return CompletableFuture.allOf(
items.map(CompletableFuture::completedFuture)
.map(f -> f.thenAcceptAsync(performSingleItemBackup, pool))
.toArray(CompletableFuture<?>[]::new));
} finally {
pool.shutdown();
}
}@FeignClient(url = "${external.resource.base}", name = "external")
public interface ExternalFeignClient {
@GetMapping(value = "${external.resource.records}", produces = "application/json")
@Headers({ACCEPT_APPLICATION_JSON, CONTENT_TYPE_APPLICATION_JSON})
ResponseWrapper<Record> getRecords(@RequestHeader Map<String, String> header,
@RequestParam Map<String, String> queryMap,
@RequestParam("limit") Integer limit,
@RequestParam("offset") Integer offset);
}
@Service
public class ExternalFeignClientAsync {
@Awtowired
private ExternalFeignClient externalFeignClient;
@Async
CompletableFuture<ResponseWrapper<Record>> getRecordsAsync(Map<String, String> header,
Map<String, String> header,
Integer limit,
Integer offset){
CompletableFuture.completedFuture(externalFeignClient.getRecords(header,header,
limit,offset));
}
}
@Service
public class ExternalService {
@Autowired
private ExternalFeignClientAsync externalFeignClientAsync;
List<Record> getAllRecords() {
final AtomicInteger offset = new AtomicInteger();
int pageSize = properties.getPageSize(); // set this as you wish
int batches = (totalCount / pageSize) + (totalCount % pageSize > 0 ? 1 : 0);
return IntStream.range(0, batches)
.parallel()
.mapToObj(i -> {
final int os = offset.getAndAdd(pageSize);
return externalFeignClientAsync.getRecordsAsync(requestHeader, queryMap,
fetchSize, os);
})
.map(CompletableFuture::join)
.map(ResponseWrapper::getItems)
.flatMap(List::stream)
.toList();
}
}Only idempotent HEAD and GET requests are served. Any other requests receive a 501 — Not Implemented or a 405 — Not Allowed response. The Simple Web Server supports HTTP/1.1 only. There is no HTTPS support.
$ jwebserverBinding to loopback by default. For all interfaces use “-b 0.0.0.0” or “-b ::”.Serving /cwd and subdirectories on 127.0.0.1 port 8000URL: http://127.0.0.1:8000/
$ jwebserver -b 0.0.0.0 Serving /cwd and subdirectories on 0.0.0.0 (all interfaces) port 8000 URL: http://123.456.7.891:8000/
Simply put, Java 18 adds a new command line tool named jwebserver.
Usage example: jwebserver -p 9000
Running the command fires up a simple web server that serves static files from the current directory. You can define a custom port via -p and a custom directory via -d.
Right now the server is only intended for education, experiments, testing and similar, it’s not intended for the production usage.
The final new language feature that was added to Java 17 is pattern matching for switch expressions. Note that this is a preview version. This is the second occurrence of pattern matching in the language after it has been introduced via the instanceof operator.
In its most simple form, pattern matching is performed on the type of variable that is supplied. Compare this to a classical switch expression/statement where the value is used. Also note that there is a special handling for the null values. Normally, a null value would lead to a NullPointerException (NPE) so it would require an additional check. Thanks to the special handling of the null value this is no longer required. Finally, also notice that the required casting is again performed automatically by the compiler.
String printValue(Object obj) {return switch (obj) {case Integer i -> String.format("It is an integer with value %d", i);case Long l -> String.format("It is a Long with value %d", l);case String s -> String.format("It is a String with value %s", s);case null -> new String("You can't pass in a null value!");default -> String.format("Dunno the type, but the value is %s", obj.toString());};}
String printValue(Object obj) {return switch (obj) { case null -> new String("You can't pass in a null value!"); case String s && s.length() > 10 -> String.format("Long String with value %s", s); case String s -> String.format("Not so long String with value %s", s); default -> String.format("Dunno the type, but the value is %s", obj.toString()); }; }
In the example above, a distinction can be made between strings with a length of up to 10 characters and strings with more than 10 characters.
return switch (obj) {case Integer i -> "It is an integer"; case String s -> "It is a string"; case Employee employee && employee.getDept().equals("IT") -> "IT Employee"; default -> "It is none of the known data types"; };
Basically, this is when you use additional parenthesis to prevent an invalid outcome of a pattern predicate
boolean printValue(Object obj) {return switch (obj) { case String s && s.length() >= 2 && (s.contains("@") || s.contains("!")) -> true; default -> false; }; }
In order to enable unreachable objects in MAT, you need to go to the Window → PreferencesThen go to the memory analyzer section, select the Keep unreachable object tick, and click apply.
Also, after enabling the unreachable objects, if you go to the dominator tree, it will show the unreachable objects along with the live objects.
This will show you the biggest objects and their retained sizes, which is the amount of memory that will be freed if this object is garbage collected.
Now we have an address in yellow section.0x7ff78b9c0When we search this address from search icon in top section, a very detailed screen will appear.