[
{
"path": ".gitignore",
"content": ".DS_Store\n.idea\n*.iml\nout\n/bin/\n"
},
{
"path": "LICENSE",
"content": "The MIT License (MIT)\n\nCopyright (c) 2023 Benjamin Winterberg\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README.md",
"content": "# Modern Java - A Guide to Java 8\n_This article was originally posted on [my blog](http://winterbe.com/posts/2014/03/16/java-8-tutorial/)._\n\n> **You should also read my [Java 11 Tutorial](https://winterbe.com/posts/2018/09/24/java-11-tutorial/) (including new language and API features from Java 9, 10 and 11).**\n\nWelcome to my introduction to [Java 8](https://jdk8.java.net/). This tutorial guides you step by step through all new language features. Backed by short and simple code samples you'll learn how to use default interface methods, lambda expressions, method references and repeatable annotations. At the end of the article you'll be familiar with the most recent [API](http://download.java.net/jdk8/docs/api/) changes like streams, functional interfaces, map extensions and the new Date API. **No walls of text, just a bunch of commented code snippets. Enjoy!**\n\n---\n\n
\n ★★★ Like this project? Leave a star, follow on Twitter or donate to support my work. Thanks! ★★★\n
\n\n---\n\n## Table of Contents\n\n* [Default Methods for Interfaces](#default-methods-for-interfaces)\n* [Lambda expressions](#lambda-expressions)\n* [Functional Interfaces](#functional-interfaces)\n* [Method and Constructor References](#method-and-constructor-references)\n* [Lambda Scopes](#lambda-scopes)\n * [Accessing local variables](#accessing-local-variables)\n * [Accessing fields and static variables](#accessing-fields-and-static-variables)\n * [Accessing Default Interface Methods](#accessing-default-interface-methods)\n* [Built-in Functional Interfaces](#built-in-functional-interfaces)\n * [Predicates](#predicates)\n * [Functions](#functions)\n * [Suppliers](#suppliers)\n * [Consumers](#consumers)\n * [Comparators](#comparators)\n* [Optionals](#optionals)\n* [Streams](#streams)\n * [Filter](#filter)\n * [Sorted](#sorted)\n * [Map](#map)\n * [Match](#match)\n * [Count](#count)\n * [Reduce](#reduce)\n* [Parallel Streams](#parallel-streams)\n * [Sequential Sort](#sequential-sort)\n * [Parallel Sort](#parallel-sort)\n* [Maps](#maps)\n* [Date API](#date-api)\n * [Clock](#clock)\n * [Timezones](#timezones)\n * [LocalTime](#localtime)\n * [LocalDate](#localdate)\n * [LocalDateTime](#localdatetime)\n* [Annotations](#annotations)\n* [Where to go from here?](#where-to-go-from-here)\n\n## Default Methods for Interfaces\n\nJava 8 enables us to add non-abstract method implementations to interfaces by utilizing the `default` keyword. This feature is also known as [virtual extension methods](http://stackoverflow.com/a/24102730). \n\nHere is our first example:\n\n```java\ninterface Formula {\n double calculate(int a);\n\n default double sqrt(int a) {\n return Math.sqrt(a);\n }\n}\n```\n\nBesides the abstract method `calculate` the interface `Formula` also defines the default method `sqrt`. Concrete classes only have to implement the abstract method `calculate`. The default method `sqrt` can be used out of the box.\n\n```java\nFormula formula = new Formula() {\n @Override\n public double calculate(int a) {\n return sqrt(a * 100);\n }\n};\n\nformula.calculate(100); // 100.0\nformula.sqrt(16); // 4.0\n```\n\nThe formula is implemented as an anonymous object. The code is quite verbose: 6 lines of code for such a simple calculation of `sqrt(a * 100)`. As we'll see in the next section, there's a much nicer way of implementing single method objects in Java 8.\n\n\n## Lambda expressions\n\nLet's start with a simple example of how to sort a list of strings in prior versions of Java:\n\n```java\nList names = Arrays.asList(\"peter\", \"anna\", \"mike\", \"xenia\");\n\nCollections.sort(names, new Comparator() {\n @Override\n public int compare(String a, String b) {\n return b.compareTo(a);\n }\n});\n```\n\nThe static utility method `Collections.sort` accepts a list and a comparator in order to sort the elements of the given list. You often find yourself creating anonymous comparators and pass them to the sort method.\n\nInstead of creating anonymous objects all day long, Java 8 comes with a much shorter syntax, **lambda expressions**:\n\n```java\nCollections.sort(names, (String a, String b) -> {\n return b.compareTo(a);\n});\n```\n\nAs you can see the code is much shorter and easier to read. But it gets even shorter:\n\n```java\nCollections.sort(names, (String a, String b) -> b.compareTo(a));\n```\n\nFor one line method bodies you can skip both the braces `{}` and the `return` keyword. But it gets even shorter:\n\n```java\nnames.sort((a, b) -> b.compareTo(a));\n```\n\nList now has a `sort` method. Also the java compiler is aware of the parameter types so you can skip them as well. Let's dive deeper into how lambda expressions can be used in the wild.\n\n\n## Functional Interfaces\n\nHow does lambda expressions fit into Java's type system? Each lambda corresponds to a given type, specified by an interface. A so called _functional interface_ must contain **exactly one abstract method** declaration. Each lambda expression of that type will be matched to this abstract method. Since default methods are not abstract you're free to add default methods to your functional interface.\n\nWe can use arbitrary interfaces as lambda expressions as long as the interface only contains one abstract method. To ensure that your interface meet the requirements, you should add the `@FunctionalInterface` annotation. The compiler is aware of this annotation and throws a compiler error as soon as you try to add a second abstract method declaration to the interface.\n\nExample:\n\n```java\n@FunctionalInterface\ninterface Converter {\n T convert(F from);\n}\n```\n\n```java\nConverter converter = (from) -> Integer.valueOf(from);\nInteger converted = converter.convert(\"123\");\nSystem.out.println(converted); // 123\n```\n\nKeep in mind that the code is also valid if the `@FunctionalInterface` annotation would be omitted.\n\n\n## Method and Constructor References\n\nThe above example code can be further simplified by utilizing static method references:\n\n```java\nConverter converter = Integer::valueOf;\nInteger converted = converter.convert(\"123\");\nSystem.out.println(converted); // 123\n```\n\nJava 8 enables you to pass references of methods or constructors via the `::` keyword. The above example shows how to reference a static method. But we can also reference object methods:\n\n```java\nclass Something {\n String startsWith(String s) {\n return String.valueOf(s.charAt(0));\n }\n}\n```\n\n```java\nSomething something = new Something();\nConverter converter = something::startsWith;\nString converted = converter.convert(\"Java\");\nSystem.out.println(converted); // \"J\"\n```\n\nLet's see how the `::` keyword works for constructors. First we define an example class with different constructors:\n\n```java\nclass Person {\n String firstName;\n String lastName;\n\n Person() {}\n\n Person(String firstName, String lastName) {\n this.firstName = firstName;\n this.lastName = lastName;\n }\n}\n```\n\nNext we specify a person factory interface to be used for creating new persons:\n\n```java\ninterface PersonFactory
{\n P create(String firstName, String lastName);\n}\n```\n\nInstead of implementing the factory manually, we glue everything together via constructor references:\n\n```java\nPersonFactory personFactory = Person::new;\nPerson person = personFactory.create(\"Peter\", \"Parker\");\n```\n\nWe create a reference to the Person constructor via `Person::new`. The Java compiler automatically chooses the right constructor by matching the signature of `PersonFactory.create`.\n\n## Lambda Scopes\n\nAccessing outer scope variables from lambda expressions is very similar to anonymous objects. You can access final variables from the local outer scope as well as instance fields and static variables.\n\n### Accessing local variables\n\nWe can read final local variables from the outer scope of lambda expressions:\n\n```java\nfinal int num = 1;\nConverter stringConverter =\n (from) -> String.valueOf(from + num);\n\nstringConverter.convert(2); // 3\n```\n\nBut different to anonymous objects the variable `num` does not have to be declared final. This code is also valid:\n\n```java\nint num = 1;\nConverter stringConverter =\n (from) -> String.valueOf(from + num);\n\nstringConverter.convert(2); // 3\n```\n\nHowever `num` must be implicitly final for the code to compile. The following code does **not** compile:\n\n```java\nint num = 1;\nConverter stringConverter =\n (from) -> String.valueOf(from + num);\nnum = 3;\n```\n\nWriting to `num` from within the lambda expression is also prohibited.\n\n### Accessing fields and static variables\n\nIn contrast to local variables, we have both read and write access to instance fields and static variables from within lambda expressions. This behaviour is well known from anonymous objects.\n\n```java\nclass Lambda4 {\n static int outerStaticNum;\n int outerNum;\n\n void testScopes() {\n Converter stringConverter1 = (from) -> {\n outerNum = 23;\n return String.valueOf(from);\n };\n\n Converter stringConverter2 = (from) -> {\n outerStaticNum = 72;\n return String.valueOf(from);\n };\n }\n}\n```\n\n### Accessing Default Interface Methods\n\nRemember the formula example from the first section? Interface `Formula` defines a default method `sqrt` which can be accessed from each formula instance including anonymous objects. This does not work with lambda expressions.\n\nDefault methods **cannot** be accessed from within lambda expressions. The following code does not compile:\n\n```java\nFormula formula = (a) -> sqrt(a * 100);\n```\n\n\n## Built-in Functional Interfaces\n\nThe JDK 1.8 API contains many built-in functional interfaces. Some of them are well known from older versions of Java like `Comparator` or `Runnable`. Those existing interfaces are extended to enable Lambda support via the `@FunctionalInterface` annotation.\n\nBut the Java 8 API is also full of new functional interfaces to make your life easier. Some of those new interfaces are well known from the [Google Guava](https://code.google.com/p/guava-libraries/) library. Even if you're familiar with this library you should keep a close eye on how those interfaces are extended by some useful method extensions.\n\n### Predicates\n\nPredicates are boolean-valued functions of one argument. The interface contains various default methods for composing predicates to complex logical terms (and, or, negate)\n\n```java\nPredicate predicate = (s) -> s.length() > 0;\n\npredicate.test(\"foo\"); // true\npredicate.negate().test(\"foo\"); // false\n\nPredicate nonNull = Objects::nonNull;\nPredicate isNull = Objects::isNull;\n\nPredicate isEmpty = String::isEmpty;\nPredicate isNotEmpty = isEmpty.negate();\n```\n\n### Functions\n\nFunctions accept one argument and produce a result. Default methods can be used to chain multiple functions together (compose, andThen).\n\n```java\nFunction toInteger = Integer::valueOf;\nFunction backToString = toInteger.andThen(String::valueOf);\n\nbackToString.apply(\"123\"); // \"123\"\n```\n\n### Suppliers\n\nSuppliers produce a result of a given generic type. Unlike Functions, Suppliers don't accept arguments.\n\n```java\nSupplier personSupplier = Person::new;\npersonSupplier.get(); // new Person\n```\n\n### Consumers\n\nConsumers represent operations to be performed on a single input argument.\n\n```java\nConsumer greeter = (p) -> System.out.println(\"Hello, \" + p.firstName);\ngreeter.accept(new Person(\"Luke\", \"Skywalker\"));\n```\n\n### Comparators\n\nComparators are well known from older versions of Java. Java 8 adds various default methods to the interface.\n\n```java\nComparator comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);\n\nPerson p1 = new Person(\"John\", \"Doe\");\nPerson p2 = new Person(\"Alice\", \"Wonderland\");\n\ncomparator.compare(p1, p2); // > 0\ncomparator.reversed().compare(p1, p2); // < 0\n```\n\n## Optionals\n\nOptionals are not functional interfaces, but nifty utilities to prevent `NullPointerException`. It's an important concept for the next section, so let's have a quick look at how Optionals work.\n\nOptional is a simple container for a value which may be null or non-null. Think of a method which may return a non-null result but sometimes return nothing. Instead of returning `null` you return an `Optional` in Java 8.\n\n```java\nOptional optional = Optional.of(\"bam\");\n\noptional.isPresent(); // true\noptional.get(); // \"bam\"\noptional.orElse(\"fallback\"); // \"bam\"\n\noptional.ifPresent((s) -> System.out.println(s.charAt(0))); // \"b\"\n```\n\n## Streams\n\nA `java.util.Stream` represents a sequence of elements on which one or more operations can be performed. Stream operations are either _intermediate_ or _terminal_. While terminal operations return a result of a certain type, intermediate operations return the stream itself so you can chain multiple method calls in a row. Streams are created on a source, e.g. a `java.util.Collection` like lists or sets (maps are not supported). Stream operations can either be executed sequentially or parallely.\n\n> Streams are extremely powerful, so I wrote a separate [Java 8 Streams Tutorial](http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/). **You should also check out [Sequency](https://github.com/winterbe/sequency) as a similiar library for the web.**\n\nLet's first look how sequential streams work. First we create a sample source in form of a list of strings:\n\n```java\nList stringCollection = new ArrayList<>();\nstringCollection.add(\"ddd2\");\nstringCollection.add(\"aaa2\");\nstringCollection.add(\"bbb1\");\nstringCollection.add(\"aaa1\");\nstringCollection.add(\"bbb3\");\nstringCollection.add(\"ccc\");\nstringCollection.add(\"bbb2\");\nstringCollection.add(\"ddd1\");\n```\n\nCollections in Java 8 are extended so you can simply create streams either by calling `Collection.stream()` or `Collection.parallelStream()`. The following sections explain the most common stream operations.\n\n### Filter\n\nFilter accepts a predicate to filter all elements of the stream. This operation is _intermediate_ which enables us to call another stream operation (`forEach`) on the result. ForEach accepts a consumer to be executed for each element in the filtered stream. ForEach is a terminal operation. It's `void`, so we cannot call another stream operation.\n\n```java\nstringCollection\n .stream()\n .filter((s) -> s.startsWith(\"a\"))\n .forEach(System.out::println);\n\n// \"aaa2\", \"aaa1\"\n```\n\n### Sorted\n\nSorted is an _intermediate_ operation which returns a sorted view of the stream. The elements are sorted in natural order unless you pass a custom `Comparator`.\n\n```java\nstringCollection\n .stream()\n .sorted()\n .filter((s) -> s.startsWith(\"a\"))\n .forEach(System.out::println);\n\n// \"aaa1\", \"aaa2\"\n```\n\nKeep in mind that `sorted` does only create a sorted view of the stream without manipulating the ordering of the backed collection. The ordering of `stringCollection` is untouched:\n\n```java\nSystem.out.println(stringCollection);\n// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1\n```\n\n### Map\n\nThe _intermediate_ operation `map` converts each element into another object via the given function. The following example converts each string into an upper-cased string. But you can also use `map` to transform each object into another type. The generic type of the resulting stream depends on the generic type of the function you pass to `map`.\n\n```java\nstringCollection\n .stream()\n .map(String::toUpperCase)\n .sorted((a, b) -> b.compareTo(a))\n .forEach(System.out::println);\n\n// \"DDD2\", \"DDD1\", \"CCC\", \"BBB3\", \"BBB2\", \"AAA2\", \"AAA1\"\n```\n\n### Match\n\nVarious matching operations can be used to check whether a certain predicate matches the stream. All of those operations are _terminal_ and return a boolean result.\n\n```java\nboolean anyStartsWithA =\n stringCollection\n .stream()\n .anyMatch((s) -> s.startsWith(\"a\"));\n\nSystem.out.println(anyStartsWithA); // true\n\nboolean allStartsWithA =\n stringCollection\n .stream()\n .allMatch((s) -> s.startsWith(\"a\"));\n\nSystem.out.println(allStartsWithA); // false\n\nboolean noneStartsWithZ =\n stringCollection\n .stream()\n .noneMatch((s) -> s.startsWith(\"z\"));\n\nSystem.out.println(noneStartsWithZ); // true\n```\n\n#### Count\n\nCount is a _terminal_ operation returning the number of elements in the stream as a `long`.\n\n```java\nlong startsWithB =\n stringCollection\n .stream()\n .filter((s) -> s.startsWith(\"b\"))\n .count();\n\nSystem.out.println(startsWithB); // 3\n```\n\n\n### Reduce\n\nThis _terminal_ operation performs a reduction on the elements of the stream with the given function. The result is an `Optional` holding the reduced value.\n\n```java\nOptional reduced =\n stringCollection\n .stream()\n .sorted()\n .reduce((s1, s2) -> s1 + \"#\" + s2);\n\nreduced.ifPresent(System.out::println);\n// \"aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2\"\n```\n\n## Parallel Streams\n\nAs mentioned above streams can be either sequential or parallel. Operations on sequential streams are performed on a single thread while operations on parallel streams are performed concurrently on multiple threads.\n\nThe following example demonstrates how easy it is to increase the performance by using parallel streams.\n\nFirst we create a large list of unique elements:\n\n```java\nint max = 1000000;\nList values = new ArrayList<>(max);\nfor (int i = 0; i < max; i++) {\n UUID uuid = UUID.randomUUID();\n values.add(uuid.toString());\n}\n```\n\nNow we measure the time it takes to sort a stream of this collection.\n\n### Sequential Sort\n\n```java\nlong t0 = System.nanoTime();\n\nlong count = values.stream().sorted().count();\nSystem.out.println(count);\n\nlong t1 = System.nanoTime();\n\nlong millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);\nSystem.out.println(String.format(\"sequential sort took: %d ms\", millis));\n\n// sequential sort took: 899 ms\n```\n\n### Parallel Sort\n\n```java\nlong t0 = System.nanoTime();\n\nlong count = values.parallelStream().sorted().count();\nSystem.out.println(count);\n\nlong t1 = System.nanoTime();\n\nlong millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);\nSystem.out.println(String.format(\"parallel sort took: %d ms\", millis));\n\n// parallel sort took: 472 ms\n```\n\nAs you can see both code snippets are almost identical but the parallel sort is roughly 50% faster. All you have to do is change `stream()` to `parallelStream()`.\n\n## Maps\n\nAs already mentioned maps do not directly support streams. There's no `stream()` method available on the `Map` interface itself, however you can create specialized streams upon the keys, values or entries of a map via `map.keySet().stream()`, `map.values().stream()` and `map.entrySet().stream()`. \n\nFurthermore maps support various new and useful methods for doing common tasks.\n\n```java\nMap map = new HashMap<>();\n\nfor (int i = 0; i < 10; i++) {\n map.putIfAbsent(i, \"val\" + i);\n}\n\nmap.forEach((id, val) -> System.out.println(val));\n```\n\nThe above code should be self-explaining: `putIfAbsent` prevents us from writing additional if null checks; `forEach` accepts a consumer to perform operations for each value of the map.\n\nThis example shows how to compute code on the map by utilizing functions:\n\n```java\nmap.computeIfPresent(3, (num, val) -> val + num);\nmap.get(3); // val33\n\nmap.computeIfPresent(9, (num, val) -> null);\nmap.containsKey(9); // false\n\nmap.computeIfAbsent(23, num -> \"val\" + num);\nmap.containsKey(23); // true\n\nmap.computeIfAbsent(3, num -> \"bam\");\nmap.get(3); // val33\n```\n\nNext, we learn how to remove entries for a given key, only if it's currently mapped to a given value:\n\n```java\nmap.remove(3, \"val3\");\nmap.get(3); // val33\n\nmap.remove(3, \"val33\");\nmap.get(3); // null\n```\n\nAnother helpful method:\n\n```java\nmap.getOrDefault(42, \"not found\"); // not found\n```\n\nMerging entries of a map is quite easy:\n\n```java\nmap.merge(9, \"val9\", (value, newValue) -> value.concat(newValue));\nmap.get(9); // val9\n\nmap.merge(9, \"concat\", (value, newValue) -> value.concat(newValue));\nmap.get(9); // val9concat\n```\n\nMerge either put the key/value into the map if no entry for the key exists, or the merging function will be called to change the existing value.\n\n\n## Date API\n\nJava 8 contains a brand new date and time API under the package `java.time`. The new Date API is comparable with the [Joda-Time](http://www.joda.org/joda-time/) library, however it's [not the same](http://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html). The following examples cover the most important parts of this new API.\n\n### Clock\n\nClock provides access to the current date and time. Clocks are aware of a timezone and may be used instead of `System.currentTimeMillis()` to retrieve the current time in milliseconds since Unix EPOCH. Such an instantaneous point on the time-line is also represented by the class `Instant`. Instants can be used to create legacy `java.util.Date` objects.\n\n```java\nClock clock = Clock.systemDefaultZone();\nlong millis = clock.millis();\n\nInstant instant = clock.instant();\nDate legacyDate = Date.from(instant); // legacy java.util.Date\n```\n\n### Timezones\n\nTimezones are represented by a `ZoneId`. They can easily be accessed via static factory methods. Timezones define the offsets which are important to convert between instants and local dates and times.\n\n```java\nSystem.out.println(ZoneId.getAvailableZoneIds());\n// prints all available timezone ids\n\nZoneId zone1 = ZoneId.of(\"Europe/Berlin\");\nZoneId zone2 = ZoneId.of(\"Brazil/East\");\nSystem.out.println(zone1.getRules());\nSystem.out.println(zone2.getRules());\n\n// ZoneRules[currentStandardOffset=+01:00]\n// ZoneRules[currentStandardOffset=-03:00]\n```\n\n### LocalTime\n\nLocalTime represents a time without a timezone, e.g. 10pm or 17:30:15. The following example creates two local times for the timezones defined above. Then we compare both times and calculate the difference in hours and minutes between both times.\n\n```java\nLocalTime now1 = LocalTime.now(zone1);\nLocalTime now2 = LocalTime.now(zone2);\n\nSystem.out.println(now1.isBefore(now2)); // false\n\nlong hoursBetween = ChronoUnit.HOURS.between(now1, now2);\nlong minutesBetween = ChronoUnit.MINUTES.between(now1, now2);\n\nSystem.out.println(hoursBetween); // -3\nSystem.out.println(minutesBetween); // -239\n```\n\nLocalTime comes with various factory methods to simplify the creation of new instances, including parsing of time strings.\n\n```java\nLocalTime late = LocalTime.of(23, 59, 59);\nSystem.out.println(late); // 23:59:59\n\nDateTimeFormatter germanFormatter =\n DateTimeFormatter\n .ofLocalizedTime(FormatStyle.SHORT)\n .withLocale(Locale.GERMAN);\n\nLocalTime leetTime = LocalTime.parse(\"13:37\", germanFormatter);\nSystem.out.println(leetTime); // 13:37\n```\n\n### LocalDate\n\nLocalDate represents a distinct date, e.g. 2014-03-11. It's immutable and works exactly analog to LocalTime. The sample demonstrates how to calculate new dates by adding or subtracting days, months or years. Keep in mind that each manipulation returns a new instance.\n\n```java\nLocalDate today = LocalDate.now();\nLocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);\nLocalDate yesterday = tomorrow.minusDays(2);\n\nLocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);\nDayOfWeek dayOfWeek = independenceDay.getDayOfWeek();\nSystem.out.println(dayOfWeek); // FRIDAY\n```\n\nParsing a LocalDate from a string is just as simple as parsing a LocalTime:\n\n```java\nDateTimeFormatter germanFormatter =\n DateTimeFormatter\n .ofLocalizedDate(FormatStyle.MEDIUM)\n .withLocale(Locale.GERMAN);\n\nLocalDate xmas = LocalDate.parse(\"24.12.2014\", germanFormatter);\nSystem.out.println(xmas); // 2014-12-24\n```\n\n### LocalDateTime\n\nLocalDateTime represents a date-time. It combines date and time as seen in the above sections into one instance. `LocalDateTime` is immutable and works similar to LocalTime and LocalDate. We can utilize methods for retrieving certain fields from a date-time:\n\n```java\nLocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);\n\nDayOfWeek dayOfWeek = sylvester.getDayOfWeek();\nSystem.out.println(dayOfWeek); // WEDNESDAY\n\nMonth month = sylvester.getMonth();\nSystem.out.println(month); // DECEMBER\n\nlong minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);\nSystem.out.println(minuteOfDay); // 1439\n```\n\nWith the additional information of a timezone it can be converted to an instant. Instants can easily be converted to legacy dates of type `java.util.Date`.\n\n```java\nInstant instant = sylvester\n .atZone(ZoneId.systemDefault())\n .toInstant();\n\nDate legacyDate = Date.from(instant);\nSystem.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014\n```\n\nFormatting date-times works just like formatting dates or times. Instead of using pre-defined formats we can create formatters from custom patterns.\n\n```java\nDateTimeFormatter formatter =\n DateTimeFormatter\n .ofPattern(\"MMM dd, yyyy - HH:mm\");\n\nLocalDateTime parsed = LocalDateTime.parse(\"Nov 03, 2014 - 07:13\", formatter);\nString string = formatter.format(parsed);\nSystem.out.println(string); // Nov 03, 2014 - 07:13\n```\n\nUnlike `java.text.NumberFormat` the new `DateTimeFormatter` is immutable and **thread-safe**.\n\nFor details on the pattern syntax read [here](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html).\n\n\n## Annotations\n\nAnnotations in Java 8 are repeatable. Let's dive directly into an example to figure that out.\n\nFirst, we define a wrapper annotation which holds an array of the actual annotations:\n\n```java\n@interface Hints {\n Hint[] value();\n}\n\n@Repeatable(Hints.class)\n@interface Hint {\n String value();\n}\n```\nJava 8 enables us to use multiple annotations of the same type by declaring the annotation `@Repeatable`.\n\n### Variant 1: Using the container annotation (old school)\n\n```java\n@Hints({@Hint(\"hint1\"), @Hint(\"hint2\")})\nclass Person {}\n```\n\n### Variant 2: Using repeatable annotations (new school)\n\n```java\n@Hint(\"hint1\")\n@Hint(\"hint2\")\nclass Person {}\n```\n\nUsing variant 2 the java compiler implicitly sets up the `@Hints` annotation under the hood. That's important for reading annotation information via reflection.\n\n```java\nHint hint = Person.class.getAnnotation(Hint.class);\nSystem.out.println(hint); // null\n\nHints hints1 = Person.class.getAnnotation(Hints.class);\nSystem.out.println(hints1.value().length); // 2\n\nHint[] hints2 = Person.class.getAnnotationsByType(Hint.class);\nSystem.out.println(hints2.length); // 2\n```\n\nAlthough we never declared the `@Hints` annotation on the `Person` class, it's still readable via `getAnnotation(Hints.class)`. However, the more convenient method is `getAnnotationsByType` which grants direct access to all annotated `@Hint` annotations.\n\n\nFurthermore the usage of annotations in Java 8 is expanded to two new targets:\n\n```java\n@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})\n@interface MyAnnotation {}\n```\n\n## Where to go from here?\n\nMy programming guide to Java 8 ends here. If you want to learn more about all the new classes and features of the JDK 8 API, check out my [JDK8 API Explorer](http://winterbe.com/projects/java8-explorer/). It helps you figuring out all the new classes and hidden gems of JDK 8, like `Arrays.parallelSort`, `StampedLock` and `CompletableFuture` - just to name a few.\n\nI've also published a bunch of follow-up articles on my [blog](http://winterbe.com) that might be interesting to you:\n\n- [Java 8 Stream Tutorial](http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/)\n- [Java 8 Nashorn Tutorial](http://winterbe.com/posts/2014/04/05/java8-nashorn-tutorial/)\n- [Java 8 Concurrency Tutorial: Threads and Executors](http://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread-executor-examples/)\n- [Java 8 Concurrency Tutorial: Synchronization and Locks](http://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/)\n- [Java 8 Concurrency Tutorial: Atomic Variables and ConcurrentMap](http://winterbe.com/posts/2015/05/22/java8-concurrency-tutorial-atomic-concurrent-map-examples/)\n- [Java 8 API by Example: Strings, Numbers, Math and Files](http://winterbe.com/posts/2015/03/25/java8-examples-string-number-math-files/)\n- [Avoid Null Checks in Java 8](http://winterbe.com/posts/2015/03/15/avoid-null-checks-in-java/)\n- [Fixing Java 8 Stream Gotchas with IntelliJ IDEA](http://winterbe.com/posts/2015/03/05/fixing-java-8-stream-gotchas-with-intellij-idea/)\n- [Using Backbone.js with Java 8 Nashorn](http://winterbe.com/posts/2014/04/07/using-backbonejs-with-nashorn/)\n\nYou should [follow me on Twitter](https://twitter.com/winterbe_). Thanks for reading!\n"
},
{
"path": "res/nashorn1.js",
"content": "var fun1 = function(name) {\n print('Hi there from Javascript, ' + name);\n return \"greetings from javascript\";\n};\n\nvar fun2 = function (object) {\n print(\"JS Class Definition: \" + Object.prototype.toString.call(object));\n};"
},
{
"path": "res/nashorn10.js",
"content": "var results = [];\n\nvar Context = function () {\n this.foo = 'bar';\n};\n\nContext.prototype.testArgs = function () {\n if (arguments[0]) {\n results.push(true);\n }\n if (arguments[1]) {\n results.push(true);\n }\n if (arguments[2]) {\n results.push(true);\n }\n if (arguments[3]) {\n results.push(true);\n }\n};\n\nvar testPerf = function () {\n var context = new Context();\n context.testArgs();\n context.testArgs(1);\n context.testArgs(1, 2);\n context.testArgs(1, 2, 3);\n context.testArgs(1, 2, 3, 4);\n};"
},
{
"path": "res/nashorn2.js",
"content": "var Nashorn2 = Java.type('com.winterbe.java8.samples.nashorn.Nashorn2');\nvar result = Nashorn2.fun('John Doe');\nprint('\\n' + result);\n\nNashorn2.fun2(123);\nNashorn2.fun2(49.99);\nNashorn2.fun2(true);\nNashorn2.fun2(\"hi there\")\nNashorn2.fun2(String(\"bam\"))\nNashorn2.fun2(new Number(23));\nNashorn2.fun2(new Date());\nNashorn2.fun2(new RegExp());\nNashorn2.fun2({foo: 'bar'});\n\n\nprint('passing object hash:');\nNashorn2.fun3({\n foo: 'bar',\n bar: 'foo'\n});\n\n\nprint('passing custom person object:');\n\nfunction Person(firstName, lastName) {\n this.firstName = firstName;\n this.lastName = lastName;\n this.getFullName = function() {\n return this.firstName + \" \" + this.lastName;\n }\n}\n\nvar person1 = new Person(\"Peter\", \"Parker\");\nNashorn2.fun3(person1);\nNashorn2.fun4(person1);"
},
{
"path": "res/nashorn3.js",
"content": "print('------------------');\nprint('IntArray:');\n\nvar IntArray = Java.type('int[]');\n\nvar array = new IntArray(5);\narray[0] = 5;\narray[1] = 4;\narray[2] = 3;\narray[3] = 2;\narray[4] = 1;\n\ntry {\n array[5] = 23;\n} catch (e) {\n print(e.message);\n}\n\narray[0] = \"17\";\nprint(array[0]);\n\narray[0] = \"wrong type\";\nprint(array[0]);\n\narray[0] = \"17.3\";\nprint(array[0]);\n\nprint('------------------');\n\nfor (var i in array) print(i);\n\nprint('------------------');\n\nfor each (var val in array) print(val);\n\nprint('------------------');\nprint('ArrayList:');\n\nvar ArrayList = Java.type('java.util.ArrayList');\n\nvar list = new ArrayList();\nlist.add('a');\nlist.add('b');\nlist.add('c');\n\nfor each (var el in list) print(el);\n\n\nprint('------------------');\nprint('HashMap:');\n\nvar HashMap = Java.type('java.util.HashMap');\n\nvar map = new HashMap();\nmap.put('foo', 'foo1');\nmap.put('bar', 'bar1');\n\nfor each(var e in map.keySet()) print(e);\n\nfor each(var e in map.values()) print(e);\n\n\nprint('------------------');\nprint('Streams:');\n\nvar list2 = new ArrayList();\nlist2.add(\"ddd2\");\nlist2.add(\"aaa2\");\nlist2.add(\"bbb1\");\nlist2.add(\"aaa1\");\nlist2.add(\"bbb3\");\nlist2.add(\"ccc\");\nlist2.add(\"bbb2\");\nlist2.add(\"ddd1\");\n\nlist2\n .stream()\n .filter(function(el) {\n return el.startsWith(\"aaa\");\n })\n .sorted()\n .forEach(function(el) {\n print(el);\n });\n\n\n\nprint('------------------');\nprint('Extend:');\n\nvar Runnable = Java.type('java.lang.Runnable');\nvar Printer = Java.extend(Runnable, {\n run: function() {\n print('This was printed from a seperate thread.');\n }\n});\n\nvar Thread = Java.type('java.lang.Thread');\nnew Thread(new Printer()).start();\n\nnew Thread(function() {\n print('this was printed from another thread');\n}).start();\n\n\nprint('------------------');\nprint('Parameter Overload:');\n\nvar System = Java.type('java.lang.System');\n\nSystem.out.println(10);\nSystem.out[\"println\"](11.0);\nSystem.out[\"println(double)\"](12);\n\nprint('------------------');\nprint('JavaBeans:');\n\nvar Date = Java.type('java.util.Date');\nvar date = new Date();\ndate.year += 1900;\nSystem.out.println(date.year);"
},
{
"path": "res/nashorn4.js",
"content": "// function literal with no braces\n\nfunction sqr(x) x * x;\n\nprint(sqr(3));\n\n\n// for each\n\nvar array = [1, 2, 3, 4];\nfor each (var num in array) print(num);\n\n\n// object literals in constructors\n\nvar runnable = new java.lang.Runnable() {\n run: function() {\n print('on the run');\n }\n};\n\nrunnable.run();\n\n\n// bind properties\n\nvar o1 = {};\nvar o2 = { foo: 'bar'};\n\nObject.bindProperties(o1, o2);\n\nprint(o1.foo);\no1.foo = 'BAM';\nprint(o2.foo);\n\n\n// string trim\n\nprint(\" hehe\".trimLeft());\nprint(\"hehe \".trimRight() + \"he\");\n\n\n// whereis\nprint(__FILE__, __LINE__, __DIR__);\n\n\n// java import\n\nvar imports = new JavaImporter(java.io, java.lang);\nwith (imports) {\n var file = new File(__FILE__);\n System.out.println(file.getAbsolutePath());\n // /path/to/my/script.js\n}\n\n\n// convert iterable to js array\n\nvar list = new java.util.ArrayList();\nlist.add(\"s1\");\nlist.add(\"s2\");\nlist.add(\"s3\");\n\nvar jsArray = Java.from(list);\nprint(jsArray);\nprint(Object.prototype.toString.call(jsArray));\n\n\n// convert js array to java array\n\nvar javaArray = Java.to([3, 5, 7, 11], \"int[]\");\nprint(Object.prototype.toString.call(javaArray));\n\n\n// calling super\n\nvar SuperRunner = Java.type('com.winterbe.java8.samples.nashorn.SuperRunner');\nvar Runner = Java.extend(SuperRunner);\n\nvar runner = new Runner() {\n run: function() {\n Java.super(runner).run();\n print('on my run');\n }\n}\nrunner.run();\n\n\n\n// load\n\nload('http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js');\n\nvar odds = _.filter([1, 2, 3, 4, 5, 6], function (num) {\n return num % 2 == 1;\n});\n\nprint(odds);"
},
{
"path": "res/nashorn5.js",
"content": "function Product(name) {\n this.name = name;\n}\n\nProduct.prototype.stock = 0;\nProduct.prototype.price = 0;\nProduct.prototype.getValueOfGoods = function() {\n return this.stock * this.price;\n};\n\nvar product = new Product('Pencil');\nproduct.price = 4.99;\nproduct.stock = 78;\n\nprint('Value of Goods: ' + product.getValueOfGoods());\n\n\nvar getValueOfGoods = function(javaProduct) {\n var jsProduct = new Product();\n Object.bindProperties(jsProduct, javaProduct);\n return jsProduct.getValueOfGoods();\n};"
},
{
"path": "res/nashorn6.js",
"content": "load('http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js');\nload('http://cdnjs.cloudflare.com/ajax/libs/backbone.js/1.1.2/backbone-min.js');\n\n\n// simple backbone model:\n// valueOfGoods will automatically be calculated when stock or price changes\nvar Product = Backbone.Model.extend({\n defaults: {\n stock: 0,\n price: 0.0,\n name:'',\n valueOfGoods: 0.0\n },\n\n initialize: function() {\n this.on('change:stock change:price', function() {\n var stock = this.get('stock');\n var price = this.get('price');\n var valueOfGoods = this.getValueOfGoods(stock, price);\n this.set('valueOfGoods', valueOfGoods);\n });\n },\n\n getValueOfGoods: function(stock, price) {\n return stock * price;\n }\n});\n\nvar product = new Product();\nproduct.set('name', 'Pencil');\nproduct.set('stock', 1000);\nproduct.set('price', 3.99);\n\n\n// pass backbone model to java method\nvar Nashorn6 = Java.type('com.winterbe.java8.samples.nashorn.Nashorn6');\nNashorn6.getProduct(product.attributes);\n\n\n// bind java object to backbone model and pass result back to java\nvar calculate = function(javaProduct) {\n var model = new Product();\n model.set('name', javaProduct.name);\n model.set('price', javaProduct.price);\n model.set('stock', javaProduct.stock);\n return model.attributes;\n};"
},
{
"path": "res/nashorn7.js",
"content": "function sqrt(x) x * x\nprint(sqrt(3));\n\nvar array = [1, 2, 3, 4];\nfor each (var num in array) print(num);\n\nvar runnable = new java.lang.Runnable() {\n run: function () {\n print('on the run');\n }\n};\n\nrunnable.run();\n\nvar System = Java.type('java.lang.System');\nSystem.out[\"println(double)\"](12);\n\nvar Arrays = Java.type(\"java.util.Arrays\");\nvar javaArray = Java.to([2, 3, 7, 11, 14], \"int[]\");\n\nArrays.stream(javaArray)\n .filter(function (num) {\n return num % 2 === 1;\n })\n .forEach(function (num) {\n print(num);\n });"
},
{
"path": "res/nashorn8.js",
"content": "var evaluate1 = function () {\n (function () {\n print(eval(\"this\"));\n }).call(this);\n};\n\nvar evaluate2 = function () {\n var context = {};\n (function () {\n print(eval(\"this\"));\n }).call(context);\n};\n\nvar evaluate3 = function (context) {\n (function () {\n print(eval(\"this\"));\n }).call(context);\n};"
},
{
"path": "res/nashorn9.js",
"content": "var size = 100000;\n\nvar testPerf = function () {\n var result = Math.floor(Math.random() * size) + 1;\n for (var i = 0; i < size; i++) {\n result += i;\n }\n return result;\n};"
},
{
"path": "src/com/winterbe/java11/HttpClientExamples.java",
"content": "package com.winterbe.java11;\n\nimport java.io.IOException;\nimport java.net.Authenticator;\nimport java.net.PasswordAuthentication;\nimport java.net.URI;\nimport java.net.http.HttpClient;\nimport java.net.http.HttpRequest;\nimport java.net.http.HttpResponse;\nimport java.time.Duration;\n\npublic class HttpClientExamples {\n\n public static void main(String[] args) throws IOException, InterruptedException {\n// syncRequest();\n// asyncRequest();\n// postData();\n basicAuth();\n }\n\n private static void syncRequest() throws IOException, InterruptedException {\n var request = HttpRequest.newBuilder()\n .uri(URI.create(\"https://winterbe.com\"))\n .build();\n var client = HttpClient.newHttpClient();\n HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());\n System.out.println(response.body());\n }\n\n private static void asyncRequest() {\n var request = HttpRequest.newBuilder()\n .uri(URI.create(\"https://winterbe.com\"))\n .build();\n var client = HttpClient.newHttpClient();\n client.sendAsync(request, HttpResponse.BodyHandlers.ofString())\n .thenApply(HttpResponse::body)\n .thenAccept(System.out::println);\n }\n\n private static void postData() throws IOException, InterruptedException {\n var request = HttpRequest.newBuilder()\n .uri(URI.create(\"https://postman-echo.com/post\"))\n .timeout(Duration.ofSeconds(30))\n .version(HttpClient.Version.HTTP_2)\n .header(\"Content-Type\", \"text/plain\")\n .POST(HttpRequest.BodyPublishers.ofString(\"Hi there!\"))\n .build();\n var client = HttpClient.newHttpClient();\n var response = client.send(request, HttpResponse.BodyHandlers.ofString());\n System.out.println(response.statusCode()); // 200\n }\n\n private static void basicAuth() throws IOException, InterruptedException {\n var client = HttpClient.newHttpClient();\n\n var request1 = HttpRequest.newBuilder()\n .uri(URI.create(\"https://postman-echo.com/basic-auth\"))\n .build();\n var response1 = client.send(request1, HttpResponse.BodyHandlers.ofString());\n System.out.println(response1.statusCode()); // 401\n\n var authClient = HttpClient\n .newBuilder()\n .authenticator(new Authenticator() {\n @Override\n protected PasswordAuthentication getPasswordAuthentication() {\n return new PasswordAuthentication(\"postman\", \"password\".toCharArray());\n }\n })\n .build();\n var request2 = HttpRequest.newBuilder()\n .uri(URI.create(\"https://postman-echo.com/basic-auth\"))\n .build();\n var response2 = authClient.send(request2, HttpResponse.BodyHandlers.ofString());\n System.out.println(response2.statusCode()); // 200\n }\n\n}\n"
},
{
"path": "src/com/winterbe/java11/LocalVariableSyntax.java",
"content": "package com.winterbe.java11;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.Map;\nimport java.util.function.Predicate;\n\npublic class LocalVariableSyntax {\n\n public static void main(String[] args) {\n var text = \"Banana\";\n// Incompatible types:\n// text = 1;\n\n\n// Cannot infer type:\n// var a;\n// var nothing = null;\n// var bla = () -> System.out.println(\"Hallo\");\n// var method = LocalVariableSyntax::someMethod;\n\n var list1 = new ArrayList<>(); // ArrayList