JEP 102: Process API Updates<\/h2>\n
Managing from java the call to an external process has always been complicated. Especially if we want to do some operations that seems basic but not foreseen in the actual implementation (getting the PID, killing a process, gathering the command lines, …)<\/p>\n
Via the JEP 102 : Process API Updates<\/a>, the Process API have been greatly enhanced to allow all these information, on the process of the JVM (ProcessHandle.current()), or on a child process created by Runtime.getRuntime().exec(“your_cmd”). Moreover, like always with java, it’s compatible will all the supported OS (so with Windows AND Linux!).<\/p>\n Here are some usage examples in Java 9:<\/p>\n HTTP\/2 is already out and a lot of websites already use it. So it is time for Java to offer a client implementation. In the mean time, the API has been revisited to offer a simpler implementation that the really old HttpURLConnection<\/a> that was the only way to make HTTP request in Java in the JDK (and the reason why developers used third-party library like Apache HttpClient or OKHttp). With the JEP 110: HTTP\/2 Client (Incubator)<\/a> Java get an up-to-date HTTP client, synchronous or asynchronous (in this case, it is based on CompletableFuture<\/a>).<\/p>\n Here is an example of an asynchronous usage :<\/p>\n Going through an execution stack in Java has never been an easy task … now it is one, thanks to the Stack-Walking API : http:\/\/openjdk.java.net\/jeps\/259<\/a><\/a><\/p>\n The JEP 256 brings one of the biggest API change in Java 9 : static methods on the interfaces of the Collection API for easily create immutable collections. More info here : http:\/\/openjdk.java.net\/jeps\/269<\/a><\/a>. This API targets the creation of small collections (list, set, map). Performance and memory utilization has been on the center of the implementation of these collections.<\/p>\n The JEP 266: More Concurrency Updates<\/a> as it’s name didn’t indicate, contains one of the major evolution of Java 9 : an implementation of the Reactive Streams<\/a> in Java via the Flow class. Java will then join the very hype group of reactive languages!<\/p>\n The class Flow<\/a> contains three interfaces for the implementation of your reactive streams :<\/p>\n Here is an example from the tutorial available here<\/a> :<\/p>\n And now the Publisher example :<\/p>\n Moreover, there as been some changes on the CompletabeFuture API (it’s more or less an equivalent to the JavaScript promises in Java) that allow, among other things, a better composition of the CompletableFuture between them :<\/p>\n For a complete list of these new methods, see the once with Since 9<\/em><\/strong>” in the javadoc : http:\/\/download.java.net\/java\/jdk9\/docs\/api\/java\/util\/concurrent\/CompletableFuture.html<\/a><\/a><\/p>\n The JEP 277: Enhanced Deprecation<\/a> allow to give extra information on the deprecation via the annotation @Deprecated<\/strong>strong>@Deprecated<\/strong<\/a>, two new attributes that allow developers to know if the deprecated API used is intended to be deleted some day and when the deprecation occurs. The purpose is to facilitate the lifecycle of applications and allow, maybe more easily, to delete some API on the JDK itself in the future.<\/p>\n Here is a small example that said that the MyDeprecatedClass is deprecated since version 9 and will be deprecated some days :<\/p>\n A lot of languages (ruby, scala, python, …) have a Read-Evaluate-Print-Loop (REPL), a shell. This allow an easy learning of the language and give a direct access to the language from a simple shell. Whether it was for introducing the language, prototyping or testing, it’s always a good thing to have a shell and avoid the ceremonial of editing, compiling and packaging code.<\/p>\n With Java 9, born jshell<\/strong>, the java REPL! More info on the JEP : http:\/\/openjdk.java.net\/jeps\/222<\/a><\/a><\/p>\n From the command line, execute \/bin\/jshell<\/strong> and let you guide with the hep (\/help). Example below :<\/p>\n An article that goes into more details : http:\/\/jakubdziworski.github.io\/java\/2016\/07\/31\/jshell-getting-started-examples.html<\/a><\/a><\/p>\n The Project Coin is a project of evolution of the language, started with Java 7, with the purpose of simplification of the usage of the language for the developers, by bringing small modifications in the order of “syntactic sugar”. The JEP213 : Milling Project Coin<\/a> contains the implementation in Java 9 of the last parts of the project.<\/p>\n Before Java 9: <\/strong><\/p>\n In Java 9 :<\/strong><\/p>\n Before : importing a deprecated class generate a warning at compile time, after … no more warning. More info here : http:\/\/openjdk.java.net\/jeps\/211<\/a><\/a><\/p>\n An article on this suject : http:\/\/www.baeldung.com\/java-9-stream-api<\/a><\/a><\/p>\n 4 new methodes have been added to the Optional class :<\/p>\n An article on this subject : http:\/\/www.baeldung.com\/java-9-optional<\/a><\/a><\/p>\n Multiple addons on the Java Time API, among other things the possibility to create streams of dates with LocalDate.datesUntil(LocalDate)<\/strong> and LocalDate.datesUntil(LocalDate, Period)<\/strong>.<\/p>\n More info here : http:\/\/blog.joda.org\/2017\/02\/java-time-jsr-310-enhancements-java-9.html<\/a><\/a><\/p>\n The following JEPs are focused on the performance of the JVM, I will not introduce them in details here (but probably in a next article), here is the list :<\/p>\n Here are the articles that inspires me to write this one :<\/p>\n https:\/\/blogs.oracle.com\/darcy\/resource\/Devoxx\/DevoxxUS-2017-jdk9-lang-tools-libs.pdf<\/a><\/a>\nhttp:\/\/docs.oracle.com\/javase\/9\/whatsnew\/toc.htm#JSNEW-GUID-BA9D8AF6-E706-4327-8909-F6747B8F35C5<\/a><\/a>\nhttp:\/\/blog.takipi.com\/5-features-in-java-9-that-will-change-how-you-develop-software-and-2-that-wont\/<\/a><\/a>\nhttps:\/\/bentolor.github.io\/java9-in-action<\/a><\/a>\nhttp:\/\/www.javaworld.com\/article\/2598480\/core-java\/why-developers-should-get-excited-about-java-9.html<\/a><\/a>\nhttps:\/\/www.sitepoint.com\/ultimate-guide-to-java-9\/<\/a><\/a>\nhttp:\/\/www.javamagazine.mozaicreader.com\/JulyAug2017<\/a><\/a><\/p>","protected":false},"excerpt":{"rendered":" Now that Java 9 is Features Complete, it’s time to look at all the new stuff that this new version will bring us, developers using java. Of course, everybody have heard about the modularization of the JDK (project Jigsaw), a long awaiting project. Well, I’m not going to talk about it here! I will only speak about the new functionalities that target common developers, not the ones that target framework authors or advanced users. First of all, the development of…\n\/\/ Get PIDs of own processes\nSystem.out.println(\"Your pid is \" + ProcessHandle.current().getPid());\n\n\/\/start a new process and get PID\nProcess p = Runtime.getRuntime().exec(\"sleep 1h\");\nProcessHandle h = ProcessHandle.of(p.getPid()).orElseThrow(IllegalStateException::new);\n\n\/\/ Do things on exiting process : CompletableFuture !\nh.onExit().thenRun( () -> System.out.println(\"Sleeper exited\") );\n\n\/\/ Get info on process : return Optional!\nSystem.out.printf(\"[%d] %s - %s\\n\", h.getPid(), h.info().user().orElse(\"unknown\"), \nh.info().commandLine().orElse(\"none\"));\n\n\/\/ Kill a process\nh.destroy();\n<\/pre>\n
JEP 110: HTTP\/2 Client (Incubator)<\/h2>\n
\n\/**\n * The HTTP API functions asynchronously and synchronously. In asynchronous mode, work is done in threads (ExecutorService).\n *\/\npublic static void main(String[] args) throws Exception {\n HttpClient.getDefault()\n .request(URI.create(\"http:\/\/www.loicmathieu.fr\"))\n .GET()\n .responseAsync() \/\/ CompletableFuture\n .thenAccept(httpResponse ->\n System.out.println(httpResponse.body(HttpResponse.asString()))\n );\n Thread.sleep(999); \/\/ Give worker thread some time.\n}\n<\/pre>\nJEP 259: Stack-Walking API<\/h2>\n
\n\/\/ return class\/method only for our classes.\nprivate static List walkAndFilterStackframe() {\n return StackWalker.getInstance().walk(s ->\n s.map( frame -> frame.getClassName() + \"\/\" + frame.getMethodName())\n .filter(name -> name.startsWith(\"fr.loicmathieu\"))\n .limit(10)\n .collect(Collectors.toList()) );\n}\n<\/pre>\nJEP 269: Convenience Factory Methods for Collections<\/h2>\n
\nList listOfNumbers = List.of(1, 2, 3, 4, 5);\n\nSet setOfNumbers = Set.of(1, 2, 3, 4, 5);\n\nMap mapOfString =\n Map.of(\"key1\", \"value1\", \"key2\", \"value2\");\n\nMap moreMapOfString =\n Map.ofEntries(\n Map.entry(\"key1\", \"value1\"),\n Map.entry(\"key2\", \"value2\"),\n Map.entry(\"key1\", \"value3\")\n);\n<\/pre>\n
JEP 266: More Concurrency Updates<\/h2>\n
Publisher : <\/code>Publish messages that the subscribers will consume. The only method is\u00a0subscribe(Subscriber).<\/code><\/li>\n\nSubscriber : <\/code>Subscribe to a publisher for receiving messages (via the method\u00a0onNext(T)<\/code>), error messages (onError(Throwable)<\/code>), or a signal that there will be no more messages\u00a0(onComplete()<\/code>). Before anything else, the publisher needs to call \u00a0onSubscription(Subscription)<\/code>.<\/li>\n\nSubscription : <\/code>The connection between a publisher and a subscriber. The subscriber will use it for asking for messages (request(long)<\/code>) or cutting the connection\u00a0(cancel()<\/code>).<\/li>\n<\/ul>\n\npublic class MySubscriber implements Subscriber { \n private Subscription subscription; \n\n @Override \n public void onSubscribe(Subscription subscription) { \n this.subscription = subscription; \n subscription.request(1); \/\/a value of Long.MAX_VALUE may be considered as effectively unbounded \n } \n\n @Override \n public void onNext(T item) { \n System.out.println(\"Got : \" + item); \n subscription.request(1); \/\/a value of Long.MAX_VALUE may be considered as effectively unbounded \n } \n\n @Override \n public void onError(Throwable t) { \n t.printStackTrace(); \n } \n\n @Override \n public void onComplete() { \n System.out.println(\"Done\"); \n } \n} \n<\/pre>\n\n \/\/Create Publisher \n SubmissionPublisher publisher = new SubmissionPublisher(); \n\n \/\/Register Subscriber \n MySubscriber subscriber = new MySubscriber(); \n publisher.subscribe(subscriber); \n\n \/\/Publish items \n System.out.println(\"Publishing Items...\"); \n String[] items = {\"1\", \"x\", \"2\", \"x\", \"3\", \"x\"}; \n Arrays.asList(items).stream().forEach(i -> publisher.submit(i)); \n publisher.close(); \n<\/pre>\nJEP 277: Enhanced Deprecation<\/h2>\n
\n@Deprecated(since=\"9\", forRemoval=true)\npublic class MyDeprecatedClass {\n \/\/deprecated stuff\n}\n<\/pre>\nJEP 222: jshell: The Java Shell (Read-Eval-Print Loop)<\/h2>\n
![\"jshell](\"https:\/\/i0.wp.com\/loicmathieu.fr\/wordpress\/wp-content\/uploads\/jshell.png?resize=502%2C353\")
JEP 213: Milling Project Coin<\/h2>\n
\nfinal Resource r = new Resource(); \ntry (Resource r2 = r) { \u2026 }\n<\/pre>\n\nfinal Resource r = new Resource(); \ntry (r) { \u2026 \/\/ Cannot mutate r }\n<\/pre>\nJEP 211 : Elide Deprecation Warnings on Import Statements<\/h2>\n
A lot of other changes, outside any JEP :<\/h2>\n
Stream & Collectors:<\/h3>\n
\n\/\/iterate\n\/java 8 style : using for loop\nfor (int i = 0; i i i + 1).forEach(System.out::println);\n\n\/\/takeWhile and dropWhile\nStream stream = Stream.iterate(\"\", s -> s + \"s\")\nstream.takeWhile(s -> s.length() !s.contains(\"sssss\"));\n\n\/\/ofNullable : returning Stream.empty() for null element\n\/\/java 8 style : we need to make a check to know if it's null or not\ncollection.stream()\n .flatMap(s -> {\n Integer temp = map.get(s);\n return temp != null ? Stream.of(temp) : Stream.empty();\n })\n .collect(Collectors.toList());\n\n\/\/java 9 style\ncollection.stream().flatMap(s -> Stream.ofNullable(map.get(s))).collect(Collectors.toList());\n<\/pre>\n\nList numbers = List.of(1, 2, 3, 5, 5);\n\nMap result = numbers.stream()\n .filter(val -> val > 3)\n .collect(Collectors.groupingBy(i ->; i, Collectors.counting()));\n\nresult = numbers.stream()\n .collect(Collectors.groupingBy(i -> i, \n Collectors.filtering(val -> val > 3, Collectors.counting())\n ));\n<\/pre>\n
Optional<\/h3>\n
\n\/\/Optional.or : a lazy version of orElse\nOptional value = ...;\nOptional defaultValue = Optional.of(() -> bigComputation());\nreturn value.or(defaultValue);\/\/bigComputation will be called only if value is empty\n\n\/\/Optional.ifPresent : \nOptional value = ...;\nAtomicInteger successCounter = new AtomicInteger(0);\nvalue.ifPresent(\n v -> successCounter.incrementAndGet());\n\n\/\/Optional.ifPresentOrElse : \nOptional value = ...;\nAtomicInteger successCounter = new AtomicInteger(0);\nAtomicInteger onEmptyOptionalCounter = new AtomicInteger(0);\nvalue.ifPresentOrElse(\n v -> successCounter.incrementAndGet(), \n onEmptyOptionalCounter::incrementAndGet);\n\n\/\/Optional.stream : unify the stream and Optional API\nOptional value = Optional.of(\"a\");\nList collect = value.stream().map(String::toUpperCase).collect(Collectors.toList()); \/\/[\"A\"]\n<\/pre>\n
Java Time :<\/h3>\n
Others :<\/h3>\n
Performance\u00a0:<\/h2>\n
Links :<\/h2>\n