Hur man lägger till ett nytt element till en array i Java

Åh, Java-arrayer. De är föremål för intensiv kärlek och hat från hundratals nybörjare mjukvaruutvecklare. Det är omöjligt att lägga till element till en array som redan initierats, sa de... Det är faktiskt möjligt, men inte i klassisk mening... och det är inte särskilt bekvämt. Att lägga till nya element till en array som redan initierats är ett slags trick. Dessa knep kan dock komma väl till pass i en intervju ... och ibland i en programmerares jobb. För att se till att du tycker om att använda datatypen och vet hur du gör det effektivt, skrev vi en guide om att lägga till ett nytt element i en Java-array. Förutom att noggrant gå igenom teorin och kodexemplen, se till att kolla in och slutföra övningsproblemen som presenteras i inlägget.

Vad är en Array i Java

Låt oss komma ihåg vad en Array är och hur man skapar den i Java. Om du kommer ihåg det, hoppa gärna vidare till nästa underrubrik "5 sätt att lägga till nya element till Java-arrayer". Oracles officiella Java-dokumentation säger att arrayer är en serie värden som tillhör samma datatyp. En uppsättning heltal är ett perfekt exempel på en array i Java . Alla värden du definierar har en specifik position inom arrayen som kallas ett index . Här är sätten att deklarera och initiera arrayer:

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

I det första fallet definierade vi en array myArray och fick Java att allokera utrymme för en array med 10 element, i det andra myArray1 matade vi omedelbart in 10 värden i den. I båda fallen kan elementet 11 inte enkelt skjutas in i gruppen. För att utföra operationer med arrayer, manipulerar utvecklare indexen för värden som en array innehåller. Vad ska vi göra? Låt oss ta en titt på de vanligaste sätten att lägga till i array.

5 sätt att lägga till nya element till Java-arrayer

Tja, här är våra knep för att få det oföränderliga att verka föränderligt.

• Konvertera en matris till en lista
• Skapa en ny array med större kapacitet och lägg till ett nytt element i arrayen
• Implementering av System.arraycopy()
• Kopiera arrayer med Apache Commons
• Använda ArrayCopyOf() -metoden

Låt oss ta en närmare titt på dessa sätt att lägga till ett element i en array.

1. Konvertera en array till en lista

Eftersom vi inte kan lägga till ett nytt element till en array direkt, är det näst bästa att göra att konvertera dem till listor, lägga till nya element och konvertera tillbaka värdena till arrayer. Det första sättet att konvertera en array till en lista är att använda asList() för att skapa en ny ArrayList. När värdeintervallet har transformerats, använd ListAdd() för att infoga värdet. När du inte längre behöver redigera en array, konvertera tillbaka till den ursprungliga datatypen med hjälp av toArray() -metoden. Med alla metoder och omvandlingar kan detta verka förvirrande till en början. Låt oss ta en titt på exemplet med att använda asList() för att rensa upp saker.

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

Utgången är: Så i programmet har vi framgångsrikt skapat en array myArray med 7 värden, fyllt i den och skrivit ut den. Då bestämde vi oss för att tio värden inte räckte för oss. Tja, vi konverterade myArray till en ArrayList arrList med metoden Arrays.asList . Här är 28, elementet som ska läggas till. Vi lade till den i ArrayList arrList och konverterade den tillbaka till en array med metoden toArray() och skrev ut den nya arrayen.

2. Skapa en ny array med större kapacitet

Ett av de vanligaste sätten att lägga till fler element i en array är genom att skapa en ny, större array från grunden, sätta in elementen från de gamla och lägga till nya element. Här är en steg-för-steg-genomgång av processen:

• Skapa en ny array med kapaciteten a+n (a — den ursprungliga arraykapaciteten, n — antalet element du vill lägga till).
• Lägg till alla element från det tidigare dataintervallet till det nya, såväl som de nya värdena.
• Skriv ut den resulterande arrayen.

Försök att skapa en sådan array på egen hand och jämför din kod med den i exemplet nedan:

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

Utgången är: Tja, det här sättet att lägga till ett nytt element i en array är det enklaste.

3. Använd System.arrayCopy()

System.arrayCopy() är en mycket använd metod för att allokera en större array till destinationen för en källmatris. En utvecklare kan specificera sekvensen han vill kopiera till en ny array inom parenteser av metoden. För att se hur metoden fungerar och prova att använda den själv, ta en titt på och prova att köra exemplet nedan:

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

Utgången är: Här har vi skapat en array myArray , skrivit ut den och lagt till ett nytt element med vår addElement- metod, som är byggd på System.arrayCopy() .

4. Använda Apache Commons för att kopiera arrayer

Låt oss använda ett icke-standardiserat sätt. Nämligen ett tredjepartsbibliotek Apache Commons lang. Det är en del av Apache Commons-projektet fokuserat på alla aspekter av återanvändbara Java-komponenter. Kunskap om projektet kommer inte att vara överflödigt. Apache Commons lang har en metod add() designad speciellt för att tillåta expanderande arrayer, det sparar kodare mycket tid och ansträngning. Det är värt att komma ihåg att denna Apache Commons add() -metod är baserad på att anropa System.arraycopy()- metoden ifall du måste svara på en knepig tentamen eller intervjufråga. För att lägga till biblioteken i ditt projekt, gå till Apache Commons webbplats och ladda ner biblioteken. Gå sedan till Arkiv → Projektstruktur → Bibliotek > + och välj de nedladdade jar-filerna.

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

Utgången är:

5. Implementering av ArrayCopyOf()

ArrayCopyOf() är ytterligare en metod för att lägga till ett nytt element i en array. Såsom Apache Commons lang add() anropar den internt System.arraycopy() för att utföra denna operation. Men de flesta utvecklare föredrar ArrayCopyOf() eftersom det tillåter dem att hålla koden kortfattad och läsbar. Här är ett exempel på hur du använder ArrayCopyOf() för att lägga till nya element i en array:

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

Utgången är:

Slutsats

Att veta hur man lägger till element i en array hjälper utvecklare att uppdatera den gamla koden snabbt utan att offra dess funktionalitet och läsbarhet... Eller bara för att klara intervjun. Eftersom det finns olika sätt att lägga till element i Java-arrayer, välj gärna den metod du är bekväm med.