Java 为什么从变量获取值比从数组获取值更可取？

考虑以下计划：

int []array = {10, 20, 30, 40, 50};
int x = array[0];
for(int i = 0; i < array.length; i++)
{
 System.out.println(x * array[i]);
 System.out.println(array[0] * array[i]);
}

现在，当x被指定一个值时，该值是

数组（10）

的第一个元素

x

在内存中存储一个值，其值为

10

variable :  x
Value :     10
Location :  120

现在当我们调用for循环时

第一个print语句将引用位置

120

处的值，并表示我有一个值

10

variable :  x
Value :     10
Location :  120

第二个print语句还将引用一个位置

100

，并说它有一个值

10

variable :  x
Value :     10
Location :  120

当两条语句每次都必须查找内存位置时，为什么第一条语句会更为优化

编辑 在同一程序中，如果多次使用

x

int []array = {10, 20, 30, 40, 50};
int x = array[0];
for(int i = 0; i < array.length; i++)
{
 System.out.println(x * array[i] + (x + 1) * array[i] - ( x + 2));
 System.out.println(array[0] * array[i] + (array[0] + 1) * array[i] - (array[0] + 2));
}

int[]数组={10,20,30,40,50}；
int x=数组[0]；
for（int i=0；i

这里x被多次使用。所以人们每次都喜欢使用

x

，而不是调用数组[0]

---

但是必须同时查找这两个变量。

当访问

array[i]

时，处理器必须查找

array

的内存地址，然后将

i

添加到该地址以获得您请求的变量

当访问

x

时，处理器可以直接从

x

获取变量

在Java中，只有原语存储在堆栈上，因此

array

将是指向堆上某物的指针，而

x

将存储在堆栈上。但这仅适用于

x

是基本体的情况。如果

array

包含对象（并且

x

因此是指向对象的指针），则这两个对象都将存储在堆上

因此，主要区别在于，当访问

array[i]

时，您将访问location-of-array-plus-i，但当访问

x

时，您将访问location-of-x。值得注意的是，

数组[0]

（或任何其他固定索引）通常可以优化为单个指令

现在，你应该担心这个吗？不，绝对不是。这两种方法之间甚至不可能存在可测量的性能差异，即使存在，性能差异也极不可能影响您-您的应用程序可能比仅访问内存中的变量要耗时得多。编译器很可能会对此进行优化，以减少所需的内存查找数量，处理器缓存也将发挥作用

真正的原因是，最好写以下内容：

int x = array[0]
int y = array[1]
int result = x + y + x * y + x * (x - y)

它的可读性比：

int result = array[0] + array[1] + array[0] * array[1] + array[0] * (array[0] - array[1])

---

当访问

array[i]

时，处理器必须查找

array

的内存地址，然后将

i

添加到该地址以获得您请求的变量

当访问

x

时，处理器可以直接从

x

获取变量

在Java中，只有原语存储在堆栈上，因此

array

将是指向堆上某物的指针，而

x

将存储在堆栈上。但这仅适用于

x

是基本体的情况。如果

array

包含对象（并且

x

因此是指向对象的指针），则这两个对象都将存储在堆上

因此，主要区别在于，当访问

array[i]

时，您将访问location-of-array-plus-i，但当访问

x

时，您将访问location-of-x。值得注意的是，

数组[0]

（或任何其他固定索引）通常可以优化为单个指令

现在，你应该担心这个吗？不，绝对不是。这两种方法之间甚至不可能存在可测量的性能差异，即使存在，性能差异也极不可能影响您-您的应用程序可能比仅访问内存中的变量要耗时得多。编译器很可能会对此进行优化，以减少所需的内存查找数量，处理器缓存也将发挥作用

真正的原因是，最好写以下内容：

int x = array[0]
int y = array[1]
int result = x + y + x * y + x * (x - y)

它的可读性比：

int result = array[0] + array[1] + array[0] * array[1] + array[0] * (array[0] - array[1])

---

当访问

array[i]

时，处理器必须查找

array

的内存地址，然后将

i

添加到该地址以获得您请求的变量

当访问

x

时，处理器可以直接从

x

获取变量

在Java中，只有原语存储在堆栈上，因此

array

将是指向堆上某物的指针，而

x

将存储在堆栈上。但这仅适用于

x

是基本体的情况。如果

array

包含对象（并且

x

因此是指向对象的指针），则这两个对象都将存储在堆上

因此，主要区别在于，当访问

array[i]

时，您将访问location-of-array-plus-i，但当访问

x

时，您将访问location-of-x。值得注意的是，

数组[0]

（或任何其他固定索引）通常可以优化为单个指令

现在，你应该担心这个吗？不，绝对不是。这两种方法之间甚至不可能存在可测量的性能差异，即使存在，性能差异也极不可能影响您-您的应用程序可能比仅访问内存中的变量要耗时得多。编译器很可能会对此进行优化，以减少所需的内存查找数量，处理器缓存也将发挥作用

真正的原因是，最好写以下内容：

int x = array[0]
int y = array[1]
int result = x + y + x * y + x * (x - y)

它的可读性比：

int result = array[0] + array[1] + array[0] * array[1] + array[0] * (array[0] - array[1])

---

当访问

数组[i]

时，进程