Vend et array i Java forklaret med eksempler
Når programmører behandler arrays, der starter med det sidste element, er det altid mere effektivt at vende arrayet om, så det første element placeres på arrayets sidste position. Derefter er det andet element på arrayets næstsidste position, indtil det sidste element er ved det første indeks.
En af Javas afgørende operationer er at vende et array. Det er en almindelig array-baseret kodningsudfordring, som programmører ofte stiller under de første par interviewrunder for at afgøre, om de kan kode eller ej. Du kan løse dette problem på flere måder, og vi vil se på de mest hyppige i Java. Fordi den ikke er fokuseret på datatyper, fungerer denne tilgang med enhver form for array, inklusive streng- og heltalsarrays og objektarrays.
Den første tilgang til at vende et array er at gøre det på en brute force måde uden at kræve yderligere datastrukturer eller biblioteksmetoder. Ja, du kan også vende arrayet ved at udvikle din funktion, der går gennem arrayet og bytter elementer, indtil arrayet er sorteret. Det er den bedste måde at nærme sig kodningsinterviews på.
Vend et array i Java
I Java er der flere måder at vende et array på. Disse er følgende:
- Brug af metoden Collections.reverse()
- Vend et array ved hjælp af en For Loop
- Brug af metoden StringBuilder.append()
- In-place array reversering
- Brug af bytte
- Brug af ArrayUtils.reverse()
Udskrivning af et array i baglæns rækkefølge
Hvis vi ønsker at udskrive arrayet i omvendt rækkefølge uden at vende det, kan vi gøre det ved at bruge en for-løkke, der begynder at skrive fra slutningen af arrayet. Det er en glimrende løsning, hvis vi kun ønsker at udskrive arrayet i omvendt rækkefølge uden behandling.
Arrayet udskrives i omvendt rækkefølge i følgende software.
import java.util.*;
import java.util.stream.*;
public class Codeunderscored
{
public static void main(String[] args) {
Integer[] intVars = {10,20,30,40,50,60,70,80,90};
// start from the first element when printing the array
System.out.println("The initial Array:");
for(int i=0;i<intVars .length;i++)
System.out.print(intVars[i] + " ");
System.out.println();
//start from the last element when printing the array
System.out.println("The initial Array in a reversed order:");
for(int i=intVars .length-1;i>=0;i--)
System.out.print(intVars[i] + " ");
}
} Det er et levedygtigt alternativ til simpelthen at udskrive arrayet. Java har flere metoder til at vende indekserne for elementer i en matrix. De mange måder, vi vil gå i dybden med i denne vejledning, er givet nedenfor.
- Brug af ArrayList omvendt metode
- Looping med den sædvanlige metode
- Brug af tilbageførsel på stedet
Ved brug af Collections.reverse()-metoden:ArrayList bruges til at vende en matrix
Den 'omvendte' metode i samlingsrammerne bruges til at vende et array i Java.
Men fordi den 'omvendte' metode accepterer en liste som et argument, skal du først konvertere en matrix til en liste. Den 'omvendte' teknik bruges i følgende applikation til at vende et array.
import java.util.*;
public class Codeunderscored {
/*function reverses the elements of the array*/
static void reverse(Integer numArray[])
{
Collections.reverse(Arrays.asList(numArray));
System.out.println("The resultant Reversed Array is:" + Arrays.asList(numArray));
}
public static void main(String[] args)
{
Integer [] numArray = {11,13,15,17,19};
System.out.println("The resultant original Array:" + Arrays.asList(numArray));
reverse(numArray);
}
} Vi bruger den omvendte funktion i dette program på et array til at konvertere det til en liste. Yderligere kan vi vende en strengmatrix på lignende måde, som illustreret i det følgende eksempel.
import java.util.*;
public class Codeunderscored {
/*function reverses the elements of the array*/
static void reverse(String arrVar[])
{
Collections.reverse(Arrays.asList(myArray));
System.out.println("The resultant reversed Array:" + Arrays.asList(arrVar));
}
public static void main(String[] args)
{
String [] arrVar = {"apple", "mangoes", "banana", "lemon", "quava", "peas","passion"};
System.out.println("The resultant original Array:" + Arrays.asList(arrVar));
reverse(arrVar);
}
} Ovenstående software opretter en streng-array. Vi vender arrayet om ved at ændre det til en liste og aktivere den omvendte funktion på det.
Sådan vender du et array ved hjælp af en For Loop
En anden metode til at vende et array på er at oprette et nyt array og vende elementerne i det tidligere array. Tag et kig på følgende eksempel.
public class Codeunderscored {
static void ReverseArray(char charArray[], int n)
{
char[] finalArray = new char[n];
int j = n;
for (int i = 0; i < n; i++) {
finalArray[j - 1] = charArray[i];
j = j - 1;
}
System.out.println("The resultant Reversed array: ");
for (int k = 0; k < n; k++) {
System.out.print(finalArray[k] + " ");
}
}
public static void main(String[] args)
{
char [] char_array = {'C','O','D','I','N','G'};
System.out.println(" The initial array is : ");
for (int k = 0; k <charArray .length; k++) {
System.out.print(charArray[k] + " ");
}
System.out.println();
ReverseArray(charArray, charArray.length);
}
} Som et eksempel har vi brugt en karakterarray. Vi vender array-elementerne én efter én ved hjælp af den omvendte funktion og viser derefter den omvendte array.
Anvendelse af StringBuilder.append()-metoden
Hvis du arbejder med en String-array, kan du bruge en StringBuilder til at vedhæfte hvert array-element med en for-løkke, der dekrementerer fra arrayets længde, konvertere StringBuilder til en streng og opdele den tilbage i et array som en fjerde metode.
// Program for array reversal using the StringBuilder
import java.util.Arrays;
class Codeunderscored {
public static void main (String[] args) {
String[] arr = {"Code", "Underscored"};
StringBuilder reverseArray = new StringBuilder();
for (int i = arr.length; i > 0; i--) {
reverseArray.append(arr[i - 1]).append(" ");
};
String[] finalArray = reverseArray.toString().split(" ");
System.out.println(Arrays.toString(finalArray));
}
} In-place array reversering
At vende elementerne i et array på plads uden at bruge et separat array er den tredje måde at vende array på. Arrayets initiale komponent er byttet med det sidste element i arrayet i denne funktion. På samme måde udveksles arrayets andet element med arrayets næstsidste element og så videre. Vi får hele arrayet omvendt i slutningen af array-gennemgangen. In-place array reversering demonstreres i følgende program.
import java.util.Arrays;
public class Codeunderscored {
/*Swap the first element of the array with the last element, the second element with the second-to-last element, etc.
*/
static void reverseArray(arrVar[], int size)
{
int i, k, temp;
for (i = 0; i < size / 2; i++) {
temp = arrVar[i];
arrVar[i] = arrVar[size - i - 1];
arrVar[size - i - 1] = temp;
}
/*printing the resulting reversed array*/
System.out.println("The resultant reversed Array is: \n" + Arrays.toString(arrVar));
}
public static void main(String[] args)
{
int [] numArray = {21,32,43,54,55,76,87,98,109};
//original array printing
System.out.println("Original Array: \n" + Arrays.toString(numArray));
//function for calling the reverse array
reverseArray(numArray, numArray.length);
}
} Softwaren genererer et omvendt array ved at bytte elementerne i det originale array uden at bruge det andet array, som det ses i outputtet. Denne metode er mere effektiv, fordi den bruger mindre hukommelse.
Sæt bytte i arbejde
Arrayet indlæses og udskrives i den anden procedure ved hjælp af en lignende teknik. Men i modsætning til den tidligere måde bygger vi ikke et nyt array. I stedet inverterer vi arrayets oprindelige rækkefølge.
Arrayets elementer ombyttes i denne procedure. Det første og det sidste element skiftes rundt. Det andet element erstatter det sidste element, og så videre. Tag for eksempel arrayet [1, 2, 3,…., n-2, n-1, n]. Vi ændrer 1 til n, 2 til n-1, 3 til n-2 og så videre.
// Program for reversing the array in a fewer number of swaps
public class arrayReverse {
// function swaps the array's first element with last
// element, second element with last second element and
// so on
static void reverse(int numArray[], int n)
{
int j, w, x;
for (j = 0; j < n / 2; j++) {
x = numArray[j];
numArray[j] = numArray[n - j - 1];
numArray[n - j - 1] = x;
}
// printing the reversed array
System.out.println(" The resultant reversed array is: \n");
for (w = 0; w < n; w++) {
System.out.println(numArray[w]);
}
}
public static void main(String[] args)
{
int[] arrVars = { 50, 70, 80, 90, 100 };
reverse(arrVars, arrVars.length);
}
} Brug af ArrayUtils.reverse()
Apache Commons er et open source-bibliotek, der indeholder mange hjælpebiblioteker, der kræves til udvikling af Java-software. Dette bibliotek bør inkluderes som standard i Java-projekter for at komplementere JDK. Apache commons-lang giver en ArrayUtils-klasse med overbelastede reverse()-metoder til at vende int-, float- eller objektarrays i Java. Denne metode vender også det givne array på plads i stedet for at returnere en ny.
import java.util.Arrays;
import org.apache.commons.lang3.ArrayUtils;
/**
* Program for reversing an array in Java using Apache Commons Lang ArrayUtils
* class.
*
*/
public class Pattern {
public static void main(String args[]) {
String[] compVars = {"HP", "DELL", "IBM", "Lenovo"};
System.out.println(" Original Array before reversal: "
+ Arrays.toString(compVars));
ArrayUtils.reverse(compVars);
System.out.println("Resultant Array after reversal: "
+ Arrays.toString(compVars));
}
} Som du kan se, har vi med succes vendt arrayet med kun én linje. Du skal inkludere commons-lang3-3.4.jar i din applikations klassesti for at bruge ArrayUtils-klassen fra Apache commons-lang. Du kan bruge Maven i stedet ved at have følgende afhængighed i din pom.xml-fil.
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.4</version>
</dependency> Eksempel 1:Program til array-vending ved hjælp af Java-samlinger
import java.util.*;
public class reversingArray {
// function responsible for reversing the elements of the array
static void reverse(Integer numArr[])
{
Collections.reverse(Arrays.asList(numArr));
System.out.println(Arrays.asList(numArr));
}
public static void main(String[] args)
{
Integer [] numArr = {60, 70, 80, 90, 100};
reverse(numArr);
}
}
Eksempel 2 :Program, der vender et array
public class reverseArray {
// function responsible for reversing an array and storing it in another array
static void reverse(int arrVar[], int n)
{
int[] bArr = new int[n];
int j = n;
for (int i = 0; i < n; i++) {
bArr[j - 1] = arrVar[i];
j = j - 1;
}
// reversed array printing
System.out.println("The resultant reversed array is: \n");
for (int x = 0; x < n; x++) {
System.out.println(bArr[x]);
}
}
public static void main(String[] args)
{
int [] arr = {10, 20, 30, 40, 50};
reverse(arr, arr.length);
}
} Konklusion
Arrays er en almindelig kodningsteknik til lagring af flere værdier af samme art i en enkelt variabel. Der er forskellige grunde til, at en programmør måske ønsker at vende et array. Når logikken i et problem kræver, at man starter fra den sidste post, kan det være nødvendigt at vende et array om.
Denne artikel så på, hvordan man kan vende et array i Java ved hjælp af flere teknikker. Selvom vi brugte heltalsdata til demonstrationsformål, bruges de samme metoder til at vende arrayet med alle andre data, uanset om det er primitive eller ikke-primitive.
For specifikke rutiner i Java kan de mest primitive typer af arrays - int, long, string og double - vendes om. ArrayUtils er en klasse i Apache commons-lang, et open source-bibliotek, der vedligeholdes af Apache Software Foundation. Leger med objektet og grundlæggende arrays i Java, denne spændende klasse bruges sammen med klassen java.util.Arrays. API'et inkluderer overbelastede metoder til at vende mange typer Java-arrays, herunder int-, long-, double-, float- og object-arrays.
