如何使两个数组具有不同的引用？

Question

我必须反转两个数组，以便它们具有相同的值但不同的引用。

这是我目前的代码。

但是当两个数组都指向同一个程序参数时，如何实现呢？

为什么String[] 引用反转String[] 值而不是反转程序参数？

例如。如果程序参数是1 2 3 4 5：

String[] values = 5 4 3 2 1
String[] reference = 1 2 3 4 5

public static void main(String[] args) {
    String[] values = changeValues(args);
    System.out.println(Arrays.toString(values));
    String[] reference = changeReference(args);
    System.out.println(Arrays.toString(reference));

    if (!testSameValues(values, reference)) {
        System.out.println("Error: Values do not match !");
    }

    if (testSameReference(values, reference)) {
        System.out.println("Error: References are the same !");
    }
}

public static String[] changeValues(String[] x) {
    for (int i = 0; i < x.length / 2; i++) {
        String temp = x[i];
        x[i] = x[(x.length - 1) - i];
        x[(x.length - 1) - i] = temp;
    }
    return x;
}

public static String[] changeReference(String[] y) {
    for (int i = 0; i < y.length / 2; i++) {
        String temp = y[i];
        y[i] = y[(y.length - 1) - i];
        y[(y.length - 1) - i] = temp;
    }
    return y;
}

public static boolean testSameValues(String[] x, String[] y) {
    if (x.equals(y)) {
        return true;
    } else
        return false;
}

public static boolean testSameReference(String[] x, String[] y) {
    if (x == y) {
        return true;
    } else
        return false;
}

Answer 1

你可以简单的复制反转后的数组，得到两个内容相同的不同引用：

// 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

---

^{另见：Swapping first array element with last, second with second last and so on}

Answer 2

您的 reverse 方法仅对输入数组进行操作，不会创建新数组。编写一个反转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 它修改传入的数组。

Answer 3

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;
}

Answer 4

克隆数组：

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

请注意，由于changeValues 和changeReference 做同样的事情，您可以只使用changeValues 或changeReference。数组在内存中的位置取决于传入的数组的位置，而不是函数的名称。