Starting with Java 9, the JVM quietly adopted a new internal representation for the java.lang.String class. The feature is called Compact Strings and, unless you went looking, you probably never noticed the change—yet it can shrink your application’s heap by 10-30% and speed up operations on text-heavy workloads.

This post explains what compact strings are, how this subtle change delivers massive performance wins, and how you can measure the benefit on your own code. Get ready to reclaim your RAM!

The Memory Drain Java 9 Tried to Solve

Prior to JDK 9, every character inside a String was stored as a 16-bit char, using the UTF-16 encoding.

The problem? For common languages like English, or text data formats like XML, JSON, log messages, and HTTP headers, most characters fall within the Latin-1 (ISO-8859-1) set, which perfectly fits into a single 8-bit byte.

This meant that for a vast majority of applications, half of every character array was filled with redundant zeroes. That silent waste translated directly to:

• Larger Heap Footprint: Your application demands more RAM.
• More GC Pressure: The Garbage Collector has to work harder and longer.
• Lower CPU-Cache Locality: Data is scattered, slowing down processing.

While developers could manually pack bytes, it came at the cost of code clarity and API compatibility. Clearly, a JVM-level fix was needed to make string handling efficient by default.

Java Streams provide elegant ways to process collections, but retrieving the last element isn’t as straightforward as calling a getLast() method. Since streams are designed for sequential processing without inherent indexing, developers need specific techniques to fetch the final element efficiently. This guide explores practical approaches to solve this common programming challenge.

Whether you’re processing large datasets or building concise functional pipelines, understanding these methods will help you write cleaner, more maintainable code.

The Core Challenge

Unlike List or Deque collections, Java Streams don’t maintain bidirectional iteration or direct index access. Once elements pass through the pipeline, they’re consumed. This design makes operations like stream().last() impossible without workarounds. However, several clever techniques leverage stream reduction and size information to achieve the desired result.

Approach 1: Using reduce() Method

The reduce() operation processes each element while retaining only the last one seen. This approach works beautifully for both sequential and parallel streams.

import java.util.Optional;
import java.util.stream.Stream;

public class LastElementWithReduce {
    public static void main(String[] args) {
        Stream fruitStream = Stream.of("apple", "banana", "cherry", "date");
        
        Optional lastElement = fruitStream.reduce((first, second) -> second);
        
        lastElement.ifPresent(element -> 
            System.out.println("Last fruit: " + element)
        );
    }
}

Extracting individual date components like year, month, and day is a common requirement in Java applications. Whether you’re working with legacy Date objects or modern date-time APIs, this guide will show you multiple approaches to accomplish this task efficiently.

1. Using Calendar Class (Legacy Approach)

Before Java 8, the Calendar class was the standard way to extract date fields from a Date object. While it’s still supported, this approach is considered outdated and less intuitive than modern alternatives.

import java.util.Calendar;
import java.util.Date;

public class DateExtractor {
    public static void main(String[] args) {
        Date currentDate = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(currentDate);
        
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1; // Months are 0-based
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        
        System.out.println("Year: " + year);
        System.out.println("Month: " + month);
        System.out.println("Day: " + day);
    }
}

Note: The Calendar.MONTH field returns values from 0 (January) to 11 (December), so you need to add 1 to get the standard 1-12 month numbering.