Java 9 Is Here!

module java.sql {
    requires transitive java.logging
    requires transitive java.xml
    uses java.sql.Driver
    exports java.sql
    exports javax.sql
    exports javax.transaction.xa
}

module java.sql {
    requires transitive java.logging
    requires transitive java.xml
}

module java.sql {
    exports java.sql
    exports javax.sql
    exports javax.transaction.xa
}

module java.sql {
    uses java.sql.Driver
}

module mysql.driver {
    provides java.sql.Driver
        with com.mysql.MySQLDriver;
}

List<Driver> drivers = new ArrayList<>();
ServiceLoader
    .load(Driver.class)
    .forEach(drivers::add);

public interface InJava8 {

    default boolean evenSum(int... numbers) {
        return sum(numbers) % 2 == 0;
    }

    default boolean oddSum(int... numbers) {
        return sum(numbers) % 2 == 1;
    }

    default int sum(int[] numbers) {
        return IntStream.of(numbers).sum();
    }

}

public interface InJava9 {

    private int sum(int[] numbers) {
        return IntStream.of(numbers).sum();
    }

}

void doSomethingWith(Connection connection)
        throws Exception {
    try(Connection c = connection) {
        c.doSomething();
    }
}

try(Connection c = connection)

void doSomethingWith(Connection connection)
        throws Exception {
    try(connection) {
        connection.doSomething();
    }
}

List<String> strings = new ArrayList<>();

<T> Box<T> createBox(T content) {
    // we have to put the `T` here :(
    return new Box<T>(content) { };
}

<T> Box<T> createBox(T content) {
    return new Box<>(content) { };
}

Box<?> createCrazyBox(Object content) {
    List<?> innerList = Arrays.asList(content);
    // compile error
    return new Box<>(innerList) { };
}

private <T> Optional<T> firstNonNull(T... args) {
    return stream(args)
            .filter(Objects::nonNull)
            .findFirst();
}

Possible heap pollution from parameterized vararg type

private <T> T[] replaceTwoNulls(
        T value, T first, T second) {
    return replaceAllNulls(value, first, second);
}

private <T> T[] replaceAllNulls(T value, T... args) {
    // loop over `args`, replacing `null` with `value`
    return args;
}

@SafeVarargs
private <T> Optional<T> firstNonNull(T... args) {
    return // [...]
}

Invalid SafeVarargs annotation. Instance
method <T>firstNonNull(T...) is not final.

import java.io.LineNumberInputStream;

@Deprecated
public class DeprecatedImports {

    LineNumberInputStream stream;

}

long zero = Stream.ofNullable(null).count();
long one = Stream.ofNullable("42").count();

iterate(T seed,
    Predicate<T> hasNext,
    UnaryOperator<T> next);

Stream
    .iterate(1, i -> i<=10, i -> 2*i)
    .forEach(System.out::println);
// output: 1 2 4 8

Enumeration<Integer> en = // ...
Stream.iterate(
        en.nextElement(),
        el -> en.hasMoreElements(),
        el -> en.nextElement())
    .forEach(System.out::println);

Stream<T> takeWhile(Predicate<T> predicate);

Stream.of("a-", "b-", "c-", "", "e-")
    .takeWhile(s -> !s.isEmpty());
    .forEach(System.out::print);

// output: a-b-c-

Stream<T> dropWhile(Predicate<T> predicate);

Stream.of("a-", "b-", "c-", "de-", "f-")
    .dropWhile(s -> s.length() <= 2);
    .forEach(System.out::print);

// output: de-f-

Stream<T> stream();

private Optional<Customer> findCustomer(String id) {
    // ...
}

Stream<Customer> findCustomers(List<String> ids) {
    return ids.stream()
        .map(this::findCustomer)
        // now we have a Stream<Optional<Customer>>
        .filter(Optional::isPresent)
        .map(Optional::get)
}

private Optional<Customer> findCustomer(String id) {
    // ...
}

Stream<Customer> findCustomers(List<String> ids) {
    return ids.stream()
        .map(this::findCustomer)
        // now we have a Stream<Optional<Customer>>
        // we can now filter-map in one step
        .flatMap(Optional::stream)
}

List<Order> findOrdersForCustomer(String id) {
    return findCustomer(id)
        .map(this::getOrders) // eager
        .orElse(new ArrayList<>());
}

Stream<Order> findOrdersForCustomer(String id) {
    return findCustomer(id)
        .stream()
        .map(this::getOrders) // lazy
        .flatMap(List::stream);
}

Optional<T> or(Supplier<Optional<T>> supplier);

public interface Search {
    Optional<Customer> inMemory(String id);
    Optional<Customer> onDisk(String id);
    Optional<Customer> remotely(String id);

    default Optional<Customer> anywhere(String id) {
        return inMemory(id)
            .or(() -> onDisk(id))
            .or(() -> remotely(id));
    }

}

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

void logLogin(String id) {
    findCustomer(id)
        .ifPresentOrElse(
            this::logCustomerLogin,
            () -> logUnknownLogin(id));
}

List<String> list = [ "a", "b", "c" ];
Map<String, Integer> map = [ "one" = 1, "two" = 2 ];

List<String> list = List.of("a", "b", "c");
Map<String, Integer> mapImmediate = Map.of(
        "one", 1,
        "two", 2,
        "three", 3);
Map<String, Integer> mapEntries = Map.ofEntries(
        entry("one", 1),
        entry("two", 2),
        entry("three", 3));

void forEach (Consumer<StackFrame>);

public static void main(String[] args) { one(); }
static void one() { two(); }
static void two() {
    StackWalker.getInstance()
        .forEach(System.out::println);
}

// output
StackWalkingExample.two(StackWalking.java:14)
StackWalkingExample.one(StackWalking.java:11)
StackWalkingExample.main(StackWalking.java:10)

T walk (Function<Stream<StackFrame>, T>);

static void three() {
    String line = StackWalker.getInstance().walk(
        frames -> frames
            .filter(f -> f.getMethodName().contains("one"))
            .findFirst()
            .map(f -> "Line " + f.getLineNumber())
            .orElse("Unknown line");
    );
    System.out.println(line);
}

// output
Line 11

ls /home/nipa/tmp | grep pdf

Path dir = Paths.get("/home/nipa/tmp");
ProcessBuilder ls = new ProcessBuilder()
        .command("ls")
        .directory(dir.toFile());
ProcessBuilder grepPdf = new ProcessBuilder()
        .command("grep", "pdf")
        .redirectOutput(Redirect.INHERIT);
List<Process> lsThenGrep = ProcessBuilder
        .startPipeline(asList(ls, grepPdf));

public class Main {

    public static void main(String[] args) {
        System.out.println(new Version().get());
    }

}

public class Version {

    public String get() { return "Java 8"; }

}

public class Version {

    public String get() { return "Java 9"; }

}

└ org
    └ codefx ... (moar folders)
        ├ Main.class
        └ Version.class
└ META-INF
    └ versions
        └ 9
            └ org
                └ codefx ... (moar folders)
                    └ Version.class

public class SystemOutLogger implements Logger {

    public String getName() { return "SystemOut"; }

    public boolean isLoggable(Level level) { return true; }

    public void log(
            Level level, ResourceBundle bundle,
            String format, Object... params) {
        System.out.println(/* ...*/);
    }

    // another, similar `log` method

}

public class SystemOutLoggerFinder
        extends LoggerFinder {

    public Logger getLogger(
            String name, Module module) {
        return new SystemOutLogger();
    }

}

module system.out.logger {
    provides java.lang.System.LoggerFinder
        with system.out.logger.SystemOutLoggerFinder;
}

String method = generateString(size);

public String work() {
    return "Calling method \"" + method + "\"";
}

String s = greeting + ", " + place + "!";