https://devops-monk.com/tutorials/java8/Recent content in Java 8 Tutorial — Complete Guide on Devops MonkHugoen-usMon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/streams-advanced/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/streams-advanced/flatMap in Depth flatMap is the most powerful transformation in the Streams API. It maps each element to a stream, then flattens all those streams into one continuous stream. // Without flatMap — stream of lists Stream<List<String>> nested = Stream.of( Arrays.asList("a", "b"), Arrays.asList("c", "d"), Arrays.asList("e") ); // Stream<String>: "a", "b", "c", "d", "e" Stream<String> flat = nested.flatMap(Collection::stream); Practical flatMap Patterns Flatten orders into line items: List<LineItem> allItems = orders.stream() .flatMap(order -> order.https://devops-monk.com/tutorials/java8/collections-maps/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/collections-maps/Overview Java 8 didn’t just add Streams — it also enhanced the existing Iterable, Collection, List, and Map interfaces with default methods that cover the most common imperative patterns. Understanding these methods lets you write cleaner code even without streams. Iterable.forEach forEach takes a Consumer<T> and applies it to every element: List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); // Before Java 8 for (String name : names) { System.out.println(name); } // Java 8 names.https://devops-monk.com/tutorials/java8/completablefuture/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/completablefuture/The Problem with Future<T> Java 5 introduced Future<T> for async computation. The problem: you can only get the result by calling get(), which blocks: // Java 7 ExecutorService pool = Executors.newFixedThreadPool(4); Future<User> future = pool.submit(() -> fetchUser(userId)); // ... User user = future.get(); // BLOCKS until done If you have multiple async operations that depend on each other, you end up with a chain of blocking get() calls — effectively synchronous execution with extra overhead.https://devops-monk.com/tutorials/java8/date-time-api/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/date-time-api/Why java.util.Date Had to Go java.util.Date was introduced in Java 1.0 and has been a source of bugs ever since: Mutable — Date can be modified after creation, causing subtle bugs when passed between methods Not thread-safe — mutable state means shared dates need external synchronisation Poor API design — year is offset from 1900, months are 0-indexed, no time zone support on Date itself Deprecated methods — most of the useful methods on Date were deprecated in Java 1.https://devops-monk.com/tutorials/java8/default-static-methods/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/default-static-methods/The Problem: Evolving Interfaces Without Breaking Implementations Before Java 8, adding a method to a widely-used interface was a breaking change. Every class implementing that interface would fail to compile until it added the new method. This was the exact problem Oracle faced when designing the Streams API. To make Collection.stream() work, Collection needed a stream() method. But Collection has thousands of implementations — add an abstract method and every third-party library breaks.https://devops-monk.com/tutorials/java8/functional-interfaces/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/functional-interfaces/What Is a Functional Interface? A functional interface is an interface with exactly one abstract method (SAM — Single Abstract Method). This is the type the compiler targets when you write a lambda expression. @FunctionalInterface public interface Comparator<T> { int compare(T o1, T o2); // the single abstract method // default and static methods are allowed } The @FunctionalInterface annotation is optional but highly recommended — it makes the intent explicit and causes the compiler to fail if you accidentally add a second abstract method.https://devops-monk.com/tutorials/java8/java8-best-practices/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/java8-best-practices/Streams Best Practices Do: Use streams for transformations and aggregations // Good: filter → transform → collect List<String> premiumNames = customers.stream() .filter(Customer::isPremium) .map(Customer::getName) .sorted() .collect(Collectors.toList()); // Good: aggregation Map<String, Long> countByCity = customers.stream() .collect(Collectors.groupingBy(Customer::getCity, Collectors.counting())); Don’t: Use streams for simple indexed iteration // Bad: stream for something a loop does more clearly IntStream.range(0, list.size()) .forEach(i -> System.out.println(i + ": " + list.get(i))); // Good: traditional loop wins here for (int i = 0; i < list.https://devops-monk.com/tutorials/java8/java8-overview/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/java8-overview/Why Java 8 Matters Java 8 was released on 18 March 2014 — nearly three years after Java 7 — and it changed Java more fundamentally than any release before or since. For the first time, Java developers could write functional-style code natively, without external libraries or workarounds. The headline features — lambda expressions and the Streams API — solved a problem that had frustrated Java developers for years: the verbosity of iteration.https://devops-monk.com/tutorials/java8/jvm-improvements/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/jvm-improvements/PermGen Removal: The End of a Classic Error Before Java 8, the JVM heap was divided into several regions. One of them — Permanent Generation (PermGen) — held class metadata, interned strings, and bytecode. PermGen had a fixed maximum size (defaulting to 64–256 MB depending on the JVM version) and could not grow beyond it. The result: applications that loaded many classes (frameworks with heavy reflection, dynamic class generation, long-lived application servers) routinely threw:https://devops-monk.com/tutorials/java8/lambdas/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/lambdas/The Problem Lambdas Solve Before Java 8, passing behaviour as a value required an anonymous inner class: // Java 7: sort a list of strings by length Collections.sort(names, new Comparator<String>() { @Override public int compare(String a, String b) { return Integer.compare(a.length(), b.length()); } }); // Run in a new thread new Thread(new Runnable() { @Override public void run() { System.out.println("Hello from thread"); } }).start(); This works, but the boilerplate-to-intent ratio is terrible.https://devops-monk.com/tutorials/java8/method-references/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/method-references/What Are Method References? A method reference is a compact syntax for a lambda expression that does nothing except call an existing method. If a lambda’s entire body is a method call, a method reference is almost always clearer. // Lambda names.forEach(s -> System.out.println(s)); // Method reference — identical behaviour, fewer characters, clearer intent names.forEach(System.out::println); The :: operator is the method reference operator. It does not call the method — it creates a reference to it, which the compiler wraps into a lambda that calls the method.https://devops-monk.com/tutorials/java8/new-apis/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/new-apis/Base64 Before Java 8, Base64 encoding required a third-party library (Apache Commons Codec, Guava) or the internal sun.misc.BASE64Encoder class. Java 8 added java.util.Base64 to the standard library. Three Encoders // Standard Base64 (RFC 4648) Base64.Encoder encoder = Base64.getEncoder(); Base64.Decoder decoder = Base64.getDecoder(); // URL-safe Base64 (replaces + with -, / with _) — safe in URLs and filenames Base64.Encoder urlEncoder = Base64.getUrlEncoder(); Base64.Decoder urlDecoder = Base64.getUrlDecoder(); // MIME Base64 (line-wrapped at 76 chars with CRLF — for email) Base64.https://devops-monk.com/tutorials/java8/optional/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/optional/The Problem Optional Solves NullPointerException is the most common runtime exception in Java. The root cause is that null is used for two different things simultaneously: “This field has no value” (intentional absence) “This reference was never set” (programming error) Callers can’t tell which meaning applies without reading the documentation or source code. And nothing in the type system forces them to check. // Java 7: what does null mean here?https://devops-monk.com/tutorials/java8/parallel-streams/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/parallel-streams/How Parallel Streams Work A parallel stream splits its source into sub-sequences, processes each sub-sequence on a separate thread, and merges the results. The mechanism is ForkJoin — specifically ForkJoinPool.commonPool(), a shared thread pool managed by the JVM. // Sequential — processes on the calling thread List<String> seq = names.stream() .map(String::toUpperCase) .collect(Collectors.toList()); // Parallel — splits work across ForkJoinPool.commonPool() List<String> par = names.parallelStream() .map(String::toUpperCase) .collect(Collectors.toList()); // Convert existing stream to parallel List<String> par2 = names.https://devops-monk.com/tutorials/java8/java8-setup/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/java8-setup/Choosing a Java 8 Distribution Oracle stopped providing free Java 8 updates for commercial use in January 2019. Multiple vendors now ship free, production-quality Java 8 builds: Distribution Vendor Free forever? Notes Amazon Corretto 8 Amazon Yes Production-hardened; used in AWS Lambda Eclipse Temurin 8 (Adoptium) Eclipse Foundation Yes Most widely used open build Microsoft Build of OpenJDK Microsoft Yes Optimised for Azure; also works anywhere Azul Zulu 8 Azul Systems Yes (community) Long LTS commitment Oracle JDK 8 Oracle No (for commercial) Requires license for production use Recommendation: Use Amazon Corretto 8 or Eclipse Temurin 8.https://devops-monk.com/tutorials/java8/streams-introduction/Mon, 04 May 2026 00:00:00 +0000https://devops-monk.com/tutorials/java8/streams-introduction/The Problem Streams Solve Consider filtering a list of orders to find the names of active premium customers who spent over $500, sorted alphabetically: // Java 7 List<String> result = new ArrayList<>(); for (Order order : orders) { if (order.isActive() && order.isPremium() && order.getTotal() > 500) { result.add(order.getCustomerName()); } } Collections.sort(result); This code is correct but reveals nothing about the structure of the computation at a glance. You have to read every line to understand what’s happening.