Jak odwrócić tablicę int w Javie?

238

Próbuję odwrócić tablicę int w Javie.

Ta metoda nie odwraca tablicy.

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

Co jest z tym nie tak?

MichaelScott
źródło
31
Widzę, co zrobiłem źle. Powinny być poprawne Data.length / 2. W przeciwnym razie odwróci się, a następnie cofnie.
MichaelScott
4
Zobacz en.wikipedia.org/wiki/In-place_algorithm, który zawiera opis poprawnej wersji tego algorytmu.
Dean Povey

Odpowiedzi:

284

Aby odwrócić tablicę int, zamieniasz elementy aż do osiągnięcia punktu środkowego, w ten sposób:

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

Sposób, w jaki to robisz, zamieniasz każdy element dwa razy, więc wynik jest taki sam jak początkowa lista.

3lectrologos
źródło
I chciałbym umieścić validData.length / 2część na zewnątrz pętli for.
Jin Kwon
7
@Jin, nie chciałbym. To tylko zaciemnia znaczenie i założę się, że kompilator optymalizacyjny i tak by to zrobił. Niezależnie od tego nie ma sensu mikrooptymalizacja, dopóki nie uzyskasz wyraźnych dowodów z profilowania, że ​​jest to konieczne / pomocne.
Nicu Stiurca,
9
@ JinKwon To byłoby trochę jak robienie validData.length >> 1. Jest to równoważne i szybsze, ale dezorientuje wielu programistów i każdy dobry kompilator zrobi to automatycznie.
Justin
2
Powinieneś wykonać to obliczenie tylko raz validData.length - i - 1i zapisać je w zmiennej.
Czy ktoś może zasugerować odwrócenie bez zmiennej temp !!
sg28
303

Dzięki Commons.Lang możesz po prostu użyć

ArrayUtils.reverse(int[] array)

W większości przypadków szybsze i bezpieczniejsze jest trzymanie się łatwo dostępnych bibliotek, które są już testowane jednostkowo i testowane przez użytkownika, gdy zajmują się Twoim problemem.

Manur
źródło
3
Wolałbym, żeby zwrócił odwróconą (przekazaną) tablicę dla stylu funkcjonalnego.
Laurent G
2
@ laurent-g, żeby być uczciwym: odwrócenie tablicy w ten sposób jest bardziej wydajne pod względem pamięci, i prawdopodobnie dlatego zrobili to w ten sposób.
Sirmyself
4
Nie chodziło mi o kopię ani o kopię. Moja wiadomość stwierdza, że ​​„(przekazany)” ma zostać zwrócony (po odwróceniu), więc może zostać przekazany w wyrażeniu, nie wymagającym osobnej instrukcji.
Laurent G
52
public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}
Tarik
źródło
11
Oczywiście, tak będzie. Lista może zawierać tylko obiekty, a nie prymitywy, więc wszystkie prymitywy ( intw tym przypadku) są zawijane w odpowiednie opakowania ( Integerw tym przypadku) i umieszczane na liście. Widzisz, Integers są obiektami. @Tom
11684,
6
Uwaga: jeśli się nie mylę, oryginalna tablica jest modyfikowana. Aby to wyjaśnić, możesz po prostu niczego nie zwracać.
Andrea Zilio
3
@ 11684 Tak, listy ogólne mogą zawierać tylko obiekty. Ale metoda nie obejmuje tablicy. Tablice mogą zawierać prymitywy. Dlatego int[]różni się od Integer[]. Wypróbuj: Integer[] array = new int[5]. Otrzymasz błąd kompilacji. Dlatego Arraysklasa Java definiuje wiele metod pracy z pierwotnymi tablicami. Próba przekazania int[]do powyższej metody da w wyniku coś takiego The method reverse(Object[]) in the type MakeSimple is not applicable for the arguments (int[]). @Filip - algorytm lokalny zużywa mniej pamięci i działa szybciej.
Brian McCutchon
3
@Andrea W rzeczywistości tak nie jest. Lista zwrócona przez Arrays.asList()nie odwołuje się do oryginalnej tablicy, a tablica nie jest zwracana. To jeden z problemów związanych z tą metodą: wykorzystuje potrójną pamięć i potroi pracę jako algorytm lokalny.
Brian McCutchon
4
Ta metoda może działać, ale po prostu nie można przekazać jej int[]argumentu jako argumentu ( „typy niezgodne: int [] nie mogą zostać przekonwertowane na Object []” ).
MC Emperor,
47
Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse() może odwrócić java.util.List s i java.util.Arrays.asList()zwraca listę, która otacza określoną tablicę, którą mu przekazujesz, dlatego yourArrayjest odwrócona po wywołaniu Collections.reverse().

Koszt to tylko utworzenie jednego obiektu listy i nie są wymagane żadne dodatkowe biblioteki.

Podobne rozwiązanie zostało przedstawione w odpowiedzi Tarika i ich komentatorów, ale myślę, że ta odpowiedź byłaby bardziej zwięzła i łatwiejsza do przeanalizowania.

escitalopram
źródło
15
W przypadku tablic obiektów jest to dobre rozwiązanie. Ale to nie działa na tablice prymitywów. Np. przekazanie int[]doasList(...) nie zwróci a List<Integer>, ale a List<int[]>, zawierającego jeden element. AFAICS nie ma prostego, wbudowanego sposobu konwersji int[]an Integer[].
Martin Rust
4
To nie będzie działać z prymitywnymi tablicami ... kolekcje nie zwracają wartości, więc teraz masz niepotrzebną tablicę jako listę w pamięci
NightSkyCode
@MartinRust Java 8+: Arrays.stream(arr).boxed().collect(Collectors.toList())lubArrays.stream(arr).boxed().toArray(Integer[]::new)
Simon Forsberg
39

Myślę, że nieco łatwiej jest podążać za logiką algorytmu, jeśli deklarujesz zmienne jawne, aby śledzić indeksy, które zamieniasz przy każdej iteracji pętli.

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

Myślę też, że łatwiej jest to zrobić w pętli 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--;
    }
}
Bill jaszczurka
źródło
old school swap wygląda na łatwiejszy, ale tak, jeśli uwzględni się wartości indeksu tablicowego w lewo, w prawo, ... będzie pomocne przy debugowaniu, jeśli w ogóle
Srinath Ganesh
Możesz także dodać „public static void swap (int [] data, int index1, int index2) {...}” i użyć tego z „reverse” w następujący sposób: swap (data, left, right).
pm_
13

Jest tu już wiele odpowiedzi, głównie skoncentrowanych na modyfikacji tablicy w miejscu. Ale ze względu na kompletność, oto inne podejście wykorzystujące strumienie Java do zachowania oryginalnej tablicy i utworzenia nowej tablicy odwróconej:

    int[] a = {8, 6, 7, 5, 3, 0, 9};
    int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();
Patrick Parker
źródło
10

Z Guava:

Collections.reverse(Ints.asList(array));
ZhekaKozlov
źródło
4
To jest genialne! Krótki i skuteczny. Podobnie jak wszystkie asListmetody, tworzy widok, który zapisuje bezpośrednio do podkładowej (pierwotnej) tablicy. Wydaje mi się, że głosujący w wyborach wyborczych omyłkowo pomyślał, że to zwróciło listę pudełkową lub coś takiego.
Luke Usherwood
@LukeUsherwood przypuszczalnie nadal będzie pewne obciążenie związane z boksem i rozpakowaniem podczas wywoływania get i set dla każdego elementu. Ale zgadzam się z tobą, że jest to genialne rozwiązanie.
Patrick Parker
Rzeczywiście, warto o tym wiedzieć. Nie sądzę, żeby byłaby to wielka sprawa w większości kodu, z którym osobiście pracuję - nasze „gorące” obszary są dobrze zdefiniowane, reszta to rodzaj „kodu kleju”. Jednocześnie jestem świadomy, że rezygnacja z pamięci powoduje również dodatkowy „ukryty” koszt, którego profilerzy nie przypisują rzeczywistej funkcji.
Luke Usherwood
@LukeUsherwood nadal zwraca listę pudełkową zamiast tablicy podstawowej
AnthonyJClink
2
@AnthonyJClink Nie jestem pewien, do czego to się odnosi, ale narzędzie JDK Collections.reversejest nieważną metodą. Działa to w miejscu na wewnętrznej klasie Guava, która otacza int[](Ponieważ nigdy nie przechowuje listy pudełek Integer, nie nazwałbym tej klasy „listą pudełkową”, a raczej „Widok listy tablicy”). Ale tak, działa poprzez interfejs przekazujący Integerobiekty, więc spowodowałoby to wiele tymczasowych rezygnacji i boksowania obiektów, jak wspomniano. Wypróbuj IntStreambibliotekę lub prymitywną bibliotekę, w której liczy się wydajność. (Trove, Koloboke, Eclipse Collections, ...)
Luke Usherwood,
10

W przypadku Java 8 możemy również użyć IntStreamdo odwrócenia tablicy liczb całkowitych, takich jak:

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]
akhil_mittal
źródło
7

Prosty w pętli!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
    int aux = array[start];
    array[start]=array[end];
    array[end]=aux;
}
Apetrei Ionut
źródło
4
W przyszłości poinformuj pytającego, co zrobili niepoprawnie i co zrobiłeś poprawnie.
Kartik Chugh
1
zmień start <= endnastart < end
Leonard Pauli
5

To ci pomoże

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;
}
Krishna Kumar Chourasiya
źródło
5
for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }
Deepak Singh
źródło
Niestety, jest to najczystsza dostępna odpowiedź tutaj, ponieważ każdy programista będzie wiedział, jak to zrobić i nie wymaga żadnych rozszerzonych instalacji pakietów.
HoldOffHunger
5

Tak osobiście bym to rozwiązał. Powodem stworzenia sparametryzowanej metody jest umożliwienie sortowania dowolnej tablicy ... nie tylko liczb całkowitych.

Mam nadzieję, że coś z tego wyciągniesz.

@Test
public void reverseTest(){
   Integer[] ints = { 1, 2, 3, 4 };
   Integer[] reversedInts = reverse(ints);

   assert ints[0].equals(reversedInts[3]);
   assert ints[1].equals(reversedInts[2]);
   assert ints[2].equals(reversedInts[1]);
   assert ints[3].equals(reversedInts[0]);

   reverseInPlace(reversedInts);
   assert ints[0].equals(reversedInts[0]);
}

@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
    if (array == null) {
        return (T[]) new ArrayList<T>().toArray();
    }
    List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
    Collections.reverse(copyOfArray);
    return copyOfArray.toArray(array);
}

private static <T> T[] reverseInPlace(T[] array) {
    if(array == null) {
        // didn't want two unchecked suppressions
        return reverse(array);
    }

    Collections.reverse(Arrays.asList(array));
    return array;
}
AnthonyJClink
źródło
2
Nie rozwiązuje oryginalnego problemu przy użyciu naczelnych.
Melinda Green
Istnieje wiele sposobów konwersji prymów na obiekty. Zawsze zalecam unikanie kotów prymaskich, gdy tylko jest to możliwe w java i uważam, że należy je zachęcać.
AnthonyJClink
Przekształcanie tablicy prymitywów o nieznanej długości w tablicę może być bardzo złym pomysłem, zwłaszcza jeśli jest wykonywane bez uświadomienia sobie tego. Java to nie Smalltalk. Prymitywy są częścią języka i mają swoje miejsce. Nie ma znaczenia, że ​​ich nie lubimy, musimy je zaakceptować i używać w razie potrzeby.
Melinda Green
1
Właściwie nie musisz kopiować tablicy Collections.reverse(asList(arraytoReverse)); return arrayToReverse;. asListjest tylko otoczką tablicy, więc oryginalna tablica jest odwrócona.
Radiodef,
3

Twój program będzie działał tylko length = 0, 1. Możesz spróbować :

int i = 0, j = validData.length-1 ; 
while(i < j)
{
     swap(validData, i++, j--);  // code for swap not shown, but easy enough
}
fastcodejava
źródło
3
Być może miałeś na myśli zamianę jako pseudo-kod dla zamiany wbudowanej zamiast wywołania metody, ale jeśli nie, to nie zadziała. Java przechodzi przez referencję, więc nie można napisać metody wymiany zmiennych.
Dean Povey
Miałem na myśli jakikolwiek sposób na zamianę v [i] i v [j]. Wiem, jak wywołania metod działają w java. Dla metody możesz zrobić coś takiego jak zamiana (v, i ++, j--);
fastcodejava
1
Dziekan, tablica validData jest obiektem przekazywanym przez referencję, więc metoda swap () będzie działać idealnie.
Gaël Oberson
3

Jeśli pracujesz z danymi, które są bardziej prymitywne (np. Char, bajt, int itp.), Możesz wykonać zabawne operacje 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];
    }
}
AbsoluteBlue
źródło
1
Zbyt słodki, by go używać w kodzie produkcyjnym, ale i tak jest zabawny. Aby uzyskać maksymalną ostrość, użyj operacji% = w następujący sposób: array [i]% = array [len - i - 1] itp.
Melinda Green
Podobne, ale nieco krótsze:for (int m = x.length, i = --m / 2; ++i <= m;) { x[i] ^= x[m - i]; x[i] ^= x[m - i] ^= x[i]; }
Thomas Mueller
2

Najbardziej wydajne jest po prostu iterowanie tablicy do tyłu.

Nie jestem pewien, czy rozwiązanie Aarona to to połączenie. Collections.reverse(list);Czy ktoś wie?

Nick Strupat
źródło
Iteracja wstecz po tablicy wymaga nowej tablicy. Podoba mi się powyższe rozwiązanie, które wykonuje wbudowane odwracanie bez tworzenia nowej tablicy.
mmcdole
1
@Simucal po co tworzyć nową tablicę? Po prostu powtórz to do tyłu.
Trejkaz
2
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;
        }
    }
Amicos
źródło
1
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]);
  }
}
programista duchów
źródło
1
tak, próbowałem tego samego i czystego kodu wraz z danymi wyjściowymi int [] a = {1,3,5,2,6,7}; for (int i = a.length-1; i> = 0; i--) {System.out.print (a [i] + "");} `odwróci tablicę od ostatniego indeksu do pierwszego indeksu
Rocket_03,
1

Czy zrobienie tego w ten sposób nie byłoby znacznie bardziej prawdopodobne w przypadku błędów?

    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;
ModDL
źródło
1

Rozwiązanie o złożoności czasowej o (n) i złożoności przestrzennej o (1).

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--;
    }
}
użytkownik11016
źródło
Wystarczy FYI, to można uprościć do kompleksu dla pętli: for (int start = 0, end = array.length - 1; start < end; start++, end--) { ... }.
Tim Cooke
1

2 sposoby odwrócenia tablicy.

  1. Używając pętli For i zamieniaj elementy do punktu środkowego ze złożonością czasową O (n / 2).

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

    }

  2. Korzystanie z wbudowanej funkcji (Collections.reverse ())

    private static void reverseArrayUsingBuiltInFun() {
    int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
    
    Collections.reverse(Ints.asList(array));
    System.out.println(Arrays.toString(array));

    }

    Wyjście: [6, 5, 4, 3, 2, 1]

Sameer Shrestha
źródło
3
Co to jest Ints?
CodingNow
@CodingNow to jedna z klas pomocniczych narzędzi Guava - patrz tutaj
mrec
1
    public static void main(String args[])    {
        int [] arr = {10, 20, 30, 40, 50}; 
        reverse(arr, arr.length);
    }

    private static void reverse(int[] arr,    int length)    {

        for(int i=length;i>0;i--)    { 
            System.out.println(arr[i-1]); 
        }
    }
Kalidindi Prashanth
źródło
1

Istnieje kilka świetnych odpowiedzi powyżej, ale tak to zrobiłem:

public static int[] test(int[] arr) {

    int[] output = arr.clone();
    for (int i = arr.length - 1; i > -1; i--) {
        output[i] = arr[arr.length - i - 1];
    }
    return output;
}
Ahmad Dalao
źródło
0

poniżej znajduje się kompletny program do uruchomienia na twoim komputerze.

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

Dla programów wykorzystujących tablice na macierzy będzie to dobre źródło. Przejdź przez link.

Mdhar9e
źródło
0

Korzystanie z rozwiązania XOR w celu uniknięcia zmiennej temp powinien wyglądać kod

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

Zobacz ten link, aby uzyskać lepsze wyjaśnienie:

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

vikarjramun
źródło
0
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;
} 
Stuart Clark
źródło
4
Rozważ dodanie wyjaśnienia do swojej odpowiedzi. Odpowiedzi tylko w kodzie nic nie wyjaśniają.
rgettman,
0

Oto prosta implementacja odwracania tablicy dowolnego typu oraz pełna / częściowa obsługa.

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

}

Oto odpowiedni test jednostkowy

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));
 }
}
craftsmannadeem
źródło
0

Oto, co wymyśliłem:

// 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);
Proste rozwiązanie
źródło
0

Istnieją dwa sposoby rozwiązania problemu:

1. Odwróć tablicę w przestrzeni.

Krok 1. Zamień elementy na początku i na końcu indeksu.

Krok 2. Zwiększ indeks początkowy, zmniejsz indeks końcowy.

Krok 3. Powtarzaj krok 1 i krok 2, aż do początku indeksu <koniec indeksu

W tym celu złożoność czasu wyniesie O (n), a złożoność przestrzeni wyniesie O (1)

Przykładowy kod do odwrócenia tablicy w przestrzeni wygląda następująco:

public static int[] reverseAnArrayInSpace(int[] array) {
    int startIndex = 0;
    int endIndex = array.length - 1;
    while(startIndex < endIndex) {
        int temp = array[endIndex];
        array[endIndex] = array[startIndex];
        array[startIndex] = temp;
        startIndex++;
        endIndex--;
    }
    return array;
}

2. Odwróć tablicę za pomocą tablicy pomocniczej.

Krok 1. Utwórz nową tablicę o rozmiarze równym podanej tablicy.

Krok 2. Wstaw elementy do nowej tablicy, zaczynając od indeksu początkowego, od podanej tablicy, zaczynając od indeksu końcowego.

W tym celu złożoność czasu będzie wynosić O (n), a złożoność przestrzeni będzie wynosić O (n)

Przykładowy kod do odwracania tablicy za pomocą tablicy pomocniczej wygląda następująco:

public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
    int[] reversedArray = new int[array.length];
    for(int index = 0; index < array.length; index++) {
        reversedArray[index] = array[array.length - index -1]; 
    }
    return reversedArray;
}

W tym celu możemy również użyć interfejsu API kolekcji Java.

Interfejs API kolekcji korzysta wewnętrznie z tego samego podejścia odwrotnego w przestrzeni.

Przykładowy kod do korzystania z interfejsu API kolekcji wygląda następująco:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}
Karan Khanna
źródło
0
static int[] reverseArray(int[] a) {
     int ret[] = new int[a.length];
     for(int i=0, j=a.length-1; i<a.length && j>=0; i++, j--)
         ret[i] = a[j];
     return ret;
}
ZA Abbasi
źródło
0
 public static int[] reverse(int[] array) {

    int j = array.length-1;
    // swap the values at the left and right indices //////
        for(int i=0; i<=j; i++)
        {
             int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
           j--;
        }

         return array;
    }

      public static void main(String []args){
        int[] data = {1,2,3,4,5,6,7,8,9};
        reverse(data);

    }
roshan posakya
źródło