Java 11 Features

public class StringMethodsDemo {
    public static void main(String[] args) {
        String blank = "   \t ";
        System.out.println("isBlank():  " + blank.isBlank());
        System.out.println("isEmpty():  " + blank.isEmpty());

        String padded = "  Java 11  ";                  // Unicode spaces
        System.out.println("trim():     [" + padded.trim() + "]");
        System.out.println("strip():    [" + padded.strip() + "]");
        String hi = "  hi  ";
        System.out.println("stripLeading:  [" + hi.stripLeading() + "]");
        System.out.println("stripTrailing: [" + hi.stripTrailing() + "]");

        System.out.println("repeat(3):  " + "ab".repeat(3));

        String text = "line one\nline two\nline three";
        System.out.println("lines():    " + text.lines().count() + " lines");
        text.lines().map(String::toUpperCase).forEach(System.out::println);
    }
}

isBlank():  true
isEmpty():  false
trim():     [  Java 11  ]
strip():    [Java 11]
stripLeading:  [hi  ]
stripTrailing: [  hi]
repeat(3):  ababab
lines():    3 lines
LINE ONE
LINE TWO
LINE THREE

import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

public class HttpClientDemo {
    public static void main(String[] args) throws Exception {
        // A tiny local server so the example runs without internet access
        HttpServer server = HttpServer.create(new InetSocketAddress(0), 0);
        server.createContext("/hello", exchange -> {
            byte[] body = "{\"message\":\"Hello from Java 11\"}"
                    .getBytes(StandardCharsets.UTF_8);
            exchange.getResponseHeaders()
                    .add("Content-Type", "application/json");
            exchange.sendResponseHeaders(200, body.length);
            exchange.getResponseBody().write(body);
            exchange.close();
        });
        server.start();
        int port = server.getAddress().getPort();

        // The standard HTTP Client (java.net.http)
        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5))
                .build();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:" + port + "/hello"))
                .GET()
                .build();

        HttpResponse<String> response =
                client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Status: " + response.statusCode());
        String type = response.headers()
                .firstValue("Content-Type").orElse("?");
        System.out.println("Type:   " + type);
        System.out.println("Body:   " + response.body());

        // Asynchronous version returns a CompletableFuture
        String async = client
                .sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .join();
        System.out.println("Async:  " + async);
        server.stop(0);
    }
}

Status: 200
Type:   application/json
Body:   {"message":"Hello from Java 11"}
Async:  {"message":"Hello from Java 11"}

import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ApiAdditionsDemo {
    public static void main(String[] args) {
        List<String> words = List.of("java", "", "spring", " ", "kafka");

        // Predicate.not: negate a method reference
        List<String> nonBlank = words.stream()
                .filter(Predicate.not(String::isBlank))
                .collect(Collectors.toList());
        System.out.println("Predicate.not:   " + nonBlank);

        // Collection.toArray(IntFunction)
        String[] array = nonBlank.toArray(String[]::new);
        System.out.println("toArray:         " + array.length
                + " elements, first = " + array[0]);

        // Optional.isEmpty
        Optional<String> missing = Optional.empty();
        System.out.println("Optional.isEmpty: " + missing.isEmpty());
    }
}

Predicate.not:   [java, spring, kafka]
toArray:         3 elements, first = java
Optional.isEmpty: true

public class NestAccessDemo {
    private String secret = "outer secret";

    class Inner {
        private int code = 42;
        // private access within the nest
        String readOuter() { return secret; }
    }

    public static void main(String[] args) {
        NestAccessDemo outer = new NestAccessDemo();
        Inner inner = outer.new Inner();
        System.out.println("Inner reads outer: " + inner.readOuter());
        System.out.println("Outer reads inner: " + inner.code);

        // Java 11 reflection API for nests
        Class<?> host = Inner.class.getNestHost();
        System.out.println("Nest host:      " + host.getSimpleName());
        boolean mates = NestAccessDemo.class.isNestmateOf(Inner.class);
        System.out.println("Are nestmates:  " + mates);
        int members = NestAccessDemo.class.getNestMembers().length;
        System.out.println("Nest members:   " + members);
    }
}

Inner reads outer: outer secret
Outer reads inner: 42
Nest host:      NestAccessDemo
Are nestmates:  true
Nest members:   2

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Java9And10Demo {
    public static void main(String[] args) {
        // Java 9: immutable collection factories
        List<String> list = List.of("a", "b", "c");
        Set<Integer> set = Set.of(1, 2, 3);
        Map<String, Integer> map = Map.of("one", 1, "two", 2);
        System.out.println(list + " " + set.size() + " " + map.get("two"));

        // Java 9: new Stream methods
        System.out.println(Stream.of(1, 2, 3, 10, 4).takeWhile(n -> n < 5)
                .collect(Collectors.toList()));
        System.out.println(Stream.iterate(1, n -> n <= 16, n -> n * 2)
                .collect(Collectors.toList()));

        // Java 9: Optional.ifPresentOrElse and or()
        Optional.empty().ifPresentOrElse(
                v -> System.out.println("value " + v),
                () -> System.out.println("ifPresentOrElse: empty"));

        // Java 10: var and unmodifiable copies
        var copy = List.copyOf(list);
        var joined = copy.stream().collect(Collectors.toUnmodifiableList());
        System.out.println("var + copyOf: " + joined);
    }
}

[a, b, c] 3 2
[1, 2, 3]
[1, 2, 4, 8, 16]
ifPresentOrElse: empty
var + copyOf: [a, b, c]