Changes in Java 9 - ashishranjandev/developer-wiki GitHub Wiki

module java.base {
exports java.lang; 
exports java.utils; 
---------> no requires, means there are no dependencies <br/>
}

module java.sql {
exports javax.sql; 
exports javax.transaction.xa; 
requires java.logging;
requires java.xml;
}

List<String> books = new ArrayList<>();
        books.add("Java Programming");
        books.add("Data Structures and Algorithms");
        books.add("Design Patterns");

// Alterative 

List<String> books = Arrays.asList("Java Programming", "Data Structures and Algorithms", "Design Patterns");
// Anonymous Instance collection Type

//
new ArrayList<>() {{ add("Java 9 mad"); }}
Collections.emptyList();

List.of(1, 2, 3);
// Intermediate Array Allocation

Set.of("first", "second");
// Null not allowed
// Duplicates not allowed

Jshell jshell = jshell.create();
List<SnippetEvent> events = jshell.eval("int i = 0;")
Stream<SnippetEvent> vars = jshell.variables();

Map.of("Key 1", 1, "Key 2", 2) -> {Key 1= 1, Key 2 = 2}
Map.ofEntries(Map.entry("key 1", true), Map.entry("key2", false))

// Iteration Order is not guranteed for Map.Sets

Collector<...> filtering(Predicate<..> predicate, Collector<..> downstream)

book.collect(groupingBy(Book::getAuthors, filtering(b -> b.getPrice() > 10, toSet())));

Optional.of("Hi")

Optional.empty()

s.map(String::toUpperCase) // "Hi"
i.map(n -> n + 1) -> Empty option, no NPE

public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction);

public Stream<T> stream();

public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier);

        // Before ifPresentOrElse
        full.ifPresent(System.out::println);
        if (full.isPresent()) {
            System.out.println(full.get());
        } else {
            System.out.println("Nothing here");
        }

        // After Java 9
        full.ifPresentOrElse(System.out::println,
                () -> System.out.println("Nothing here!"));

        Stream<Optional<Integer>> optionals =
                Stream.of(Optional.of(1), Optional.empty(), Optional.of(2));

        Stream<Integer> ints = optionals.flatMap(Optional::stream);

        ints.forEach(System.out::println);

        // Find all first authors of the books
        Set<String> authors = Book.getBooks()
                .map(book -> book.authors.stream().findFirst())
                .flatMap(optAuthor -> optAuthor.stream())
                .collect(Collectors.toSet());
        System.out.println(authors);

        // Java 8
        Book bestBookBefore = getBestOffer()
                .orElse(getExternalOffer().orElse(localFallback.get()));  // .get() is BAD!

        Optional<Book> bestBook =
                getBestOffer()
                .or(() -> getExternalOffer())
                .or(() -> localFallback);

// Java 8
public void normalTryWithResources() throws IOException {
        try (FileInputStream fis = new FileInputStream("~/tmp/test")) {
           fis.read();
        }
    }

// fis = null; // Re-assignment makes fis not 'effectively final'
        try (FileInputStream fis2 = fis) {
            fis2.read();
        }
// Java 9
public void doWithFile(FileInputStream fis) throws IOException {
        // Only if fis is 'effectively final', can this form be used
        // fis has to be effectively final
        try (fis) {
            fis.read();
        }

    }

ArrayList<String> list1 = new ArrayList<String>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<String> list3 = new ArrayList<>() {
            @Override
            public boolean add(String s) {
                System.out.println("Adding " + s);
                return super.add(s);
            }
        };

    double getPrice();

    default double getPriceWithTax() {
        return getPriceWithTaxInternal();
    }

    default double getPriceWithDiscount() {
        return getPriceWithTaxInternal() * 0.80;
    }

    private double getPriceWithTaxInternal() {
        return getPrice() * 1.20;
    }

        LocalDate birthDay = LocalDate.of(1991, 12, 6);

        System.out.println(birthDay.
                                datesUntil(LocalDate.now(), Period.ofYears(1)).
                                map(date -> Year.of(date.getYear())).
                                filter(Year::isLeap).
                                count());

long pidOld = Long.parseLong(ManagementFactory.getRuntimeMXBean().getName().split("@")[0]);
        // With the new ProcessHandle API in Java 9:
        long pidNew = ProcessHandle.current().pid();
        long parentPid = ProcessHandle.current().parent().get().pid();

ProcessHandle textEditHandle =
          ProcessHandle.allProcesses()
            .filter(h -> h.info().commandLine().map(cmd -> cmd.contains("TextEdit")).orElse(false))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("No matching handle found"));

HttpClient.Builder builder = HttpClient.newBuilder();

        builder.version(HttpClient.Version.HTTP_2)
                .followRedirects(HttpClient.Redirect.ALWAYS);

        HttpClient client = builder.build();

        HttpRequest request = HttpRequest.newBuilder(URI.create("https://www.google.com"))
                .header("User-Agent", "Java")
                .timeout(Duration.ofMillis(500))
                .GET()
                .build();

        CompletableFuture<HttpResponse<String>> response =
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        response.thenAccept(r -> {
            System.out.println("Version: " + r.version());
            System.out.println(r.body());
        });

        response.join();

classDiagram
  class StackWalker {
    +walk(): Stream<StackWalker.StackFrame>
    +getCallerClass(): Class<?>
  }

  class StackWalker.StackFrame {
    -className: String
    -methodName: String
  }

  class StackWalker.Option {
    -SHOW_REFLECT_FRAMES: StackWalker.Option
    -SHOW_HIDDEN_FRAMES: StackWalker.Option
  }

  StackWalker --> StackWalker.StackFrame
  StackWalker --> StackWalker.Option

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

    @Stable
    private final byte[] value;

    /**
     * The identifier of the encoding used to encode the bytes in
     * {@code value}. The supported values in this implementation are
     *
     * LATIN1
     * UTF16
     */
    private final byte coder;

String s = "a" + "b" + "c";
// this gets translated to 
String s = new StringBuilder;
s.append("a");
s.append("b");
s.append("c");

public interface ObjectInputFilter {

    /**
     * Check the class, array length, number of object references, depth,
     * stream size, and other available filtering information.
     * Implementations of this method check the contents of the object graph being created
     * during deserialization. The filter returns {@link Status#ALLOWED Status.ALLOWED},
     * {@link Status#REJECTED Status.REJECTED}, or {@link Status#UNDECIDED Status.UNDECIDED}.
     *
     * @param filterInfo provides information about the current object being deserialized,
     *             if any, and the status of the {@link ObjectInputStream}
     * @return  {@link Status#ALLOWED Status.ALLOWED} if accepted,
     *          {@link Status#REJECTED Status.REJECTED} if rejected,
     *          {@link Status#UNDECIDED Status.UNDECIDED} if undecided.
     */
    Status checkInput(FilterInfo filterInfo);
}