Sådan tilføjes et nyt element til et array i Java

Åh, Java-arrays. De er genstand for intens kærlighed og had hos hundredvis af nybegyndere softwareudviklere. Det er umuligt at tilføje elementer til et array, der allerede var initialiseret, sagde de... Faktisk er det muligt, men ikke i en klassisk betydning... og det er ikke særlig praktisk. Tilføjelse af nye elementer til et array, der allerede var initialiseret, er et slags trick. Disse tricks kan dog være nyttige i et interview ... og nogle gange i et programmørjob. For at sikre, at du nyder at bruge datatypen og ved, hvordan du gør det effektivt, skrev vi en guide til at tilføje et nyt element til et Java-array. Bortset fra omhyggeligt at gennemgå teori- og kodeeksemplerne, skal du sørge for at tjekke ud og fuldføre de praksisproblemer, der er omtalt i indlægget.

Hvad er et array i Java

Lad os huske, hvad et array er, og hvordan man opretter det i Java. Hvis du husker det, er du velkommen til at springe videre til næste underoverskrift "5 måder at tilføje nye elementer til Java-arrays". Oracles officielle Java-dokumentation siger, at arrays er en række værdier, der tilhører den samme datatype. Et sæt heltal er et perfekt eksempel på en matrix i Java . Alle værdier, du definerer, har en specifik position i arrayet kaldet et indeks . Her er måderne at erklære og initialisere arrays på:

int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}

I det første tilfælde definerede vi et array myArray og fik Java til at allokere plads til et array med 10 elementer, i det andet myArray1 indtastede vi straks 10 værdier i det. I begge tilfælde kan element 11 ikke blot skubbes ind i arrayet. For at udføre operationer med arrays manipulerer udviklere indekserne for værdier, som et array indeholder. Hvad skal vi gøre? Lad os tage et kig på de mest almindelige måder at tilføje til array.

5 måder at tilføje nye elementer til Java-arrays

Nå, her er vores tricks til at få det uforanderlige til at virke foranderligt.

• Konverter et array til en liste
• Opret et nyt array med større kapacitet og tilføj et nyt element til arrayet
• Implementering af System.arraycopy()
• Kopiering af arrays ved hjælp af Apache Commons
• Anvendelse af ArrayCopyOf() metoden

Lad os se nærmere på disse måder at tilføje et element til en matrix.

1. Konvertering af et array til en liste

Da vi ikke kan tilføje et nyt element til et array direkte, er den næstbedste ting at gøre at konvertere dem til lister, tilføje nye elementer og konvertere værdierne tilbage til arrays. Den første måde at konvertere et array til en liste er at bruge asList() til at oprette en ny ArrayList. Når rækken af ​​værdier er transformeret, skal du bruge ListAdd() til at indsætte værdien. Når du ikke længere behøver at redigere et array, skal du konvertere tilbage til den oprindelige datatype ved hjælp af toArray()- metoden. Med alle metoder og konverteringer kan dette virke forvirrende i starten. Lad os tage et kig på eksemplet med at bruge asList() til at rydde op i tingene.

// Code for adding Java arrays to a program
import java.lang.*;
import java.util.*;

class ArrayDemo{
   //Let’s add a new element to an array
   public static Integer[] addX(Integer myArray[], int x) {
       int i;
       //turn array into ArrayList using asList() method
       List arrList = new ArrayList( Arrays.asList(myArray));

       // adding a new element to the array
       arrList.add(x);

       // Transforming the ArrayList into an array
       myArray = arrList.toArray(myArray);
       return myArray;
   }
   public static void main(String[] args) {
       int i;
       //initial array
       Integer myArray[] = { 0, 1, 2, 45, 7, 5, 17};

       //print the initial array out
       System.out.println("Initial Array: "
                          + Arrays.toString(myArray));

       //element to be added
       int x = 28;

       // call the method to add x in myArray
       myArray = addX(myArray, x);

       // print the updated array out
       System.out.println("Array with " + x + " added: "
                          + Arrays.toString(myArray));
   }
}

Udgangen er: Så i programmet har vi med succes oprettet et array myArray med 7 værdier, udfyldt det og udskrevet det. Så besluttede vi, at ti værdier ikke var nok for os. Nå, vi konverterede myArray til en ArrayList arrList ved hjælp af Arrays.asList metoden. Her er 28, elementet, der skal tilføjes. Vi føjede det til ArrayList arrList og konverterede det tilbage til et array ved hjælp af toArray()- metoden og udskrev det nye array.

2. Opret et nyt array med en større kapacitet

En af de mest almindelige måder at tilføje flere elementer til en matrix er ved at skabe en ny, større matrix fra bunden, sætte elementerne fra de gamle og tilføje nye elementer. Her er en trin-for-trin gennemgang af processen:

• Opret et nyt array med kapaciteten a+n (a — den oprindelige arraykapacitet, n — antallet af elementer, du vil tilføje).
• Tilføj alle elementerne fra det tidligere dataområde til det nye, såvel som de nye værdier.
• Udskriv det resulterende array.

Prøv at oprette sådan et array på egen hånd, og sammenlign din kode med den i eksemplet nedenfor:

// Java Program to add an element in an Array

import java.lang.*;
import java.util.*;

class ArrayDemo {
   //Method to add an element x into array myArray
   public static int[] addX(int myArray[], int x) {
       int i;

       // create a new array of a bigger size (+ one element)
       int newArray[] = new int[myArray.length + 1];

       // insert the elements from the old array into the new one
       for (i = 0; i < myArray.length; i++)
           newArray[i] = myArray[i];

       newArray[myArray.length] = x;
       return newArray;
   }

   public static void main(String[] args) {
       int i;

       // initial array of size 10
       int arr[]
               = {0, 1, 2, 45, 7, 5, 17};

       // print the initial array
       System.out.println("Initial Array: " + Arrays.toString(arr));

       // element to be added
       int x = 28;

       // call the addX method to add x in arr
       arr = addX(arr, x);
       // print the updated array
       System.out.println("Array with " + x + " added:" + Arrays.toString(arr));
   }
}

Udgangen er: Nå, denne måde at tilføje et nyt element i et array er den nemmeste.

3. Anvendelse af System.arrayCopy()

System.arrayCopy() er en meget brugt metode til at allokere et større array til destinationen for et kildearray. En udvikler kan angive den sekvens, han ønsker at kopiere til et nyt array i parentes af metoden. For at se, hvordan metoden fungerer, og prøv at bruge den selv, skal du tage et kig på og prøve at køre eksemplet nedenfor:

import java.util.Arrays;

class ArrayDemo {
   private static Integer[] addElement(Integer[] myArray, int newElement) {
       //we create a new Object here, an array of bigger capacity
       Integer[] array = new Integer[myArray.length + 1];
       System.arraycopy(myArray, 0, array, 0, myArray.length);
       array[myArray.length] = newElement;
       return array;
   }

   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}

Udgangen er: Her har vi lavet et array myArray , printet det ud og tilføjet et nyt element ved hjælp af vores addElement metode, som er bygget på System.arrayCopy() .

4. Brug af Apache Commons til at kopiere arrays

Lad os bruge en ikke-standard måde. Nemlig et tredjeparts bibliotek Apache Commons lang. Det er en del af Apache Commons-projektet fokuseret på alle aspekter af genanvendelige Java-komponenter. Viden om projektet vil ikke være overflødig. Apache Commons lang har en metode add() designet specifikt til at tillade udvidelse af arrays, det sparer koderne for en masse tid og kræfter. Det er værd at huske på, at denne Apache Commons add() -metode er baseret på at kalde System.arraycopy()- metoden, hvis du skal besvare en vanskelig eksamen eller et interviewspørgsmål. For at tilføje bibliotekerne til dit projekt skal du gå til Apache Commons- webstedet og downloade bibliotekerne. Gå derefter til Filer → Projektstruktur → Biblioteker > + og vælg de downloadede jar-filer.

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;

class ArrayDemo {
   private static <T> T[] append(T[] arr, T element) {
       return ArrayUtils.add(arr, element);
   }

   public static void main(String[] args) {
       Integer[] myArray = { 0, 1, 2, 3, 4};
       System.out.println("myArray: " + Arrays.toString(myArray));

       myArray = append(myArray, 5);
       System.out.println("new Array with the number added: " + Arrays.toString(myArray));
   }
}

Udgangen er:

5. Implementering af ArrayCopyOf()

ArrayCopyOf() er endnu en metode til at tilføje et nyt element til et array. Såsom Apache Commons lang add() kalder den internt System.arraycopy() for at udføre denne operation. De fleste udviklere foretrækker dog ArrayCopyOf() , da det giver dem mulighed for at holde koden kortfattet og læsbar. Her er et eksempel på brug af ArrayCopyOf() til at tilføje nye elementer til en matrix:

import java.util.Arrays;
class ArrayDemo {
   private static <X> X[] addElement(X[] myArray, X element) {
       X[] array = Arrays.copyOf(myArray, myArray.length + 1);
       array[myArray.length] = element;
       return array;
   }
   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}

Udgangen er:

Konklusion

At vide, hvordan man tilføjer elementer til et array, hjælper udviklere med at opdatere den gamle kode hurtigt uden at ofre dens funktionalitet og læsbarhed... Eller bare for at bestå interviewet. Da der er forskellige måder at tilføje elementer til Java-arrays, er du velkommen til at vælge den metode, du er komfortabel med.