Deep Analysis of Java int to String Conversion: Integer.toString(i) vs new Integer(i).toString()

Introduction

In Java programming, converting primitive int type to String is one of the most common operations. Developers typically face two choices: using the static method toString(i) of the Integer class, or creating an Integer object and then calling the instance method toString(). While both methods can achieve the same functionality, they exhibit significant differences in implementation mechanisms, performance characteristics, and applicable scenarios.

Method Implementation Mechanism Analysis

Integer.toString(i) is a static method provided by the Integer class that directly converts the primitive int value to a string representation. This method does not require creating any object instance and directly transforms the int value into its corresponding string form through internal algorithms. From the Java source code perspective, this method internally calls the more generic toString(int i, int radix) method with a default decimal radix.

In contrast, new Integer(i).toString() first creates an Integer object instance through the constructor, wrapping the primitive int value within an object, and then calls the object's toString() method. This process involves object creation, memory allocation, and subsequent garbage collection, requiring more system resources compared to the static method call.

Performance Comparison Analysis

In terms of performance, Integer.toString(i) demonstrates clear advantages. By avoiding the overhead of object creation, this method is more efficient in both execution speed and memory usage. Particularly in scenarios requiring extensive int to String conversions, this performance difference becomes especially noticeable.

The following code example provides an intuitive comparison of performance differences between the two methods:

public class PerformanceComparison {
    public static void main(String[] args) {
        int iterations = 1000000;
        long startTime, endTime;
        
        // Test Integer.toString(i) performance
        startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            String result = Integer.toString(i);
        }
        endTime = System.nanoTime();
        System.out.println("Integer.toString() time: " + (endTime - startTime) + " nanoseconds");
        
        // Test new Integer(i).toString() performance
        startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            String result = new Integer(i).toString();
        }
        endTime = System.nanoTime();
        System.out.println("new Integer().toString() time: " + (endTime - startTime) + " nanoseconds");
    }
}

Memory Usage Analysis

Regarding memory usage, Integer.toString(i) only requires memory allocation for the result string, while new Integer(i).toString() needs additional memory allocation for the Integer object besides the result string. Each Integer object typically occupies 16 bytes in 32-bit JVM (8 bytes object header + 4 bytes int field + 4 bytes alignment padding) and more in 64-bit JVM.

Consider the following memory usage scenario:

public class MemoryUsageDemo {
    public static void demonstrateMemoryDifference() {
        int[] numbers = {1, 2, 3, 4, 5};
        
        // Method 1: Using static method, no additional object creation
        String[] results1 = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            results1[i] = Integer.toString(numbers[i]);
        }
        
        // Method 2: Using instance method, creating additional objects
        String[] results2 = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            results2[i] = new Integer(numbers[i]).toString();
        }
    }
}

Functional Characteristics Comparison

While Integer.toString(i) is superior in performance and memory aspects, new Integer(i) has unique advantages in certain scenarios. When int values need to be treated as objects, such as when placing them into collection frameworks or when other methods of the Integer class are required, creating Integer objects becomes necessary.

For example, in scenarios requiring collection framework usage:

import java.util.ArrayList;
import java.util.List;

public class CollectionUsage {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        
        // Must use Integer objects to place into List<Integer>
        for (int i = 0; i < 10; i++) {
            numberList.add(new Integer(i)); // or use Integer.valueOf(i)
        }
        
        // If only string representation is needed, static method is more efficient
        List<String> stringList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            stringList.add(Integer.toString(i));
        }
    }
}

Best Practice Recommendations

Based on the above analysis, we propose the following best practice recommendations:

1. When only int to String conversion is needed, prioritize using the Integer.toString(i) static method for optimal performance and minimal memory overhead.

2. When Integer object functionality is required (such as placing into collections, using comparison methods, etc.), use new Integer(i) or preferably Integer.valueOf(i).

3. In Java 5 and later versions, recommend using Integer.valueOf(i) instead of new Integer(i), as the valueOf method employs caching mechanisms that can reuse existing objects for common values (-128 to 127), further improving performance.

4. In performance-sensitive applications, particularly those requiring extensive int to String conversions,务必 use static methods to avoid unnecessary object creation overhead.

Extended Application Scenarios

Beyond basic int to String conversion, the Integer class provides other useful string conversion methods:

public class ExtendedConversionMethods {
    public static void demonstrateOtherMethods() {
        int number = 255;
        
        // Convert to binary string
        String binary = Integer.toBinaryString(number);
        System.out.println("Binary: " + binary); // Output: 11111111
        
        // Convert to hexadecimal string
        String hex = Integer.toHexString(number);
        System.out.println("Hexadecimal: " + hex); // Output: ff
        
        // Convert to octal string
        String octal = Integer.toOctalString(number);
        System.out.println("Octal: " + octal); // Output: 377
        
        // Convert using specified radix
        String base36 = Integer.toString(number, 36);
        System.out.println("Base 36: " + base36); // Output: 73
    }
}

Conclusion

Although both Integer.toString(i) and new Integer(i).toString() can achieve int to String conversion, they differ fundamentally in implementation mechanisms, performance characteristics, and applicable scenarios. Understanding these differences is crucial for writing efficient and maintainable Java code. In most cases, Integer.toString(i) is the superior choice, but in specific scenarios requiring Integer object functionality, creating Integer instances becomes necessary. Developers should choose appropriate methods based on specific requirements and pay particular attention to avoiding unnecessary object creation in performance-sensitive applications.