Keer een array om in Java

Arrays worden vaak gebruikt bij het coderen en zijn een manier om meerdere waarden van hetzelfde type op te slaan in één variabele. Er kunnen veel redenen zijn waarom een ​​codeur een array wil omkeren. Het kan nodig zijn om een ​​array om te keren, bijvoorbeeld wanneer de logica van een probleem moet beginnen met het laatste element. In dit geval is het de beste praktijk om de omkering uit te voeren en vervolgens waar nodig de omgekeerde array in de code te gebruiken. Sterker nog, het omkeren van een array is een erg populaire taak in Java Juniors-interviews.

Hoe een array om te keren

Er zijn veel manieren om een ​​array om te keren, en hier bekijken we 5. Voor Optie 1 wordt een array omgekeerd met behulp van een extra array die in oplopende volgorde wordt ingevuld vanaf het einde van de oorspronkelijke array (aflopend), in Optie 2 een in-place omkering wordt uitgevoerd waarbij array-elementen aan het begin en einde worden verwisseld, in Optie 3 wordt de methode reverse() uit het Collections-framework gebruikt om de omkering uit te voeren, in Optie 4, List.add() en List.remove() worden gebruikt, en ten slotte wordt in Optie 5 recursie gebruikt.

Optie 1: een array omkeren met behulp van een extra array

Laten we een eenvoudige methode schrijven om een ​​array om te keren met behulp van een extra array . Deze optie gebruikt een extra array die wordt gevuld beginnend met het laatste element van de originele array in aflopende volgorde, dwz het eerste element is hetzelfde als het laatste element in de originele array, het tweede is hetzelfde als het op een na laatste en dus aan totdat de extra array is gevuld.

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

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

       return newArray;
   }
}

In dit voorbeeld hebben we een methode geschreven die een array omkeert en een nieuwe omgekeerde array retourneert, gebaseerd op de array die eraan is doorgegeven. array wordt gedeclareerd in main en vervolgens wordt een methode, reverse , aangeroepen. Het argument van de methode is de array. In methode reverse wordt een nieuwe array, newArray , gemaakt en is even groot als array , alleen helemaal leeg. Een for- lus wordt gebruikt om de newArray in te vullen en werkt over de hele lengte van de array. Dit wordt gedaan door te beginnen met het eerste element van een array en dit toe te wijzen aan het laatste element van newArray, vervolgens het tweede element van onze array nemen en toewijzen aan het voorlaatste element van newArray , enzovoort; newArray wordt achterstevoren ingevuld. Wanneer de for-lus is voltooid, is newArray volledig vol en is het precies het tegenovergestelde van de array .

Optie 2: print de elementen van een array in omgekeerde volgorde

Voor deze optie om een ​​array om te keren, is het niet nodig om een ​​extra array te gebruiken en wordt deze niet geconverteerd naar een arraylijst. In plaats daarvan worden de array-elementen op hun plaats in omgekeerde volgorde geplaatst . Dit betekent dat ze in feite worden verwisseld. Het eerste element wordt verwisseld met het laatste element, het tweede element wordt verwisseld met het op een na laatste, enzovoort. Er wordt een for- lus gebruikt en wanneer deze is voltooid, is de array omgekeerd. De code ziet er als volgt uit:

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

De originele array wordt afgedrukt als een String met behulp van Arrays.toString(array) , en vervolgens wordt onze array doorgegeven als een argument in reverse . Bij de omgekeerde methode in de for- lus wordt een variabele, temp, gemaakt en gebruikt. In de for -lus wordt de omgekeerde volgorde bereikt in drie stappen:

1. het eerste element toewijzen aan temp
2. toewijzen van het laatste element aan het eerste element
3. het toewijzen van temp aan het laatste element

Dit wordt dan dit keer opnieuw uitgevoerd voor het tweede element en het tweede van het laatste element, enzovoort. Dit wordt gedaan voor opeenvolgende elementen van de array, maar de lus herhaalt slechts tot de helft van de arraygrootte. In wezen worden de elementen aan tegenovergestelde uiteinden van de array verwisseld. Deze methode werkt twee keer zo snel als een methode die een for- lus gebruikt die van 0 naar size gaat. Als resultaat wordt de omgekeerde volgorde van de array bereikt en wordt getoond hoe een array in omgekeerde volgorde moet worden afgedrukt en worden de waarden afgedrukt:

Optie 3: Collecties gebruiken.reverse()

In Java kan de omgekeerde methode, die deel uitmaakt van het bestaande Collections-framework, worden gebruikt om een ​​array om te keren. Laten we het gebruiken om de omkering te doen.

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

In main wordt de array gemaakt en gevuld als een Integer-array met 5 getallen. Het wordt vervolgens afgedrukt als een lijst met behulp van Arrays.asList(array) en vervolgens wordt de functie reverse aangeroepen en wordt array als argument aan deze functie doorgegeven. In reverse wordt Collections.reverse gebruikt, en dit wordt gebruikt op de arraylijst, Arrays.asList(array) , in plaats van op de array zelf. Vervolgens wordt in de volgende stap getoond hoe we een array in omgekeerde volgorde kunnen afdrukken met behulp van System.out.println , en deze keer wordt elk element op dezelfde regel afgedrukt:

Optie 4: keer een array om met List.add() en List.remove()

In deze nieuwe optie worden List.add() en List.remove() gebruikt om de omkering uit te voeren. De manier waarop dit werkt is dat de array wordt geconverteerd naar een lijst en het laatste element van de lijst wordt verwijderd en aan het begin van de lijst wordt geplaatst. Nadat de hele lijst is herhaald, is de nieuwe lijst een omkering van het origineel. In de methode main() wordt een array gemaakt die bestaat uit 5 getallen. Vervolgens wordt de oorspronkelijke status van de array uitgevoerd naar de console. Deze array wordt dan ingevoerd als een argument voor de methode reverse() . Deze methode werkt in feite door het laatste element te verwijderen en aan de voorkant van de array in te voegen. Ten slotte wordt de nieuwe (omgekeerde) status van de array uitgevoerd naar de console. Omgekeerd ()methode, wordt de array naar een lijst geschreven via Arrays.asList(array) , om de methoden add() en remove() in staat te stellen de omkering uit te voeren. Deze methode werkt in feite door het laatste element te verwijderen en aan de voorkant van de array in te voegen. De stappen die reverse() gebruiken zijn als volgt. Het gebruikt een for- lus om de elementen van de lijst om te keren. Het doet dit door een variabele i te initialiseren . Aanvankelijk is de i ingesteld op 0. Wanneer i = 0 , wordt het element op list.size() - 1 in lijst verwijderd, en dit zal altijd het laatste element zijn sinds i < list.size() - 1. Aangezien de methode remove() het verwijderde element retourneert, wordt dit element nu toegevoegd aan de lijst met index i = 0 , dwz aan het begin ingevoegd. De rest van de lijst wordt dan naar rechts verschoven, maar de nieuwe lijst heeft nog steeds hetzelfde aantal elementen, dwz grootte . Voortzetting van de uitvoering van de for- lus met de volgende waarde van i , i = 1 , wordt dezelfde reeks stappen uitgevoerd, zodat het laatste element wordt verwijderd en in getallen wordt gezet op i = 1 en de lijst naar rechts wordt verschoven. Dit gaat door totdat de laatste incrementele waarde van i en alle elementen in de lijst zijn gewijzigd. In de tweede voorloop-element van de lijst met index i is ingesteld op het array-element met index i waarbij i van 0 tot list.size() - 1 is . Samenvattend zijn de gebruikte stappen: Stappen:

1. ik = 0
2. verwijder element op list.size() - 1
3. voeg een element in, dat zich op list.size() - 1 bevond , op i = 0
4. verhoging ik
5. herhaal stap 2 t/m 4 (met nieuwe waarden voor i bij stap 3) totdat de laatste oplopende waarde van i is gebruikt

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

Deze code geeft de uitvoer:

Optie 5: keer een array om met recursie

De recursiemethode wordt veel gebruikt bij het coderen en kan worden gebruikt om een ​​efficiënte methode te creëren voor het omkeren van een array . Bij deze optie wordt de array geconverteerd naar een lijst en vervolgens gaat de code naar de methode reverse() telkens wanneer het laatste element aan het einde van de lijst wordt verwijderd en de lijst heeft de verwijderde waarden toegevoegd in omgekeerde volgorde. Net als bij de vorige methoden wordt er een array gemaakt die uit 5 getallen bestaat. Het wordt vervolgens als argument doorgegeven aan de functie reverse() . In reverse() is het eerste dat wordt gedaan, de array in een lijst veranderen en de lijstgrootte controleren. Als het maar één element heeft of null is, is de methode voltooid en keert terug. Zo niet, dan wordt het eerste element verwijderd, maar gekopieerd naar een geheel getal, waarde . Methode reverse() wordt dan opnieuw aangeroepen en de recursie begint opnieuw. Wanneer de functie wordt ingevoerd, worden dezelfde stappen uitgevoerd, een groottecontrole waarbij, als de lijst groter is dan 1, de volgende stap is om het eerste element te verwijderen en vervolgens de recursie opnieuw uit te voeren. Wanneer de grootte van de lijst 1 is, keert reverse() terug naar de plaats waar deze is aangeroepen en vervolgens wordt aan de lijst elke waarde toegevoegd om deze op te bouwen tot een exacte omgekeerde van de oorspronkelijke lijst.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

De uitvoer is:

Conclusie

Dus hier hebben we gekeken naar 5 verschillende manieren om een ​​array om te keren. Optie 3, die het Collections-framework gebruikt, is waarschijnlijk de beste methode om te gebruiken, aangezien Collections.reverse een reeds bestaande, beproefde Java-functie is. Natuurlijk kunnen de andere opties worden gebruikt, vooral tijdens het leren, maar over het algemeen zijn standaardmethoden, als ze bestaan, de beste, omdat ze meestal sterk geoptimaliseerd en getest zijn. U kunt dergelijke methoden echter zelf maken, aangezien dit een goede codeeroefening is en u zal helpen slagen in uw sollicitatiegesprek voor Java Junior.