Как изменить массив int в Java?

Чтобы отменить массив 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; } 

Как вы это делаете, вы меняете каждый элемент дважды, поэтому результат совпадает с исходным.

С Commons.Lang вы можете просто использовать

 ArrayUtils.reverse(int[] array) 

В большинстве случаев быстрее и безопаснее использовать легкодоступные библиотеки, которые уже прошли тестирование и тестирование пользователей, когда они заботятся о вашей проблеме.

 public class ArrayHandle { public static Object[] reverse(Object[] arr) { List 

Я думаю, что немного легче следовать логике алгоритма, если вы объявляете явные переменные для отслеживания индексов, которые вы меняете на каждой итерации цикла.

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

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

java.util.Collections.reverse() может отменить java.util.List s и java.util.Arrays.asList() возвращает список, который обертывает конкретный массив, который вы передаете ему, поэтому yourArray отменяется после вызова Collections.reverse() .

Стоимость – это просто создание одного объекта List, и никаких дополнительных библиотек не требуется.

Аналогичное решение было представлено в ответе Тарика и их комментаторов, но я думаю, что этот ответ был бы более кратким и более понятным.

С Гуавой:

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

Здесь уже много ответов, в основном основное внимание уделяется модификации массива на месте. Но для полноты, вот еще один подход, использующий streamи Java для сохранения исходного массива и создания нового обратного массива:

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

Это поможет вам

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

Простой цикл!

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

Если вы работаете с более примитивными данными (т. Е. 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]; } } 

Вот как я лично ее решаю. Причина создания параметризованного метода заключается в том, чтобы разрешить сортировку любого массива … а не только целые числа.

Надеюсь, вы что-то извлекли из этого.

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

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

Наиболее эффективно просто перебрать массив назад.

Я не уверен, что решение Aaron делает это vi этим вызовом Collections.reverse(list); Кто-нибудь знает?

Ваша программа будет работать только для 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 } 

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

Вот простое быстрое решение. Надеюсь, поможет!.

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

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

В случае 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] 

 static int[] reverseArray(int[] a) { int ret[] = new int[a.length]; for(int i=0, j=a.length-1; i=0; i++, j--) ret[i] = a[j]; return ret; } 

Разве это не было бы слишком маловероятно для ошибок?

  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; 

Ниже приведена полная программа для запуска на вашем компьютере.

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

Для программ по матрице с использованием массивов это будет хороший источник. По ссылке.

Используя решение XOR, чтобы избежать переменной temp, ваш код должен выглядеть так:

 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/

 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