Java中声明double：本地一次性声明还是从ArrayList<Double>重复获取？

Great question—this hits on both performance optimization and clean coding practices, which are super relevant for large-scale computations in Java. Let’s break this down into efficiency and style:

Efficiency: Local double variable wins for repeated access #

• Avoid repeated unboxing: ArrayList<Double> stores wrapper objects, not primitive doubles. Every time you call constants.get(index), Java has to unbox the Double to a double—a tiny overhead, but it adds up when you’re accessing the same element hundreds/thousands of times in intensive calculations.
• Faster access: Local primitive variables live on the stack, which is faster to access than heap-based Double objects in an ArrayList. Reusing a local variable eliminates repeated trips to the heap for the same value.
• Note for single-use cases: If you only access an element once, the overhead of unboxing is negligible, so directly calling constants.get(index) is fine—no need to declare an extra variable.

Style: Local variables improve readability and maintainability #

• Meaningful names: Instead of writing constants.get(5) everywhere in your calculation logic, assign it to a named variable like double gravitationalConstant = constants.get(5);. This makes your code self-documenting—anyone reading it immediately knows what that value represents.
• Follow DRY principle: Repeating constants.get(index) violates "Don’t Repeat Yourself". If you ever need to change which index corresponds to a particular constant, you only have to update it once where the variable is declared, not everywhere it’s used.
• Cleaner logic: Local variables keep your calculation code focused on the math, not on fetching values from a list. This reduces cognitive load for anyone (including future you) reading the code.

Recommendation for your scenario #

Since you’re working on a large-scale computation:

• For constants used multiple times in your calculations: Extract them to named local double variables once at the start of your computation logic. This boosts both efficiency and readability.
• For constants used once: Directly fetch from the ArrayList<Double>—no need to clutter your code with unnecessary variables.

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