在Java中反转数组

如果我有这样一个数组：

1 4 9 16 9 7 4 9 11 

11 9 4 7 9 16 9 4 1 

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

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
}

反转阵列以使其看起来像这样的最佳方法是什么：

1 4 9 16 9 7 4 9 11 

11 9 4 7 9 16 9 4 1 

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

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
}

我有下面的代码，但我觉得有点乏味：

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

有更简单的方法吗？

如果你把你的数字放在一个

整数列表中，你就可以完成这项工作

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

如果要在位反转阵列，请执行以下操作：

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

它可以工作，因为它会向原始数组返回一个直写代理。
如果您不想使用
集合
，则可以执行以下操作：

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（i=0；i
我会这样做：

1 4 9 16 9 7 4 9 11 

11 9 4 7 9 16 9 4 1 

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

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
}

或者你也可以从后面绕过去

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

（注意：我没有编译这个，但希望它是正确的）
我希望保留原始数组并返回副本。这是一个通用版本：

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

公共静态T[]反向（T[]数组）{
T[]copy=array.clone（）；
Collections.reverse（Arrays.asList（copy））；
返回副本；
}

在不保留原始阵列的情况下：

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

publicstaticvoidreverse（T[]数组）{
Collections.reverse（Arrays.asList（array））；
}
你把事情搞砸了

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

您可以使用org.apache.commons.lang.ArrayUtils：
ArrayUtils.reverse（数组）
尝试以下操作：

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

public int[]reverse3（int[]nums）{
int[]反向=新int[nums.length]；
对于（int i=0；i互换金额最小的原地反转）

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

for（int i=0；i
此代码将有助于：

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

public void swap（int[]arr，int a，int b）
{
int temp=arr[a]；
arr[a]=arr[b]；
arr[b]=温度；
}
公共内部[]反向通道（内部[]arr）{
int size=arr.length-1；
对于（int i=0；i以下内容将在索引
i
和
j
之间就地反转数组（要反转整个数组调用
反转（a，0，a.length-1）
）

public void reverse（int[]a，int i，int j）{
int ii=i；
int jj=j；
而（ii
如果不想使用临时变量，也可以这样做：

1 4 9 16 9 7 4 9 11 

11 9 4 7 9 16 9 4 1 

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

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
}

final int len=arr.length；
对于（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
}
您可以将原始数组发送到一个方法，例如：

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

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


}

公共静态无效反向（int[]a）{
int[]reversedArray=新int[a.length]；
对于（int i=0；i使用循环将前半部分中的每个元素与后半部分中的元素交换。如果我使用void，这意味着我将无法在此方法中使用return语句，对吗？这是真的。您可以保留可能返回或不返回的exist数组。或者您可以返回一个副本。基于您已有的想法，我将我猜您在开发方面很有经验，所以我将指出一个简单的替代方法。只需在反转的for循环中执行您想要的操作，而不是实际反转数组。
for（int I=someArray.length-1；I>0；I--）{doStuff（someArray[I]）；}reversedArray[j++]=firstArray[I]；}
您能再解释一下吗？谢谢。请查看答案的编辑。为什么要实例化新的ArrayList？Arrays.asList（）已经返回了一个列表。谢谢@cypressious，我的印象是Arrays.asList将返回一个不可修改的列表。更正了这个问题。Arrays.asList实际上返回一个冻结列表，即您不能从新创建的列表中添加或删除任何元素。但是，您可以在原地修改元素。@RodrigoKossmann。。或者您可以只使用：-
numsrurn[count--]=num
在for循环之前将
array.length/2
部分放到外部难道不值得吗？我相信每次迭代都会重新计算。@JinKwon我相信编译器会以这种方式增强它，您可以用javap@JinKwon为了澄清这一点，我不是指javac，而是指JIT编译器，即对在运行时发生。@Begueradj-我觉得这是一个答案-不一定是一个好答案，但这是一个答案。虽然是一个旧答案，但我花了一些时间才弄明白…这对op不起作用，因为int[]是一个对象和数组。asList（数组）将返回List而不是List（无论如何这是不可能的）因此，实际上一个列表中只有一个条目是相反的。这适用于所有基元数组！public int decToBinary（int n）{//array来存储二进制数int[]binaryNum=new int[1000]；//二进制数组的计数器int i=0；while（n>0）{//将余数存储在二进制数组binaryNum[i]=n%2；n=n/2；i++；}返回集合。reverse（Arrays.asList（binaryNum））；}--------------给出错误-->错误：不兼容的类型：void无法转换为int返回集合。reverse（Arrays.asList（binaryNum））；这真的很有帮助。我喜欢这样一个事实，即您没有更改原始数组，而是返回了一个新数组。不适用于原语数组，尽管我喜欢这个答案，因为它避免了在循环中调用.length方法，并且不经常计算len-1-I；它适用于数组的任何范围，并且使用swap而不是temp变量。但是没有理由使用重复变量（ii&jj）；您可以直接使用i&j。我会交换（ii++，jj-）并避免额外的行。还要注意，它只在i