如何在Java中反转int数组？

我想在Java中反转一个int数组。

此方法不会颠倒数组。

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

这是怎么回事？

Answer 1

为了反转一个int数组，你将项目交换到中点，如下所示：

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

你这样做，你交换每个元素两次，所以结果是一样的初始列表。

Answer 2

与Commons.Lang ，你可以简单地使用

 ArrayUtils.reverse(int[] array) 

大多数情况下，使用易于使用的库已经进行了unit testing和用户testing，可以更快速，更安全地保护错误。

Answer 3

 public class ArrayHandle { public static Object[] reverse(Object[] arr) { List<Object> list = Arrays.asList(arr); Collections.reverse(list); return list.toArray(); } } 

Answer 4

我认为如果你声明显式variables来跟踪在循环的每次迭代中交换的索引，那么遵循algorithm的逻辑就容易一些。

 public static void reverse(int[] data) { for (int left = 0, right = data.length - 1; left < right; left++, right--) { // swap the values at the left and right indices int temp = data[left]; data[left] = data[right]; data[right] = temp; } } 

我也认为在while循环中这样做更具可读性。

 public static void reverse(int[] data) { int left = 0; int right = data.length - 1; while( left < right ) { // swap the values at the left and right indices int temp = data[left]; data[left] = data[right]; data[right] = temp; // move the left and right index pointers in toward the center left++; right--; } } 

Answer 5

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

java.util.Collections.reverse()可以反转java.util.List s和java.util.Arrays.asList()返回一个列表，该列表包装了传递给它的特定数组，因此在调用Collections.reverse()之后， yourArray被反转Collections.reverse() 。

成本只是创build一个List对象，不需要额外的库。

Tarik及其评论者的回答中也提出了类似的解决scheme，但我认为这个答案会更简洁，更易于parsing。

Answer 6

这将帮助你

 int a[] = {1,2,3,4,5}; for (int k = 0; k < a.length/2; k++) { int temp = a[k]; a[k] = a[a.length-(1+k)]; a[a.length-(1+k)] = temp; } 

Answer 7

简单的循环！

 for (int start = 0, end = array.length - 1; start <= end; start++, end--) { int aux = array[start]; array[start]=array[end]; array[end]=aux; } 

Answer 8

如果使用更原始的数据（即char，byte，int等），则可以执行一些有趣的XOR操作。

 public static void reverseArray4(int[] array) { int len = array.length; for (int i = 0; i < len/2; i++) { array[i] = array[i] ^ array[len - i - 1]; array[len - i - 1] = array[i] ^ array[len - i - 1]; array[i] = array[i] ^ array[len - i - 1]; } } 

Answer 9

这是我个人如何解决这个问题。 创build参数化方法的原因是允许任何数组sorting…不只是你的整数。

我希望你从中得到一些东西。

 @Test public void reverseTest(){ Integer[] ints = {1, 2, 3, 4}; Integer[] reversedInts = reverse(ints); assertEquals(Integer.valueOf(1), reversedInts[3]); assertEquals(Integer.valueOf(4), reversedInts[0]); } public static <T> T[] reverse(T[] arrayToReverse){ //as per the collections spec (and pointed out by @Radiodef) // the collections api will sort the array in place. Collections.reverse(Arrays.asList(arrayToReverse)); return arrayToReverse; } 

Answer 10

 for(int i=validData.length-1; i>=0; i--){ System.out.println(validData[i]); } 

Answer 11

番石榴：

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

Answer 12

这里已经有很多答案，主要集中在修改arrays。 但为了完整起见，下面是使用Javastream来保存原始数组并创build一个新的反向数组的另一种方法：

  int[] a = {8, 6, 7, 5, 3, 0, 9}; int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray(); 

Answer 13

简单地向后迭代数组是最有效的。

我不确定Aaron的解决scheme是否会调用Collections.reverse(list); 有人知道吗？

Answer 14

你的程序只能工作length = 0, 1 。 你可以试试 ：

 int i = 0, j = validData.length-1 ; while(i < j) { swap(validData, i++, j--); // code for swap not shown, but easy enough } 

Answer 15

 public void display(){ String x[]=new String [5]; for(int i = 4 ; i > = 0 ; i-- ){//runs backwards //i is the nums running backwards therefore its printing from //highest element to the lowest(ie the back of the array to the front) as i decrements System.out.println(x[i]); } } 

Answer 16

这是一个简单的快速解决scheme。 希望它有帮助！

 public int[] reverse(int[] arr) { for(int i = arr.length; i > 0 ; i--){ System.out.print(arr[i-1] + " "); } return arr; } 

Answer 17

 public void getDSCSort(int[] data){ for (int left = 0, right = data.length - 1; left < right; left++, right--){ // swap the values at the left and right indices int temp = data[left]; data[left] = data[right]; data[right] = temp; } } 

Answer 18

不这样做是不是更不可能的错误？

  int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int[] temp = new int[intArray.length]; for(int i = intArray.length - 1; i > -1; i --){ temp[intArray.length - i -1] = intArray[i]; } intArray = temp; 

Answer 19

下面是在你的机器上运行的完整程序。

 public class ReverseArray { public static void main(String[] args) { int arr[] = new int[] { 10,20,30,50,70 }; System.out.println("reversing an array:"); for(int i = 0; i < arr.length / 2; i++){ int temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; } for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } } 

对于matrix使用数组的程序， 这将是很好的来源 。通过链接。

Answer 20

使用XOR解决scheme来避免tempvariables，你的代码应该看起来像

 for(int i = 0; i < validData.length; i++){ validData[i] = validData[i] ^ validData[validData.length - i - 1]; validData[validData.length - i - 1] = validData[i] ^ validData[validData.length - i - 1]; validData[i] = validData[i] ^ validData[validData.length - i - 1]; } 

看到这个链接更好的解释：

http://betterexplained.com/articles/swap-two-variables-using-xor/

Answer 21

 public class TryReverse { public static void main(String[] args) { int [] array = {2,3,4,5,6,7,8,9}; reverse(array); for(int i=0; i<array.length; ++i) System.out.print(array[i] + " "); } public static void reverse (int [] array){ for(int start=0, end=array.length-1; start<=end; start++, end--){ int aux = array[start]; array[start]=array[end]; array[end]=aux; } } } 

Answer 22

 private static int[] reverse(int[] array){ int[] reversedArray = new int[array.length]; for(int i = 0; i < array.length; i++){ reversedArray[i] = array[array.length - i - 1]; } return reversedArray; } 

Answer 23

试试这个代码：

  int arr[] = new int[]{1,2,3,4,5,6,7}; for(int i=0;i<arr.length/2;i++){ int temp = arr[i]; arr[i] = arr[(arr.length-1)-i]; arr[(arr.length-1)-i] = temp; } System.out.println(Arrays.toString(arr)); 

Answer 24

这里是一个简单的实现，以反转任何types的数组，加上全部/部分支持。

 import java.util.logging.Logger; public final class ArrayReverser { private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName()); private ArrayReverser () { } public static <T> void reverse(T[] seed) { reverse(seed, 0, seed.length); } public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) { if (seed == null || seed.length == 0) { LOGGER.warning("Nothing to rotate"); } int start = startIndexInclusive < 0 ? 0 : startIndexInclusive; int end = Math.min(seed.length, endIndexExclusive) - 1; while (start < end) { swap(seed, start, end); start++; end--; } } private static <T> void swap(T[] seed, int start, int end) { T temp = seed[start]; seed[start] = seed[end]; seed[end] = temp; } } 

这是相应的unit testing

 import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; import org.junit.Before; import org.junit.Test; public class ArrayReverserTest { private Integer[] seed; @Before public void doBeforeEachTestCase() { this.seed = new Integer[]{1,2,3,4,5,6,7,8}; } @Test public void wholeArrayReverse() { ArrayReverser.<Integer>reverse(seed); assertThat(seed[0], is(8)); } @Test public void partialArrayReverse() { ArrayReverser.<Integer>reverse(seed, 1, 5); assertThat(seed[1], is(5)); } } 

Answer 25

另一种反转数组的方法

 public static int []reversing(int[] array){ int arraysize = array.length; int[] reverse = new int [arraysize+1]; for(int i=1; i <= arraysize ; i++){ int dec= arraysize -i; reverse[i] = array[dec]; } return reverse; } 

Answer 26

如果你想要反转，直到到达数组的中间位置，这种方法才有效。

  double [] list = {11,21,31,41,51,61,71,81,91}; int midpoint = list.length/2 -1; int firstVal = 0; while(firstVal < midpoint){ double midPoint = list[midpoint]; double firstValue = list[firstVal]; list[midpoint] = firstValue; list[firstVal] = midPoint; firstVal = firstVal + 1; midpoint = midpoint-1; } StdOut.println(Arrays.toString(list)); } 

Answer 27

由于我打算保留原来的arrays，所以我用以下方式解决了这个问题：

 List<Integer> normalArray= new ArrayList<>(); List<Integer> reversedArray = new ArrayList<>(); // Fill up array here for (int i = 1; i <= normalArray.size(); i++) { reversedArray .add(normalArray.get(normalArray.size()-i)); } 

所以基本上循环通过初始数组，并以相反的顺序将所有的值添加到新的（反向）数组。 列表的types可以是任何东西。 我多次通过此代码工作，导致其他一些解决scheme无法工作。

Answer 28

这是我所想到的：

 // solution 1 - boiler plated Integer[] original = {100, 200, 300, 400}; Integer[] reverse = new Integer[original.length]; int lastIdx = original.length -1; int startIdx = 0; for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++) reverse[startIdx] = original[endIdx]; System.out.printf("reverse form: %s", Arrays.toString(reverse)); // solution 2 - abstracted // convert to list then use Collections static reverse() List<Integer> l = Arrays.asList(original); Collections.reverse(l); System.out.printf("reverse form: %s", l); 

Answer 29

在Java 8的情况下，我们也可以使用stream来反转整数数组，如下所示：

 int[] sample = new int[]{1,2,3,4,5}; int size = sample.length; int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1]) .toArray(); //Output: [5, 4, 3, 2, 1] 

Answer 30

具有o（n）时间复杂度和o（1）空间复杂度的解决scheme。

 void reverse(int[] array) { int start = 0; int end = array.length - 1; while (start < end) { int temp = array[start]; array[start] = array[end]; array[end] = temp; start++; end--; } }