Java 8 (March 2014) is a Long-Term Support (LTS) release of the Java platform. It introduced functional programming constructs, a modern date/time API, and a new JavaScript engine. Java 8 remains the most widely deployed JDK version in enterprise environments, with significant install bases in banking, insurance, government, and legacy enterprise systems.
Java 8 is the eighth major version of the Java platform, distributed as JDK 1.8. It was the first release to bring functional programming to mainstream Java development through lambda expressions and the Streams API. Oracle ended free public updates for Java 8 in January 2019 for commercial use, but the release continues to receive security patches from third-party OpenJDK vendors including Azul.
Java 8 was released on March 18, 2014. It was originally designated as Java 1.8.0, following the pre-Java-9 version numbering convention where releases used a 1.x prefix.
Lambda Expressions (JSR 335)
Lambda expressions enable functional programming in Java. They provide a concise syntax for implementing single-method interfaces (functional interfaces), replacing anonymous inner class boilerplate with a single expression.
// Before Java 8
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println(“Hello”);
}
};
// Java 8 lambda
Runnable r = () -> System.out.println(“Hello”);
Lambda expressions work with any functional interface (an interface with exactly one abstract method). The standard library includes built-in functional interfaces in java.util.function: Predicate<T>, Function<T,R>, Consumer<T>, Supplier<T>, and their primitive specializations.
Streams API (JEP 107)
The Streams API provides functional-style operations on collections. A stream is a sequence of elements supporting sequential and parallel aggregate operations (filter, map, reduce, collect).
List<String> names = people.stream()
.filter(p -> p.getAge() > 30)
.map(Person::getName)
.collect(Collectors.toList());
Key characteristics:
Default Methods in Interfaces (JSR 335)
Default methods allow interfaces to declare method bodies. This enables API evolution: adding methods to existing interfaces without breaking implementations.
public interface Iterable<T> {
default void forEach(Consumer<? super T> action) {
for (T t : this) action.accept(t);
}
}
Without default methods, adding forEach to Iterable would have broken every class implementing Iterable across the entire Java ecosystem.
Optional Class
java.util.Optional<T> is a container that may or may not hold a non-null value. It provides a type-safe alternative to null references for representing the absence of a value.
Optional<String> name = Optional.ofNullable(getName());
String result = name.orElse(“default”);
Optional is intended as a return type, not as a field type or method parameter. It reduces NullPointerException risk at API boundaries.
Date and Time API (JSR 310)
The java.time package replaces java.util.Date and java.util.Calendar with an immutable, thread-safe date/time API inspired by Joda-Time.
| Class | Purpose |
|---|---|
| LocalDate | Date without time or timezone (2024-03-18) |
| LocalTime | Time without date (14:30:00) |
| LocalDateTime | Date and time without timezone |
| ZonedDateTime | Date and time with timezone |
| Instant | Machine-readable timestamp (epoch seconds/nanos) |
| Duration | Time-based amount (hours, minutes, seconds) |
| Period | Date-based amount (years, months, days) |
All java.time classes are immutable and thread-safe. The API uses factory methods instead of constructors: LocalDate.of(2024, 3, 18), LocalDate.now().
Nashorn JavaScript Engine (JEP 174)
Nashorn is a JavaScript engine compiled to JVM bytecode, replacing the older Rhino engine. It implements the ECMAScript 5.1 specification and provides a jjs command-line tool for running JavaScript.
Note: Nashorn was deprecated in Java 11 (JEP 335) and removed in Java 15 (JEP 372). For JavaScript on the JVM, use GraalVM instead.
| Feature | Reference | Description |
|---|---|---|
| Type Annotations | JEP 104 | Annotations can be applied to any type use, not just declarations |
| Repeating Annotations | JEP 120 | Multiple annotations of the same type on a single declaration |
| Compact Profiles | JEP 161 | Subset configurations of the Java SE platform for resource-constrained devices |
| Method Parameter Reflection | JEP 118 | Runtime retention of method parameter names via -parameters compiler flag |
| Remove Permanent Generation | JEP 122 | PermGen space replaced by native memory metadata; tuning flags like -XX:PermSize removed |
Oracle ended free commercial updates for Java 8 on January 31, 2019 (March 2019 for personal use). Java 8 without a support contract receives no security patches.
| Provider | Java 8 Support Status |
|---|---|
| Oracle | Ended January 2019 (free). Oracle Java SE Subscription required for continued updates. |
| OpenJDK Community | No free updates after January 2019. |
| Azul | Full, Extended, and Lifetime Support phases available. Active security patching. |
Running an unpatched Java 8 runtime in production means operating with known, unpatched vulnerabilities. Organizations still on Java 8 should either migrate to a current LTS (Java 21 or 25) or obtain supported binaries from a vendor like Azul.
Azul provides free and enterprise-grade Java 8 binaries:
Azul Zulu Java 8 builds are available for Linux (x64, ARM64, POWER, s390x), Windows (x64), macOS (x64), Docker containers, and cloud marketplaces (AWS, Azure, GCP).
Azul provides long-term support for Java 8 under its multi-phase lifecycle:
Additional Azul Java 8 support offerings:
