Java中为何选用int[]而非Integer[]？类与基本类型数组选择疑问

Great question! It’s totally reasonable to wonder why we’d reach for a primitive array over a wrapper class array when wrappers come with handy utility methods (like Integer.parseInt() or Integer.compare()). Let’s break down the key reasons:

• Massive Memory Savings
  A primitive int takes up exactly 4 bytes of memory per value. An Integer object, though? On most JVMs (like HotSpot), each Integer has an object header (around 16 bytes) plus the 4-byte int value it wraps. That means an Integer[] of length 1000 uses ~20,000 bytes, while an int[] of the same length uses only 4,000 bytes. For large datasets, this difference can add up to significant memory bloat.

• Better Performance
  Working with int[] avoids the overhead of autoboxing and unboxing. Every time you assign an int to an Integer or vice versa, the JVM has to convert between the primitive and wrapper type—this adds tiny costs that pile up in loops or frequent operations. Plus, JVMs optimize primitive arrays more aggressively: they’re stored as contiguous blocks of memory, making access faster than jumping through object references in an Integer[].

• Safer Default Values
  When you initialize an int[], every element defaults to 0—which is often a sensible starting point for things like counters, sums, or numeric datasets. An Integer[], on the other hand, defaults to null for every element. This means you’ll get a NullPointerException if you try to use any element before explicitly initializing it, adding extra boilerplate code to avoid errors.

• Matching the Use Case
  int[] is perfect for scenarios where you only need to store raw numeric values with no need for a "missing" or "undefined" state. Use Integer[] only when you need to represent null values (e.g., mapping database NULLs) or when working with APIs that require objects (like generics—since you can’t have List<int>, only List<Integer>).

Don’t get me wrong—Integer[] has its place! For example, it works seamlessly with collections and stream operations. But for most straightforward numeric storage and computation, int[] is the more efficient, reliable choice.

内容的提问来源于stack exchange，提问作者someone