As a Java developer, you may know that the Java programming language supports two different types of data. These include primitive data types and objects. In recent releases of Java, a new type, named ValueType has been introduced. While there should not be any difference in how you deal with objects and value types in your code, ValueTypes do have significant differences beneath the hood. To put it simply: ValueTypes seem like objects but they behave like primitives. This Java programming tutorial discusses the newly introduced ValueType in Java.
What are the Data Types in Java?
Here is a quick look at the existing data types supported in Java:
- Boolean Data Type: The Boolean data type in Java can be used to store two values only: true or false.
- Character Data Type: The character data type can store any Unicode character. For example: a, A, z, 1, 4, $, #, and ! are all examples of character data types (so long as they are encased in quotes).
- Short Data Type: The short data type can store any numeric values between -32768 and 32767.
- Integer Data Type: The Integer data type can store any numeric integer values. This is the original primitive data type in Java and is used for storing integers.
- Long Data Type: The long data type can store larger integers.
- Float Data Type: The float data type can store real numbers with up to three digits of precision. This is great for storing numbers like 0.5 or 32.72. Also known as decimal point numbers.
- Double Data Type: The double data type can store real numbers with up to six digits of precision. This is a good choice for storing numbers like 23.198 or -32.45.
Java Example: Understanding the Problem
A CPU cache is a small, fast hardware device located close to the CPU core to minimize data access time. It contains data read from frequently used memory locations. The CPU accesses the cache when it needs to find a memory location. When the CPU wants to read or write data from or to a place in the main memory, it first checks to see whether that location is cached. When the CPU locates the memory location in the cache, this is a cache hit. The data is read from the cache in this situation. On the other hand, a cache miss happens when the CPU cannot locate the requested memory address in the cache.
The CPU accesses the cache when it needs access to a memory location. When a program needs anything from memory, it is expected that it will subsequently want something from the next memory address, and so on. As a result, the CPU reads the entire memory pages into the cache. Typically, the cache contains many pages from various memory regions. If a developer is working with an array, an attempt to read the first element of the array might be slow. However, accessing the following elements would be faster since they are already in the cache.
This approach works fine, but things get complex when dealing with an array of objects. In this case, the array itself is stored in a contiguous memory location. So, the CPU will have the reference of such objects available in the cache. However, these objects might be present on a completely different memory page than the memory page where the first object of the array is located.
Specific memory layout optimization approaches can help with this problem. However, each object has its own header in Java. So even if these objects were stored one after the other, they would be separated by their object headers. Enter ValueType.
What is a ValueType in Java?
A ValueType is a type that represents a value. This is similar to how primitive types are represented in Java. The main difference is that ValueType is a reference type, which means that it can be stored in a variable or passed as an argument to a method.
ValueType is a new feature in Java 8 that makes it possible to define custom types that behave like primitives. For example, you can create a ValueType for points in a two-dimensional coordinate system. This makes it easy to work with complex data structures without having to use classes or arrays.
In Java 8, the new ValueType was introduced to improve performance and to make code more concise. The ValueType is a wrapper for an object that is immutable and cannot be changed. This makes it ideal for use in situations where the object does not need to be changed, such as in a returned value from a method.
What are the Features of the new ValueType in Java?
Here are the features of a Java ValueType at a glance:
A Java ValueType is Immutable
Immutability is yet another inbuilt feature of the Java programming language. Once created, an immutable object cannot be altered; that is, you cannot modify the content of an immutable object after it has been created. Note that in Java, all the wrapper classes such as String, Integer, Boolean, Byte, and Short are immutable. Immutable objects help you write code in a cleaner, thread safe way.
A ValueType is immutable, which means that once it has been defined, you cannot alter its value. This makes them ideal for use in data structures such as hash tables and sets.
A Java ValueType Does Not Have an Identity
An instance of ValueType does not have an identity,( i.e., they are considered to be identical only if their respective internal state is identical).
When we can object without an identity, it implies that all that matters is the value of the object. As an example, an int that has a value 100 is the same as any otherbint in your code that has the same value.
A Java ValueType Does Not Have Any Reference or Object Header
Instances of ValueType are entirely copied when you pass them as a parameter to a method.
Moreover, it lacks an object header or identity and hence lacks inheritance across value types.
A Java ValueType Does Not Support Inheritance or Polymorphism
What distinguishes a value type from an object is immutable references to the value type. Hence, it lacks inheritance and polymorphism as well. Several of them, such as the absence of an object header, are implementation details; others are design choices.
Polymorphism for a ValueType does not make any sense because a ValueType does not include any class information and is stored directly. So, the Java Virtual Machine (JVM) must be able to infer the type of the object from the program instead of the object.
Final Thoughts on the Java ValueType
Values are often read into the CPU cache from the main memory in chunks, which are substantially smaller than pages. The size of a page may be as small as 4096 bytes (4KB) or as big as 2MB (64K to 2MB); a cache line can be as small as 16 or 32 bytes.