Java 哪一个更快：x整数数组还是包含x整数字段的对象？

到目前为止，在我正在编写的一个程序中，我一直在使用数组来存储有关线段的数据。为了解决这个问题，我们假设这些数组只包含定义起始（x1，y1）和结束（x2，y2）坐标的整数

Integer[] lineData = {x1, y1, x2, y2};

在我的程序中，我需要使用for循环对多个这样的数组中包含的数据连续执行操作

在编写程序的过程中，我多次意识到我需要更多关于这些片段的数据。因此，我将元素添加到数组中，数组变大了，例如：

Integer[] lineData = {x1, y1, x2, y2, slope, red, green, blue, width};

这已经变得很难管理，因为我需要记住每个整数数据的位置以对其执行操作，并且实现对数组的更改（例如交换两个元素的位置）非常繁琐，因为我需要更新对它们执行操作的程序的每个部分中元素的索引

这让我想到了一个显而易见的想法，即创建一个lineData类，其中包含整数作为字段：

public class LineData {

public int x1,y1,x2,y2,slope, red, green, blue, width;

LineData(int x1, int y1, int x2, int y2, int slope, int red, int green, int blue, int width){
    this.x1 = x1;
    this.y1 = y1;
    this.x2 = x2;
    this.y2 = y2;
    this.slope = slope;
    this.red = red;
    this.green = green;
    this.blue = blue;
    this.width = width;
}

public int getX1() {
    return x1;
}

public void setX1(int x1) {
    this.x1 = x1;
}

public int getY1() {
    return y1;
}

public void setY1(int y1) {
    this.y1 = y1;
}

public int getX2() {
    return x2;
}

public void setX2(int x2) {
    this.x2 = x2;
}

public int getY2() {
    return y2;
}

public void setY2(int y2) {
    this.y2 = y2;
}

public int getSlope() {
    return slope;
}

public void setSlope(int slope) {
    this.slope = slope;
}

public int getRed() {
    return red;
}

public void setRed(int red) {
    this.red = red;
}

public int getGreen() {
    return green;
}

public void setGreen(int green) {
    this.green = green;
}

public int getBlue() {
    return blue;
}

public void setBlue(int blue) {
    this.blue = blue;
}

public int getWidth() {
    return width;
}

public void setWidth(int width) {
    this.width = width;
}
}

这看起来是一个很好的解决方案

不过，我担心的是，访问和更改lineData类的字段要比访问和更改数组中的元素慢。我担心的原因是相信数组的存在是有原因的

使用lineList类的另一个理由是需要存储关于线段的数据，这些线段不是整数，而是字符串、布尔值和其他自定义对象

然而，请忽略这一论点。我想将整数数组与只包含整数字段的类进行比较

总而言之，我的问题是：

哪一个更快：x整数数组还是包含x整数字段的对象？ 当您过去面对上述问题时，您是如何解决的？如果使用带字段的对象比使用数组慢，您是否仍然决定使用带字段的对象？为什么?

请考虑到这些数组的数量非常多，因此将数组更改为带有字段的对象将创建大量循环的实例化对象-这可能会影响性能

---

非常感谢您的帮助

您是否考虑过使用列表或集合之类的东西

List<Interger> myList = new ArrayList<Integer>();

myList.add(5);

boolean foo = myList.contains(5); // true

foo = myList.contains(6); // false

int size = myList.size(); // 1 
foo = myList.isEMpty(); //false   

myList.remove(new Integer(5));
size.size() // 0
foo = myList.isEmpty(); // true

List myList=new ArrayList（）；
添加（5）；
布尔foo=myList.contains（5）；//真的
foo=myList.contains（6）；//假的
int size=myList.size（）；//1.
foo=myList.isEMpty（）//假的
myList.remove（新整数（5））；
size.size（）//0
foo=myList.isEmpty（）；//真的

或者你需要的是一张地图

Map myMap<String,Integer> = new HashMap<String, Integer>();

myMap.put("blue", 5);
myMap.put("red", 6);

int value = myMap.get("red"); // 6
int size = myMap.size(); //2
myMap.remove("red");
size = myMap.sie(); //2

Map myMap=newhashmap（）；
myMap.put（“蓝色”，5）；
myMap.put（“红色”，6）；
int value=myMap.get（“红色”）；//6.
int size=myMap.size（）//2.
myMap.remove（“红色”）；
size=myMap.sie（）//2.

---

你可以使用的技巧还有很多，你确定你使用的是正确的数据结构吗？

Array

s用于存储大量实例，其中数字未知，或者你必须对该实例进行迭代，并对其执行相同的操作

因此，数组最好包含相同（语义）类型的对象。在本例中不是这样，在坐标后存储线宽。虽然技术上没有问题，但很难维护

因此，从开发的角度来看，最好创建一个存储线段的类，然后在数组中存储不同的线段

因此，您可能需要的是

LineData[]

数组。在每个元素中存储一行的数据

从性能的角度来看，差别不大

• 通过方法访问字段：在这种情况下，您首先调用方法create-overhead（调用堆栈帧）以及null检查，访问字段本身是非常快的，因为Java预先知道字段的位置
• 访问公共字段：通常不被认为是一个好主意。优点是您只需要对对象执行

  null

  检查
• 访问数组元素。在这种情况下，将执行两项检查：数组上的

  null

  -检查和

  索引

  检查（如果经过优化，此索引检查可以在一次操作中完成（并且在具有合理指令集的机器上）

---

但是，如果您事先不确定线段的数量，那么最好使用

列表

实例，从而使用

链接列表

或

数组列表

，首先，我想说，如果您只处理整数，并且追求性能，那么您肯定应该使用

int[]

而不是

Integer[]

：

• int[]

  是一个包含本机整数数组（4字节）的单个对象

• Integer[]

  是

  Integer

  类的数组，这意味着实例化所有对象时，对象的数量与数组的长度相同

现在谈谈你的问题。 坦白地说，在您的设计上，并且与性能问题无关，您应该选择

LineData

类。我看不出在数组中实现伪对象有什么好的理由。从概念上讲，在sam中存储不同性质的东西，如

slope

，

color

，

x

，

y

，…是没有意义的数组（甚至本机数组）是一种集合，然后应该包含具有相同性质的值

---

在性能方面，我想说编译器可以很容易地优化对象上的getter和setter。

使用

LineData

类来存储对象是非常合适的，可读性，而且肯定比保存所有数据更快