Section 1.1: Comparing Efficiency of Object Creation

When we analyze the performance of creating 100 million objects using new versus using reflection, the disparity in efficiency is stark. Let's investigate the reasons behind this significant difference.

Java code typically undergoes compilation and runs on the Java Virtual Machine (JVM). Initially, Java files are transformed into class files using a front-end compiler, such as javac. During execution, a Just-In-Time (JIT) compiler may convert bytecode into machine-readable code. Alternatively, an Ahead-Of-Time (AOT) compiler might directly compile Java files into native machine code.

While the JIT compiler optimizes code during runtime, reflection relies on dynamic analysis, which limits its ability to benefit from JVM optimizations. Several factors contribute to this inefficiency:

• The Method#invoke method encapsulates and unpacks parameters.
• Method visibility must be verified.
• Parameters require validation.
• Reflection methods are challenging to inline.
• JIT optimization is not applicable to reflection.

Subsection 1.1.1: Use Cases for Reflection and New

Reflection has its applications in various scenarios, such as:

• Instantiating objects in Spring frameworks using reflection and integrating them into the Inversion of Control (IoC) container.
• Loading database drivers with Class.forName() when connecting via JDBC.
• Reverse engineering, such as decompilation.
• Storing a String object in an ArrayList with a generic type of int through reflection.

The distinction between using new and reflection is evident: the new operator cannot access private properties, while reflection can bypass this limitation using the setAccessible() method. Additionally, new requires knowledge of the class name, whereas reflection can create instances without prior knowledge of the type.