1. Introduction to Wrappers in Java

In the Java ecosystem, wrappers represent an essential component of object-oriented programming. These classes "wrap" primitive types, allowing them to be used where objects are traditionally required. By understanding how they work and how they are used, developers can write cleaner, more robust code that adapts to current platform expectations.

Java is one of the most widely used languages in the software industry, and one of the foundations of its design is to be able to treat primitive types as objects in the contexts where they are required. wrappers or wrapper classes make this transition possible, also allowing the use of additional methods for data manipulation and validation.

2. What are Wrappers?

Wrappers are classes that encapsulate primitive types (such as int, double, etc.) and convert them into objects. This is essential for working with Java APIs and collections, which require objects rather than primitive data. With the evolution toward Java 21, they are also subject to performance optimizations and new functionality implementations, such as integration with pattern matching, for example, the class Integer It is used to represent integer values, allowing not only the manipulation of arithmetic data, but also the use of useful methods such as parseInt(), valueOf() either intValue()This mechanism is vital for working with collections and APIs that require object arguments, facilitating interaction with libraries and frameworks without having to resort to complex or untyped solutions.

3. What are Wrappers or Wrapper Classes?

In Java, every primitive type has an associated class (called wrapper) that allows it to behave like an object. For example, the primitive type int can be wrapped using the class IntegerThese classes offer:

• Useful methods: Conversion from/to text strings, comparisons, etc.
• Autoboxing and Unboxing: They allow automatic conversion between a primitive and its wrapper class and vice versa.
• Integration into Collections: Since collections (such as ArrayList) only accept objects.

4. Importance of Wrappers in Java Programming

The importance of wrappers lies in their ability to bridge the world of primitive types with that of objects. This allows:

• Integration with collections: The standard library classes (such as ArrayList, HashMap, etc.) can only store objects. Wrappers allow you to include numeric or Boolean values without resorting to untyped solutions.
• Ease of conversion: With autoboxing and unboxing, the compiler handles the implicit conversion between primitives and objects, simplifying your code and improving its readability.
• Use of specialized methods: Wrappers provide useful methods that facilitate string conversions to numbers and comparison operations, among others, extending the basic capabilities of the language.

5. New Features and Improvements to Wrappers in Java SE 21

Java 21‑SE has implemented several improvements in wrapper handling:

• Autoboxing/Unboxing Optimization: Internal adjustments have been made to reduce overhead on bulk conversions during operations with streams and lambda expressions.
• Improved Caching: Caching mechanisms for certain ranges (as in Integer and Short) have been optimized to reduce the memory footprint.
• Compatibility with Functional Paradigms: Integration with streams APIs and functional programming has been strengthened, allowing wrappers to be used more efficiently in aggregation and transformation operations.

These improvements make wrappers more secure and efficient to use, especially in high-performance applications or microservices environments.

6. History of Wrapper Types.

6.1. Origins and Motivation of Wrapper Design in Java

The wrappers They emerged to integrate primitive types into the object-oriented paradigm. This allowed, for example, the use of numeric values in contexts where an object was expected, facilitating interoperability in object-oriented APIs and frameworks.

6.2. Evolution of Java: From Java 1.5 to Java 21

• Java 1.5: Autoboxing/unboxing was introduced, reducing the need to manually instantiate wrapper classes.
• Intermediate Versions: Improvements were added to methods and internal memory management (such as caching in Integer).
• Java 21‑SE: Current optimizations reduce autoboxing overhead, improve integration with lambda expressions and streams, and improve performance in concurrent environments.

6.3. Impact of Wrappers on Object-Oriented Programming

By allowing each primitive value to be treated as an object, wrappers make it easy to:

• The extension of functionalities through specific methods.
• Interoperability with APIs that require objects.
• A consistent approach to implementing object-oriented design patterns.

7. Table: Wrappers and Primitive Types

Table: Primitive Types and Wrapper Classes

8. Initializing Wrapper Objects in Java SE 21

In Java SE 21, wrapper objects (which wrap primitive types) can be initialized in several ways:

In Java, the wrappers are classes that wrap primitive types (such as int, float, boolean, etc.) allowing them to be treated as objects. This feature is essential for taking advantage of the language's object-oriented feature set and for integrating into collections and APIs that require objects.

8.1 Initialization forms

Example of autoboxing:

int numeroPrimitivo = 10;  
Integer numeroWrapper = numeroPrimitivo; // Conversión automática (autoboxing)

Automatic conversion (autoboxing).

Integer i = new Integer(10); // Deprecated
Double d = new Double(3.14); // Deprecated

valueOf() method (recommended):

Integer i = Integer.valueOf(10);
Double d = Double.valueOf(3.14);
Boolean b = Boolean.valueOf(true);

Autoboxing (automatic conversion from Java 5):

Integer i = 10; // Autoboxing de int a Integer
Double d = 3.14; // Autoboxing de double a Double

String parsing:

Integer i = Integer.parseInt("10");
Double d = Double.parseDouble("3.14");

Boolean class with True or False values:

Boolean b = Boolean.TRUE;
Boolean f = Boolean.FALSE;

9. Changes in Java SE 21

In Java SE 21, wrapper constructors are marked as @Deprecated(forRemoval=true), which means:

• Its use is not recommended
• They will be removed in a future version of Java
• It is recommended to use valueOf() or autoboxing instead

10.1 Complete example

public class WrapperInitialization {
    public static void main(String[] args) {
        // Formas modernas recomendadas
        Integer num1 = 42; // Autoboxing
        Integer num2 = Integer.valueOf(42);
        Integer num3 = Integer.parseInt("42");
        
        Double decimal1 = 3.14; // Autoboxing
        Double decimal2 = Double.valueOf(3.14);
        
        Boolean flag1 = true; // Autoboxing
        Boolean flag2 = Boolean.valueOf(true);
        Boolean flag3 = Boolean.parseBoolean("TRUE");
        
        // Forma antigua (deprecated en Java SE 21)
        Integer deprecatedNum = new Integer(42); // No recomendado
    }
}

The most common and recommended way in modern Java is to use autoboxing or methods valueOf().

11. The String Class as a Wrapper

Although the class String It behaves in a special way in Java (due to its immutability and management in the string pool), and can also be considered a reference data type similar to wrappers.

• Main features of the String:
  • Immutability: Once created, its content cannot be changed.
  • Useful methods: length(), substring(), replace(), toUpperCase(), etc.

Example:

String saludar = "Hola, Java 21!";
System.out.println("Longitud del String: " + saludar.length());
System.out.println("En mayúsculas: " + saludar.toUpperCase());

12 Autoboxing and Unboxing with Wrapper Examples

He autoboxing allows the compiler to automatically convert a primitive value into its corresponding wrapper object. Similarly, the unboxing converts the object to its original value.

• Autoboxing: Automatic conversion of a primitive to its wrapper class.

• Unboxing: Reverse process, from wrapper object to its primitive type.

General Example:

public class EjemploAutoboxingUnboxing {
    public static void main(String[] args) {
        // Autoboxing
        Integer enteroWrapper = 50;  // int 50 convertido a Integer
        Double dobleWrapper = 3.14;    // double 3.14 convertido a Double
        
        // Unboxing
        int enteroPrimitivo = enteroWrapper;  
        double doblePrimitivo = dobleWrapper;
        
        System.out.println("Integer: " + enteroWrapper);
        System.out.println("int: " + enteroPrimitivo);
        System.out.println("Double: " + dobleWrapper);
        System.out.println("double: " + doblePrimitivo);
    }
}

This mechanism is applied to each of the wrappers, facilitating programming without the need for explicit manual conversion.

13. Conversion between Wrappers and Primitive Types: Practical Examples

The conversion is performed using methods specific to each wrapper class, as well as through autoboxing/unboxing.

Example for Integer:

public class EjemploConversion {
    public static void main(String[] args) {
        String numeroStr = "1234";
        
        // Conversión de String a Integer (wrapper)
        Integer numeroWrapper = Integer.valueOf(numeroStr);
        
        // Conversión a int (unboxing)
        int numeroPrimitivo = Integer.parseInt(numeroStr);
        
        System.out.println("Wrapper: " + numeroWrapper);
        System.out.println("Primitivo: " + numeroPrimitivo);
    }
}

This type of conversion is similar for each wrapper (for example, Double.parseDouble(), Boolean.parseBoolean(), etc.), which unifies the way data is processed.

14. Explanation and Examples of Each Wrapper Type in Java SE 21

14.1. The String Class

Although String It is not a wrapper for a primitive, its importance and extensive use as an immutable object make it fundamental.

String mensaje = "Java 21 es innovador";
System.out.println("Mensaje original: " + mensaje);
System.out.println("Mensaje en minúsculas: " + mensaje.toLowerCase());

14.2. Byte

The class Byte wraps the type byte.

Byte b = Byte.valueOf((byte) 10);
System.out.println("Valor Byte: " + b);

14.3. Short

Wrap the type short.

Short s = Short.valueOf((short) 20);
System.out.println("Valor Short: " + s);

14.4. Integer

The class Integer It is probably one of the most used when wrapping a int.

Integer i = Integer.valueOf(30);
System.out.println("Valor Integer: " + i);

14.5. Long

Wrap the type long.

Long l = Long.valueOf(40L);
System.out.println("Valor Long: " + l);

14.6. Float

Wrap the type float.

Float f = Float.valueOf(5.75f);
System.out.println("Valor Float: " + f);

14.7. Double

Wrap the type double.

Double d = Double.valueOf(9.99);
System.out.println("Valor Double: " + d);

14.8. Character

Wrap the type char.

Character c = Character.valueOf('A');
System.out.println("Valor Character: " + c);

14.9. Boolean

Wrap the type boolean. This wrapper makes it easy to convert strings to logical values.

Boolean bool = Boolean.valueOf("true");
System.out.println("Valor Boolean: " + bool);

15. Table of Methods for Working with Wrappers: Explanation and Examples

Note: Wrapper classes also have specific methods such as isDigit() in Character either compare() in Integer, which allow for more precise comparisons and validations.

16. Sample Program Wrapper.java

The following program integrates the concepts explained in this document. It summarizes the initialization, conversion, autoboxing, unboxing, and method usage of various wrappers.

public class EjemploWrapper {
    public static void main(String[] args) {
        // Autoboxing y unboxing
        Integer entero = 100;         // Autoboxing
        int numero = entero;          // Unboxing
        
        // Conversión desde String hacia Integer y viceversa
        String numStr = "250";
        Integer numeroWrapper = Integer.valueOf(numStr);
        int numPrim = Integer.parseInt(numStr);
        
        // Uso de otros wrappers
        Byte b = Byte.valueOf((byte) 10);
        Short s = Short.valueOf((short) 20);
        Long l = Long.valueOf(40L);
        Float f = Float.valueOf(3.14f);
        Double d = Double.valueOf(9.99);
        Character c = Character.valueOf('J');
        Boolean bool = Boolean.valueOf("true");
        
        // Mostrar resultados
        System.out.println("Integer (Autoboxing): " + entero);
        System.out.println("int (Unboxing): " + numero);
        System.out.println("Integer from String (valueOf): " + numeroWrapper);
        System.out.println("int from String (parseInt): " + numPrim);
        System.out.println("Byte: " + b);
        System.out.println("Short: " + s);
        System.out.println("Long: " + l);
        System.out.println("Float: " + f);
        System.out.println("Double: " + d);
        System.out.println("Character: " + c);
        System.out.println("Boolean: " + bool);
        
        // Comparaciones con wrappers
        if (entero.compareTo(150) < 0) {
            System.out.println(entero + " es menor que 150.");
        } else {
            System.out.println(entero + " es mayor o igual que 150.");
        }
    }
}

17. Conclusion, Complementary Topics, Good Practices, Summary and References

17.1 Conclusion

The wrappers Wrapper classes are an essential tool in Java. They allow primitive values to be transformed into objects, facilitating integration with collections, conversion, and the use of advanced features (such as pattern matching in Java 21). Using them through autoboxing and unboxing, along with class-specific methods, allows for writing cleaner, safer, and more expressive code.

17.2 Complementary Topics and Good Practices

• Null and Error Control: Always verify that wrapper objects are not null before operating on them to avoid runtime exceptions when unboxing.
• Performance Considerations: Although autoboxing simplifies writing code, it is important to avoid unnecessary conversions in loops or intensive calculations.
• Appropriate Comparisons: Use equals() rather == to compare the contents of wrapper objects, since the latter compares references.
• Use of Specialized Methods: Take advantage of methods such as parseXxx, valueOf and xxxValue() to achieve safe and efficient conversions.

17.3 Summary

This document has explained in detail:

• The theory and practice behind wrappers.
• How to initialize and use them in Java 21.
• Detailed examples for each wrapper type: Byte to Boolean, including class String as a special data type.
• Table of common methods that facilitate conversion and comparison.
• An example program that summarizes the concepts covered.

17.4 References

1. Official Oracle Documentation: Java SE Documentation
2. Tutorials and Specialized Articles:
   • “Wrapper Classes in Java: Concepts and Examples”
   • “Autoboxing and Unboxing in Java 21: Improvements and Practical Examples”
3. Technical Blogs and Forums:
   • Articles on Medium and StackOverflow about optimization and best practices for using wrappers.