Does Java Reflection Really Slow Down Your Apps? A Deep Performance Test

Why Reflection May Hurt Performance

Many developers know that Java reflection can impact performance, but the exact cost and when it becomes noticeable are often unclear. This article investigates the performance impact of reflection by measuring execution time of direct method calls, reflective method calls, direct field access, and reflective field access.

Test Setup

The test repeatedly creates a ProgramMonkey instance and invokes setmLanguage via four different approaches: direct method call, reflective method call, direct field assignment, and reflective field assignment. For each approach the test runs from 1 to 1,000,000 iterations, averaging the time over ten runs.

public class ReflectionPerformanceActivity extends Activity {
    private static final int AVERAGE_COUNT = 10;
    // ... (omitted for brevity, core methods shown)
    private long getNormalCallCostTime(int count) { /* direct method call */ }
    private long getReflectCallMethodCostTime(int count) { /* reflective method call */ }
    private long getNormalFieldCostTime(int count) { /* direct field access */ }
    private long getReflectCallFieldCostTime(int count) { /* reflective field access */ }
}

Initial Results

The benchmark shows that reflection does cause performance degradation. When the number of calls is below 100 the difference is negligible, but beyond 100 calls the overhead becomes obvious. The relative cost of the four access methods is:

Direct instance field access – fastest.

Direct method call – about 1.4× slower than direct field access.

Reflective field access – about 3.75× slower.

Reflective method call – about 6.2× slower.

Where the Overhead Comes From

All four approaches instantiate ProgramMonkey, so object creation is not the source of the difference. The extra cost stems from reflective operations such as Class.getMethod, Class.getDeclaredField, Method.invoke, and Field.set. Additional tests isolate these calls:

private long getReflectCallMethodCostTime(int count) {
    long start = System.currentTimeMillis();
    ProgramMonkey obj = new ProgramMonkey("X", "M", 12);
    Method m = obj.getClass().getMethod("setmLanguage", String.class);
    m.setAccessible(true);
    for (int i = 0; i < count; i++) {
        m.invoke(obj, "Java");
    }
    return System.currentTimeMillis() - start;
}

Further measurements show that getMethod and getDeclaredField themselves are slower than the actual invoke and set calls.

Guidelines to Mitigate Reflection Overhead

Avoid frequent use of reflection; excessive calls can degrade performance.

Prefer direct field access over reflective method calls when possible.

Future Work

Potential further tests include measuring the impact of repeated native method calls, evaluating the cost of many conditional checks within a method, and assessing how class complexity influences reflection performance.