Why Is Reflection Slower Than new? Java Object Creation Performance Explained

1. Basic Concepts

In Java, objects are typically created with the new operator, but they can also be instantiated via reflection.

When should you choose new and when should you use reflection? How do their performance characteristics differ?

// new way
ReflectDemo reflectDemo = new ReflectDemo();

// three ways to create via reflection
// (1) Class<ReflectDemo> reflectDemoClass = ReflectDemo.class;
// (2) Class<?> aClass = Class.forName("com.whale.springtransaction.transactiondemo.reflectdemo.ReflectDemo");
// (3) Class<? extends Class> aClass = reflectDemoClass.getClass();

2. Performance Comparison Between new and Reflection

// test code
public class ReflectDemo {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        proxyObject();
        newObject();
    }

    // new object creation
    public static void newObject() {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            ReflectDemo reflectDemo = new ReflectDemo();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("new耗时为:" + (endTime - startTime));
    }

    // reflection object creation
    public static void proxyObject() throws IllegalAccessException, InstantiationException {
        long startTime = System.currentTimeMillis();
        Class<ReflectDemo> reflectDemoClass = ReflectDemo.class;
        for (int i = 0; i < 100000000; i++) {
            ReflectDemo reflectDemo = reflectDemoClass.newInstance();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射耗时为:" + (endTime - startTime));
    }
}

Running the benchmark shows that creating 100,000,000 objects with new is dramatically faster than using reflection.

Why Is There Such a Large Difference?

1. Java code is compiled to bytecode and executed on the JVM. The new path benefits from JIT optimizations, while reflection involves dynamic resolution that prevents many of these optimizations.

2. Reflection incurs additional overhead such as method visibility checks, parameter validation, and the inability to inline reflective calls.

Key Reasons for the Overhead

Method#invoke wraps and unwraps parameters.

Visibility checks are required.

Parameter type verification is performed.

Reflective calls are hard to inline.

JIT cannot optimize reflective code.

3. When to Use Reflection vs new

Typical reflection use cases:

Spring uses reflection to instantiate beans and place them in the IoC container.

Loading JDBC drivers with Class.forName().

Reverse engineering tasks such as decompilation.

Inserting a String into a generic ArrayList<Integer> via reflection.

Differences between new and reflection:

Reflection can access private members using setAccessible(), while new cannot. new requires the class name at compile time; reflection can instantiate classes without knowing the type beforehand.