在Java中反转数组[重复]答案

【问题标题】：Reversing an Array in Java [duplicate]在Java中反转数组[重复]
【发布时间】：2012-09-22 15:03:11
【问题描述】：

如果我有这样的数组：

1 4 9 16 9 7 4 9 11

反转数组的最佳方法是什么，使其看起来像这样：

11 9 4 7 9 16 9 4 1

我有下面的代码，但是感觉有点繁琐：

public int[] reverse3(int[] nums) {
    return new int[] { nums[8], nums[7], nums[6], nums[5], num[4],
                       nums[3], nums[2], nums[1], nums[0] };
}

有没有更简单的方法？

【问题讨论】：

使用循环将前半部分的每个元素与后半部分的元素交换。
如果我使用了 void 那意味着我不能在这个方法中使用 return 语句对吗？
确实如此。您可以保留可能返回也可能不返回的现有数组。或者您可以退回一份副本。
根据您已有的想法，我会大胆猜测您在开发方面非常有经验，因此我将指出一个简单的替代方案。只需在反向 for 循环中执行您想要的操作，而不是实际反转数组。 for (int i = someArray.length - 1; i > 0; i--) { doStuff(someArray[i]); } reversedArray[j++] = firstArray[i]; }

标签： java arrays reverse

【解决方案1】：

如果您将号码放在List 中的Integers 中，Collections.reverse() 可以为您完成这项工作。

List<Integer> list = Arrays.asList(1, 4, 9, 16, 9, 7, 4, 9, 11);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);

输出：

[1, 4, 9, 16, 9, 7, 4, 9, 11]
[11, 9, 4, 7, 9, 16, 9, 4, 1]

【讨论】：

你能解释一下吗？谢谢
请看答案的编辑。
为什么要实例化一个新的 ArrayList？ Arrays.asList() 已经返回一个列表。
谢谢@cypressious，我的印象是 Arrays.asList 会返回一个不可修改的列表。更正了。
Arrays.asList 实际上会返回一个 Frozen 列表，因为您无法从新创建的列表中添加或删除任何元素。但是，您可以进行就地元素修改。

【解决方案2】：

如果要就地反转数组：

Collections.reverse(Arrays.asList(array));

因为 Arrays.asList 返回原始数组的直写代理，所以它可以工作。

【讨论】：

虽然旧答案花了我一些时间来弄清楚...这对操作不起作用，因为 int[] 是一个对象，而 Arrays.asList(array) 将返回 List 而不是 List （无论如何这是不可能的）所以实际上是一个 List 具有完全相同的一个条目，它是相同的。这适用于所有原始数组！
public int decToBinary(int n) { // 存储二进制数的数组 int[] binaryNum = new int[1000]; // 二进制数组的计数器 int i = 0; while (n > 0) { // 将余数存入二进制数组 binaryNum[i] = n % 2; n = n / 2;我++； } 返回 Collections.reverse(Arrays.asList(binaryNum)); } ---------------- 报错 --> 错误：不兼容的类型：void 不能转换为 int return Collections.reverse(Arrays.asList(binaryNum));

【解决方案3】：

如果你不想使用Collections，那么你可以这样做：

for (i = 0; i < array.length / 2; i++) {
  int temp = array[i];
  array[i] = array[array.length - 1 - i];
  array[array.length - 1 - i] = temp;
}

【讨论】：

在for循环之前将array.length / 2部分放到外面不值得吗？我相信每次迭代都会重新计算它。
@JinKwon 我相信编译器会这样增强它，你可以用 javap 试试
@JinKwon 为了澄清这一点，我不是指 javac，我说的是 JIT 编译器，即在运行时发生的优化。

【解决方案4】：

我会这样做：

public int[] reverse3(int[] nums) {
  int[] numsReturn = new int[nums.length()]; 
  int count = nums.length()-1;
  for(int num : nums) {
    numsReturn[count] = num;
    count--;
  }
  return numsReturn;
}

【讨论】：

@RodrigoKossmann.. 或者你可以使用：-numsReturn[count--] = num

【解决方案5】：

或者你可以在后面循环播放它

int[] firstArray = new int[]{1,2,3,4};
int[] reversedArray = new int[firstArray.length];
int j = 0;
for (int i = firstArray.length -1; i > 0; i--){
    reversedArray[j++] = firstArray[i];
}

（注意：我没有编译这个，但希望它是正确的）

【讨论】：

【解决方案6】：

我喜欢保留原始数组并返回一个副本。这是一个通用版本：

public static <T> T[] reverse(T[] array) {
    T[] copy = array.clone();
    Collections.reverse(Arrays.asList(copy));
    return copy;
}

不保留原始数组：

public static <T> void reverse(T[] array) {
    Collections.reverse(Arrays.asList(array));
}

【讨论】：

这真的很有帮助。我喜欢您没有更改原始数组，而是返回了一个新数组这一事实。
虽然不适用于原始数组

【解决方案7】：

你搞砸了

int[] firstArray = new int[]{1,2,3,4};
int[] reversedArray = new int[firstArray.length];
int j = 0;
for (int i = firstArray.length -1; i >= 0; i--){
    reversedArray[j++] = firstArray[i];
}

【讨论】：

【解决方案8】：

您可以使用 org.apache.commons.lang.ArrayUtils ： ArrayUtils.reverse(array)

【讨论】：

【解决方案9】：

试试这个：

public int[] reverse3(int[] nums) {
    int[] reversed = new int[nums.length];
    for (int i=0; i<nums.length; i++) {
        reversed[i] = nums[nums.length - 1 - i];
    }
    return reversed;
}

我的意见是：

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

我得到的输出：

12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

【讨论】：

【解决方案10】：

以最少的掉期进行就地逆转。

for (int i = 0; i < a.length / 2; i++) {
    int tmp = a[i];
    a[i] = a[a.length - 1 - i];
    a[a.length - 1 - i] = tmp;
}

【讨论】：

【解决方案11】：

这段代码会有所帮助：

int [] a={1,2,3,4,5,6,7};
for(int i=a.length-1;i>=0;i--)
  System.out.println(a[i]);

【讨论】：

@Begueradj - 这对我来说似乎是一个答案 - 不一定是一个好答案，但它是一个答案。

【解决方案12】：

 public void swap(int[] arr,int a,int b)
 {
    int temp=arr[a];
    arr[a]=arr[b];
    arr[b]=temp;        
}
public int[] reverseArray(int[] arr){
    int size=arr.length-1;

    for(int i=0;i<size;i++){

        swap(arr,i,size--); 

    }

    return arr;
}

【讨论】：

【解决方案13】：

以下将在索引i 和j 之间反转数组（以反转整个数组调用reverse(a, 0, a.length - 1)）

    public void reverse(int[] a, int i , int j) {
        int ii =  i;
        int jj = j;

        while (ii < jj) {
            swap(ii, jj);
            ++ii;
            --jj;
        }
    }

【讨论】：

我喜欢这个答案，因为它避免在循环内调用 .length 方法，并且不会不断计算 len - 1 - i;它适用于数组的任何范围，并使用交换而不是临时变量。但是没有理由使用重复变量（ii & jj）；你可以直接使用 i & j 。我会交换(ii++, jj--) 并避免多余的行。
还要注意它只在 i

【解决方案14】：

如果您不想使用临时变量，也可以这样做：

final int len = arr.length;
for (int i=0; i < (len/2); i++) {
    arr[i] += arr[len - 1 - i]; //  a = a+b
    arr[len - 1 - i] = arr[i] - arr[len - 1 - i];   //  b = a-b
    arr[i] -= arr[len - 1 - i]; //  a = a-b
}

【讨论】：

【解决方案15】：

您可以将原始数组发送到一个方法，例如：

之后创建一个新数组来保存反转的元素

public static void reverse(int[] a){

int[] reversedArray = new int[a.length];

for(int i = 0 ; i<a.length; i++){
reversedArray[i] = a[a.length -1 -i];


}

【讨论】：