在静态方法中复制数组Java时的奇怪行为

我在用Java创建数组副本时遇到问题

我将接收到的数据的副本传递给我的自定义排序方法。 问题是原始数组也发生了变化。我尝试了

.clone（）

和一些我在互联网上找到的其他方法，但结果总是一样的：排序数组。我认为它是针对java行为的，而且非常容易修复。可能是带有静态关键字（？）的内容。通常我用JS编程，Java不适合我：(

publicstaticvoidmysort（示例[]数据）{
示例[]copy=Arrays.copyOf（data，data.length）；
示例[]SorterDarray=customSort（复制）；
System.out.println（“原始数据（不应排序）：”；
对于（int i=0；i

如何在mySort方法中创建接收数据的真实副本

所有代码：

package com.company;

import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;

public class Main {

    public static void main(String[] args) {

        Example examples[] = new Example[20];

        for (int i = 0; i < examples.length; i++) {
            int randomValue1 = ThreadLocalRandom.current().nextInt(1, 6);
            double randomValue2 = ThreadLocalRandom.current().nextDouble();
            examples[i] = new Example(randomValue1, randomValue2);
        }

        System.out.println("Beforesort: ");
        for (int i = 0; i < examples.length; i++) {
            System.out.println(i + ". " + examples[i]);
        }

        mySort(examples);
    }

    public static void mySort(Example[] data) {
        Example[] copy = Arrays.copyOf(data, data.length);
        Example[] sortedArray= customSort(copy);
        System.out.println("Original data (should not be sorted): ");
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i]);
        }
    }

// you can ignore this, it's just customSort
    static Example[] customSort(Example[] copy) {

        for (int i = 0; i < copy.length; i++) {
            for (int j = 0; j < copy.length - i - 1; j++)
                if (copy[j].value1 != copy[j + 1].value1) {
                    if (copy[j].value1 > copy[j + 1].value1) {
                        int temp = copy[j].value1;
                        copy[j].value1 = copy[j + 1].value1;
                        copy[j + 1].value1 = temp;
                    }
                } else {
                    if (copy[j].value2 > copy[j + 1].value2) {
                        double temp = copy[j].value2;
                        copy[j].value2 = copy[j + 1].value2;
                        copy[j + 1].value2 = temp;
                    }
                }


        }
        return copy;
    }

}

class Example {
    int value1;
    double value2;

    public Example(int value1, double value2) {
        this.value1 = value1;
        this.value2 = value2;
    }

    @Override
    public String toString() {
        return "Example{" +
                "value1=" + value1 +
                ", value2=" + value2 +
                '}';
    }
}

package.com公司；
导入java.util.array；
导入java.util.concurrent.ThreadLocalRandom；
公共班机{
公共静态void main（字符串[]args）{
示例示例[]=新示例[20]；
for（int i=0；i复制[j+1].value1）{
int temp=copy[j].value1；
复制[j].value1=复制[j+1].value1；
复制[j+1]。值1=温度；
}
}否则{
如果（复制[j].value2>复制[j+1].value2）{
双温=复制[j]。值2；
复制[j].value2=复制[j+1].value2；
复制[j+1]。值2=温度；
}
}
}
返回副本；
}
}
课例{
int值1；
双重价值2；
公开示例（int值1，double值2）{
此值为1.value1=value1；
此参数为0.value2=value2；
}
@凌驾
公共字符串toString（）{
返回“示例{”+
“value1=“+value1+
“，value2=“+value2+
'}';
}
}

问题在于，您正在通过交换

示例

实例的内容进行排序。想象这些实例具有相应的值（只是以抽象的方式）：

您正在交换值，而不是实例的位置

e1 = 1;
e2 = 2;
e3 = 3;

您可以看到值已排序，但这并没有影响实例的位置。每个引用这些实例的数组显然会在值更改时看到这些更改，而不是排序数组中的位置

您需要的是：

e2 = 1;
e3 = 2;
e1 = 3;

正如您所看到的，顺序本身是更改的，而不是实例包含的任何内容。这显然只在一个数组中可见，即您交换实例的数组中

您的排序功能必须如下所示：

静态示例[]自定义排序（示例[]副本）{
for（int i=0；i复制[j+1].value1）{
示例温度=复制[j]；
复制[j]=复制[j+1]；
复制[j+1]=温度；
}
}否则{
如果（复制[j].value2>复制[j+1].value2）{
示例温度=复制[j]；
复制[j]=复制[j+1]；
复制[j+1]=温度；
}
}
}
返回副本；
}

同样，您当前的版本交换的是价值而不是位置。我希望现在已经清楚了

---

事情是这样的：

导入java.util.array；
导入java.util.concurrent.ThreadLocalRandom；
公共班机{
公共静态void main（字符串[]args）{
示例示例[]=新示例[20]；
for（int i=0；ie1 = 1;
e2 = 2;
e3 = 3;

e2 = 1;
e3 = 2;
e1 = 3;