My colleague asked me: “Why we don’t use primitives more? It is faster!”.

I didn’t have a good answer at the time, so it motivated me to write this article.

Table of contents

Introduction

Working with Java often involves juggling two types of data representations: primitive types ( such as int, double, boolean, etc.) and their wrapper class counterparts (like Integer, Double, Boolean, etc.). On the surface, they may look and function similarly, but under the hood, they behave quite differently. In this post, we will explore the reasons behind having two categories of types in Java, how they differ, and scenarios where you’d want to use one over the other.

Code samples are compatible with Java 25 and can be executed as-is.

What Are Primitives in Java?

Primitives in Java are basic data types that represent raw values. They are not objects. They are simply stored in memory locations that hold the value directly. Java defines the following eight primitive types:

1. byte – 8-bit signed integer
2. short – 16-bit signed integer
3. int – 32-bit signed integer
4. long – 64-bit signed integer
5. float – 32-bit floating-point
6. double – 64-bit floating-point
7. char – 16-bit Unicode character
8. boolean – true/false value

Key Characteristics of Primitives:

• Fast and lightweight, as they store only the value
• Not part of the object hierarchy, meaning they can’t have methods or be used with generics directly
• Have a fixed size, making them efficient for numeric and boolean operations
• Default values:
  • 0 for numeric types
  • false for boolean
  • \u0000 for char

Example usage:

int count = 10;
double price = 19.99;
boolean isValid = true;

What Are Wrapper Classes in Java?

Wrapper classes are object representations of the primitive types. Each primitive has a corresponding wrapper class:

1. Byte - 16 bytes
2. Short - 16 bytes
3. Integer - 16 bytes
4. Long - 24 bytes
5. Float - 16 bytes
6. Double - 24 bytes
7. Character - 16 bytes
8. Boolean - 16 bytes

Key Characteristics of Wrapper Classes

• They are full-fledged objects stored on the heap
• Offer utility methods for parsing, converting, or manipulating values
• Allow usage of null, which can be advantageous or problematic
• Require more memory and have more overhead than primitives
• Wrapper objects are immutable. This means after their value can’t be changed after creation.

Memory Layout Examples:

Primitive int (4 bytes)

┌─────────────────────────────────────┐
│ 00000000 00000000 00000000 00000000 │
└─────────────────────────────────────┘
 <------------- 4 bytes (32 bits) ------------>

• An int is stored directly in memory (usually on the stack if not part of an object)
• Takes exactly 4 bytes (32 bits)
• Can represent values from -2³¹ to 2³¹-1
• Direct memory access makes operations very fast
• No overhead (object header) - every bit is used for the actual value

Integer object (16 bytes total)

┌───────────────────────────────────────────────────────────────────────────────┐
│ Mark Word (8 bytes) │ Klass Pointer (4 bytes) │ int value (4 bytes)           │
└───────────────────────────────────────────────────────────────────────────────┘
 <--------------------- Object Header (12 bytes) -------------------> < 4 bytes >
 <------------------------------------ 16 bytes total -------------------------->

Object Header (12 bytes total):

• Mark Word (8 bytes):

  • Contains information used by the JVM
  • Includes: hash code, garbage collection state, locking state, synchronization info
  • Used for synchronization and memory management

• Klass Pointer (4 bytes):

  • Points to the class metadata
  • Tells JVM this is an Integer object
  • Enables object-oriented features

  Actual Value (4 bytes):

• The same 4 bytes as the primitive int

• Stored on the heap instead of the stack

• Referenced through the object

Autoboxing and Unboxing

My cat Luna!

One of the key features that bridges the gap between primitives and wrapper classes is autoboxing and unboxing.

• Autoboxing: The automatic conversion of a primitive type to its corresponding wrapper class.

  int num = 5;
  Integer obj = num;  // Autoboxing (int -> Integer)

• Unboxing: The automatic conversion of a wrapper class object to its corresponding primitive type.

  Integer obj = 5;
  int num = obj;  // Unboxing (Integer -> int)

While autoboxing and unboxing make the language more convenient, they can also introduce performance pitfalls and NullPointerExceptions if not used carefully (e.g., unboxing a null Integer).

Key Differences

1. Performance:
   Let’s look at a concrete example:

   void main() {
    // Benchmark example
    long start = System.nanoTime();
    for (int i = 0; i < 10_000_000; i++) {
    int primitive = i + 1;  // Primitive operation
    }
    long primitiveTime = System.nanoTime() - start;
    IO.println(primitiveTime); // 2219262
    start = System.nanoTime();
    for (Integer i = 0; i < 10_000_000; i++) {
    Integer wrapper = i + 1;  // Boxing/unboxing operation
    }
    
    long wrapperTime = System.nanoTime() - start;
    IO.println(wrapperTime); // 68629061
    
    var ratio = (double) primitiveTime * 100 / wrapperTime;
    IO.println(ratio); //  ~ 3.233%
    
    var timesFaster = (double) wrapperTime / primitiveTime;
    IO.println(timesFaster); //  ~ 30 times faster when using primitives
    }

   Wrapper operations are typically 15–25 times slower than primitive operations in tight loops.

2. Memory Usage:

   • Primitives consume fixed memory (e.g., int = 4 bytes)
   • Wrappers have object overhead (e.g., Integer = 16 bytes minimum) Memory layout breakdown for Integer:
   • 8 bytes: Mark Word (hash code, GC state, locking)
   • 4 bytes: Klass Pointer (class metadata)
   • 4 bytes: Actual int value

3. Default Values & Nullability:

   • Primitives cannot be null; they have default values
   • Wrappers can be assigned null

4. Object Methods:

   • Wrappers have built-in utility methods
   • Primitives do not have methods

5. Generics Compatibility:

   • Primitives cannot be used in generics
   • Wrappers can be used as type parameters

Real-World Applications

When to Use Primitives:

1. Game Development

public class GamePhysics {

  private double positionX;
  private double positionY;

  public void updatePosition(double deltaTime) {
    positionX += velocityX * deltaTime;
    positionY += velocityY * deltaTime;
  }
}

2. Real-time Processing

public class SignalProcessor {

  public double[] processSignal(double[] rawData) {
    double[] processed = new double[rawData.length];
    for (int i = 0; i < rawData.length; i++) {
      processed[i] = rawData[i] * 1.5;
    }
    return processed;
  }
}

When to Use Wrappers:

1. Database Entities

@Entity
public class User {

  @Id
  private Long id;
  private Integer age;
  private Boolean isActive;
}

2. API Responses

public class ProductDTO {

  private Integer productId;
  private Double price;
  private Boolean isAvailable;
}

3. Optional and Wrapper Classes

public class UserService {

  public Optional<Integer> getUserAge(String userId) {
    User user = findUser(userId);
    return Optional.ofNullable(user.getAge());
  }
}

4. Stream API Considerations

    void main() {
  // Primitive stream (efficient)
  IntStream.range(0, 1000000)
      .sum();

  // Wrapper stream (less efficient)
  Stream.iterate(0, i -> i + 1)
      .limit(1000000)
      .mapToInt(Integer::intValue)
      .sum();
}

Common Pitfalls and Best Practices

1. Accidental Null Unboxing

void main() {
  Integer countObj = null;
  // This will throw NullPointerException
  int count = countObj;

  // Better approach
  int safeCount = (countObj != null) ? countObj : 0;
}

2. Performance in Loops

void main() {
// Bad practice (boxing/unboxing overhead)
  List<Integer> numbers = new ArrayList<>();
  for (int i = 0; i < 1_000_000; i++) {
    numbers.add(i); // boxing occurs here
  }

// Better approach
  IntStream.range(0, 1000000)
      .boxed()
      .toList();
}

3. Comparing Values of Object

== compares object references, not values. Never use == to compare wrapper objects unless you explicitly want reference equality.

void main() {
  Integer x = 127;
  Integer y = 127;
  IO.println(x == y);      // true (due to caching of JVM, Carefully!)
}

.equals() compares object values

void main() {
  Integer a = 128;
  Integer b = 128;
  IO.println(a == b);      // false
  IO.println(a.equals(b)); // true (correct way to compare object values)
}

JVM caches Wrapper Objects from -128 to 127 for performance and memory efficiency

Integer x = 127; // This is equivalent to Integer.valueOf():
Integer x = Integer.valueOf(127); // returns a cached instance 

4. Boolean Comparisons

void main() {
  Boolean flag1 = Boolean.TRUE;
  Boolean flag2 = Boolean.TRUE;
  
  boolean result = flag1.equals(flag2); // true (correct way)
  boolean result2 = flag1 == flag2; // true (incorrect as you can see flag1 and flag2 are different objects!)
  // but due to JVM caching behavior result2 is true
}

Decision Guidelines

When choosing between primitives and wrappers, consider:

1. Do you need null values?

   • Yes → Use wrapper
   • No → Consider primitive

2. Is performance critical?

   • Yes → Use primitive
   • No → Either is fine

3. Need collections or generics?

   • Yes → Use wrapper
   • No → Consider primitive

Conclusion

Understanding the trade-offs between primitives and wrapper classes is crucial for writing efficient Java code. Use primitives for performance-critical operations and when null values aren’t needed. Use wrappers when working with collections, frameworks, or when null values are part of your domain model.

Additional Resources

Official Java Documentation on Primitive Data Types

Autoboxing/Unboxing Documentation

Effective Java by Joshua Bloch

Java Performance: The Definitive Guide

Happy coding!