Article illustration 1

Java's long-anticipated Valhalla Project has reached a critical milestone with the release of early-access JDK builds implementing JEP 401: Value Classes and Objects (Preview). This isn't just another language tweak—it's a foundational shift in how Java handles objects, promising radical performance improvements while simplifying semantics for immutable data types.

What Makes Value Objects Revolutionary

Value classes—declared with the value keyword—represent immutable data without traditional object identity. As Dan Smith of the Valhalla team demonstrates, this enables two critical behaviors:

// In JShell with --enable-preview
jshell> Objects.hasIdentity(LocalDate.now())
$3 ==> false  // Value object

jshell> Objects.hasIdentity(new ArrayList<>())
$4 ==> true   // Identity object
  1. Statewise equivalence: == compares field values rather than memory addresses
  2. Heap flattening: The JVM can embed object state directly in references or arrays

Core JDK classes like Integer and LocalDate already behave as value objects when preview is enabled. Developers can convert existing records:

value record Point(int x, int y) {} 
Point p = new Point(17, 3);
Objects.hasIdentity(p); // false

The Performance Payoff

The real magic emerges in memory-bound operations. Smith's benchmark—processing 50 million LocalDate objects—reveals staggering gains:

Without preview (identity objects):
Attempt 1: 82.703 ms
Attempt 5: 71.915 ms

With value objects (--enable-preview):
Attempt 1: 41.959 ms
Attempt 5: 25.027 ms  // ~3x faster!

This speedup comes from avoiding pointer indirection. When value objects are stored in arrays, their data packs consecutively—like a C struct—rather than requiring scattered heap accesses. For data-heavy workloads (databases, scientific computing, financial systems), this could reduce memory footprints by 30-50% while accelerating processing.

Why This Matters Beyond Benchmarks

  • Semantic clarity: Value classes explicitly declare domain objects as interchangeable when state matches, eliminating accidental identity comparisons
  • Cache efficiency: Flattened data structures play nicer with CPU caches
  • Future-proofing: Enables new JVM optimizations impossible with identity objects

Proceed with Measured Optimism

This is still early-access software—bugs and performance quirks are expected. The Valhalla team actively seeks feedback at [email protected]. Before rewriting performance-critical code:

  1. Profile with JDK Flight Recorder to identify actual bottlenecks
  2. Review JEP 401 to understand optimization boundaries
  3. Test workloads with the early-access build

As Java evolves beyond its 30th year, value objects represent more than a performance hack—they're a philosophical shift toward efficient data-oriented programming without sacrificing Java's object model. For developers wrestling with big data on the JVM, this preview offers a compelling glimpse of Java's high-performance future.

Source: Inside Java