您只需复制反向数组，即可获得两个具有相同内容的不同引用：

// original array
String[] arr1 = {"5", "7", "3", "2", "1"};

// reversed array
String[] arr2 = IntStream
        // iterating in reverse order
        .iterate(arr1.length, i -> i > 0, i -> i - 1)
        // get an element by its index
        .mapToObj(i -> arr1[i - 1])
        .toArray(String[]::new);

// copy of the reversed array
String[] arr3 = Arrays.stream(arr2).toArray(String[]::new);

System.out.println(Arrays.toString(arr2)); // [1, 2, 3, 7, 5]
System.out.println(Arrays.toString(arr3)); // [1, 2, 3, 7, 5]

System.out.println(arr2 == arr3); // false
System.out.println(Arrays.equals(arr2, arr3)); // true
System.out.println(Arrays.compare(arr2, arr3)); // 0

另请参见：用last交换第一个数组元素，用second-last交换第二个数组元素，依此类推

反向方法只对输入数组进行操作，不创建新数组。编写一个方法来反转 String[] 并返回一个新数组。像这样的

private static String[] copyReverse(String[] arr) {
    String[] ret = new String[arr.length];
    for (int i = 0; i < arr.length; i++) {
        ret[i] = arr[arr.length - i - 1];
    }
    return ret;
}

然后你可以依次调用它。比如，

String[] values = copyReverse(args);
String[] reference = copyReverse(values);

我认为您需要两种方法，一种是复制数组，另一种是反转数组。让我们使这些方法成为泛型的，但是为了泛型地复制数组，我们还需要传递类。比如说，

private static <T> T[] copy(Class<T> cls, T[] arr) {
    T[] ret = (T[]) Array.newInstance(cls, arr.length);
    for (int i = 0; i < arr.length; i++) {
        ret[i] = arr[i];
    }
    return ret;
}

在原地反转数组时，如果在数组中的位置使用两个变量，我会发现更容易读取。比如，

private static <T> T[] reverse(T[] arr) {
    for (int i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    return arr;
}

以及 copyReverse 一般来说，

private static <T> T[] copyReverse(Class<T> cls, T[] arr) {
    T[] ret = (T[]) Array.newInstance(cls, arr.length);
    for (int i = 0; i < arr.length; i++) {
        ret[i] = arr[arr.length - i - 1];
    }
    return ret;
}

复制 String[] 你们两个都可以

String[] values = copy(String.class, args);
String[] reversed = copyReverse(String.class, args);

但如果你用原地踏步 reverse 它修改传入的数组。

克隆阵列：

String[] values = changeValues(args.clone());
String[] reference = changeReference(args.clone());

注意，自从 changeValues 以及 changeReference 做同样的事，你可以用 changeValues 两者或 changeReference 两个都是。数组在内存中的位置基于传入数组的位置，而不是函数名。

changereference和changevalues方法执行相同的操作—反转数组。这就是为什么最后会看到相同的输入数组。
要更改引用，需要创建一个新数组，并使用与原始数组相同的元素填充它。
编辑：将数组复制到新数组中

public static String[] changeReference(String[] y) {
    String[] copy = new String[y.length];
    for(int i = 0; i < y.length; i++) {
        copy[i] = y[i]
    }
    return copy;
}