JDK 28 Preview: Value Objects, Generational Shenandoah GC, and the Truth About Java's Native JSON API
There is still a year left for Java 28 to be officially released, but there is enough buzz in the development world about its new features. Unlike the non-LTS Java versions that have been released so far, Java 28 has attracted a lot of curiosity and speculation. There are also several contradictory claims about what the new version is coming packed with. Some just think JDK 28 is only going to be a modest release focused on basic maintenance aspects, while there are others who think JDK 28 is going to offer a built-in JSON API. But no such claim and counter-claim really unfold the entire possibilities.
As we have reached the middle of August 2026, there have been 3 JEPs (JDK Enhancement Proposals) for the release of Java 28. These 3 proposals include value objects, a generational-by-default Shenandoah garbage collector, and strict field initialization in the JVM. While these 3 proposals are official, there is also a fourth proposal for a native JSON API, and it is currently being discussed. But this fourth proposal, as of now, has not been given as big a priority as the other three.
Here in this comprehensive guide on Java 28, we are going to cover all four of these proposals in technical depth. We will also uncover what has been officially confirmed as of now and what is still pending.
Value Objects (JEP 401)
Among all the new features that are expected to be part of the new Java 28, value objects represent a major shift. The feature was originally conceptualised under Project Valhalla. This project was started in 2014 to provide a comprehensive solution to what most Java developers have been living with. Java developers always needed to opt for a primitive type like int to ensure speed, or they needed to wrap it in a class to deliver structure and meaning, but they were required to pay the price against it through a heap allocation, an object header, and pointer indirection whenever this is touched.
The JEP 401 now addresses this and offers a new value modifier. This is a class that becomes a value class, and all its instances become the value objects. Since these instances only have final fields and do not have any object identity, two value objects having identical field values are now to be considered the same object.
This shift is likely to have a direct and visible impact on the == operator. When it comes to ordinary Java objects, == compares references irrespective of whether two variables point to the same object in memory. But with value objects, == compares the values of their fields, the way it already behaves with primitives. Since the JVM already knows that a value object cannot be distinguished from another identical one, this allows for more effective storage of these objects. This will allow developers to use them directly in arrays or fields without the need to track them through pointers or allocate them on the heap.
Let’s have a look at the simplified example of the syntax to understand the impact:
value class Point {
private final int x;
private final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
// getters omitted
}
Point a = new Point(3, 4);
Point b = new Point(3, 4);
System.out.println(a == b); // true ? compared by field values, not identity
Where this new pattern can impact the real world includes location coordinates, monetary amounts, timestamps, IP addresses, etc. All the data that remains static following construction and does not need to be distinguished from its equal copies are the best candidates for this pattern. Any system that generates an extensive number of small immutable objects, such as payment processing, event streaming, and real-time analytics, is likely to be the highest beneficiary of this new feature.
All said and done, there are also some preconditions that developers need to be aware of before using the feature. The feature is likely to be a preview, which means for production environments, developers need to enable preview at both compile time and runtime.
Generational Shenandoah GC by Default (JEP 535)
This is the second feature to be packed with the new Java 28. Though it is much narrower in terms of scope, it can be hugely helpful to any developer running Java for services that are sensitive to latency. Shenandoah is well-known as one of the many garbage collectors in the Java development kits. This garbage collector was originally designed to reduce downtime. It requires the least pause time because it carries out the vast majority of its collection work concurrently while the application is still running.
Shenandoah, as of now, used to operate only in a single-generation mode. It used to treat every object in the heap similarly and without giving any attention to the time any object is alive. This is where JEP 535 brought a major change. Now, by default, generational mode has been introduced, allowing the garbage collector to treat the old objects differently from the new objects. This ensures more efficient management of accumulated objects and consequent concurrency.
Strict Field Initialization in the JVM (JEP 539)
The next JEP feature is rolled out to mitigate a small integrity gap that has been there for a long time. This gap is how the JVM handles object fields. With the present Java, the code can read a field before initialization. It receives a default value like 0 or null instead of a real error. For years, this resulted in bugs that are difficult to detect. This is particularly challenging for libraries that build all objects outside the regular constructor path.
Now JEP 539 introduced strictly-initialized fields, which will require assigning a value to the fields before they can be read. When the same strictly-initialized field is designated as final, throughout the object’s lifetime the same value is going to be observed. This will prevent any window through which a stale default can leak.
Though the developers are not likely to interact with this feature in their everyday work, as it is basically a VM-level feature. The target audience of this feature is those who design languages based on the JVM, such as Kotlin, Scala, Clojure, etc. This will also help developers of JVM-based frameworks. Any developer who is building tools for serialization or dependency injection on top of the JVM will be a direct beneficiary of this feature.
What About the JSON API?
This is the feature that has not been officially confirmed as part of the upcoming JDK 28 release. The built-in JSON API has been proposed under the formal JEP 540. A simple JSON API has been the subject of discussion within the OpenJDK community. The feature is already under consideration for the JDK 28 release, though the official confirmation is yet to come.
The real objective behind this feature is to facilitate a lightweight way to create and navigate JSON documents without depending on any external library for the same. As of now, carrying out common everyday tasks with JSON files such as reading a configuration file, building a JSON payload, inspecting an API response, and many such tasks requires external help from third-party libraries. With the inclusion of JSON API, this dependency can end and ensure better efficiency of tasks related to JSON documents.
Let’s have a quick look at the type of usage the proposal of including JSON API aims at:
// Illustrative only ? syntax is not finalized
JsonValue root = Json.parse(responseBody);
if (root instanceof JsonObject obj) {
String status = obj.get("status").asString();
}
Here are some small updates on how this new proposal has progressed. In the weekly roundup of OpenJDK, JEP 540 has progressed to the JEP Draft stage, followed by Candidate status by the last week of July 2026. From these developments, apparently the native JSON API is very likely to be part of the official JDK 26 release.
What do these 4 Proposals for JDK 28 Signify?
When we look at each of these 4 feature proposals, they can be considered a bunch of additions for a non-LTS release. But when you connect the dots among these features, it shows the evolution of Java in a particular direction. Value objects prioritize immutability, and the value-based semantics seem to knock on the door to become part of the core of the Java language. This trajectory was first seen with the introduction of records in Java 16 and sealed classes in Java 17.
The new garbage collection capabilities indicate prioritization of concurrency and low-pause object handling. The objective is to standardize this low-friction garbage collection rather than making developers opt for it manually. Lastly, the stringent field initialization addresses a long-standing fault line for the framework developers and JVM-based language architects. This reflects Oracle’s vision of reducing the gaps within the Java ecosystem so that dependence on third-party libraries can be drastically reduced.
Should Developers Start Using JDK 28 Features?
It is advisable to avoid the new JDK 28 features now in production. But developers should not shy away from experimenting with the new features. Since all the first three official features are shipped as previews, you need to enable them explicitly. Oracle hasn’t yet made them production-ready because there might be scope for further fine-tuning before the final JDK 28 release.
If you are curious about the new JDK 28, you can always download the early-access builds. This is a more practical approach to see how the JVM really interacts. This way you can avoid committing any production code to rely on the feature preview behavior.
Frequently Asked Questions
When is JDK 28 releasing?
JDK 28 is expected to be released officially in March 2027, since that is the time when the standard six-month release cadence of Java ends.
Is JDK 28 a Long-Term Support (LTS) release?
No, it is a short-term feature release. Like any short-term feature release, it is going to receive a limited six months of support from Oracle.
Does JDK 28 include a built-in JSON API?
As of August 2026, the proposal for a built-in JSON API has not been officially approved. The proposal, under JEP 540, is being discussed, and it has progressed to Candidate status.
What's the difference between value objects and records?
0Records, the feature that was introduced in Java 16, represent a concise syntax for immutable data carrier classes. But its limitation is that it remained ordinary objects bearing regular identities. By this logic, two records with identical field values were considered as different objects under ==. This is where value objects bring a new approach and remove identity completely so that == can only compare by field values. This ensures more efficient storage of objects in the JVM memory.
Do existing Java applications need to change anything for JDK 28?
No, because all the new JDK 28 features are previewed. They are disabled by default and developers need to separately opt in to use them.
1Final Thoughts
JDK 28, though it is only a short-term feature release, is nevertheless a significant release because of packing some of the most anticipated features that Oracle and the OpenJDK community were working on for some time. This non-LTS release is all set to make a serious uproar in the coming months.