Hoe een nieuw element aan een array in Java toe te voegen

Oh, Java-arrays. Ze zijn het voorwerp van intense liefde en haat van honderden beginnende softwareontwikkelaars. Elementen toevoegen aan een reeds geïnitialiseerde array is onmogelijk, zeiden ze... Eigenlijk is het mogelijk, maar niet in de klassieke betekenis... en het is niet erg handig. Het toevoegen van nieuwe elementen aan een reeds geïnitialiseerde array is een soort truc. Deze trucs kunnen echter van pas komen in een interview ... en soms in de baan van een programmeur. Om ervoor te zorgen dat u het gegevenstype met plezier gebruikt en weet hoe u dit efficiënt kunt doen, hebben we een handleiding geschreven over het toevoegen van een nieuw element aan een Java-array. Afgezien van het zorgvuldig doornemen van de theorie en codevoorbeelden, moet u de oefenproblemen in de post bekijken en voltooien.

Wat is een array in Java

Laten we ons herinneren wat een array is en hoe deze in Java kan worden gemaakt. Als je je dat herinnert, ga dan gerust verder naar de volgende subkop "5 manieren om nieuwe elementen aan Java-arrays toe te voegen". Volgens de officiële Java-documentatie van Oracle zijn arrays een reeks waarden die tot hetzelfde gegevenstype behoren. Een set gehele getallen is een perfect voorbeeld van een array in Java . Alle waarden die u definieert, hebben een specifieke positie binnen de array die een index wordt genoemd . Hier zijn de manieren om arrays te declareren en te initialiseren:

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

In het eerste geval hebben we een array myArray gedefinieerd en Java ruimte laten toewijzen voor een array van 10 elementen, in het tweede myArray1 hebben we er onmiddellijk 10 waarden in ingevoerd. In beide gevallen kan element 11 niet zomaar in de array worden geschoven. Om bewerkingen met arrays uit te voeren, manipuleren ontwikkelaars de indices van waarden die een array bevat. Wat moeten we doen? Laten we eens kijken naar de meest gebruikelijke manieren om aan een array toe te voegen.

5 manieren om nieuwe elementen toe te voegen aan Java-arrays

Nou, hier onze trucs om het onveranderlijke veranderlijk te laten lijken.

• Converteer een array naar een lijst
• Maak een nieuwe array met een grotere capaciteit en voeg een nieuw element toe aan de array
• System.arraycopy() implementeren
• Arrays kopiëren met behulp van Apache Commons
• De methode ArrayCopyOf() toepassen

Laten we deze manieren om een ​​element aan een array toe te voegen eens nader bekijken.

1. Een array converteren naar een lijst

Aangezien we een nieuw element niet rechtstreeks aan een array kunnen toevoegen, is het op een na beste wat we kunnen doen om ze naar lijsten te converteren, nieuwe elementen toe te voegen en de waarden weer om te zetten in arrays. De eerste manier om een ​​array naar een lijst te converteren, is door asList() te gebruiken om een ​​nieuwe ArrayList te maken. Zodra het waardenbereik met succes is getransformeerd, gebruikt u ListAdd() om de waarde in te voegen. Zodra u een array niet meer hoeft te bewerken, converteert u deze terug naar het oorspronkelijke gegevenstype met behulp van de methode toArray() . Met alle methoden en conversies kan dit in het begin verwarrend lijken. Laten we eens kijken naar het voorbeeld van het gebruik van asList() om dingen op te helderen.

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

De uitvoer is: Dus in het programma hebben we met succes een array myArray van 7 waarden gemaakt, ingevuld en uitgeprint. Toen besloten we dat tien waarden niet genoeg voor ons waren. Welnu, we hebben myArray geconverteerd naar een ArrayList arrList met behulp van de methode Arrays.asList . Hier is 28, het element dat moet worden toegevoegd. We hebben het toegevoegd aan de ArrayList arrList , en het vervolgens weer geconverteerd naar een array met behulp van de toArray() methode en de nieuwe array afgedrukt.

2. Creëer een nieuwe array met een grotere capaciteit

Een van de meest gebruikelijke manieren om meer elementen aan een array toe te voegen, is door een nieuwe, grotere array vanaf nul te maken, de elementen van de oude te plaatsen en nieuwe elementen toe te voegen. Hier is een stapsgewijze uitleg van het proces:

• Maak een nieuwe array met de capaciteit a+n (a — de oorspronkelijke arraycapaciteit, n — het aantal elementen dat u wilt toevoegen).
• Voeg alle elementen van het vorige gegevensbereik toe aan het nieuwe, evenals de nieuwe waarden.
• Druk de resulterende matrix af.

Probeer zelf zo'n array te maken en vergelijk uw code met die in het onderstaande voorbeeld:

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

De uitvoer is: Welnu, deze manier om een ​​nieuw element aan een array toe te voegen, is de gemakkelijkste.

3. System.arrayCopy() toepassen

System.arrayCopy() is een veelgebruikte methode voor het toewijzen van een grotere array aan de bestemming van een bronarray. Een ontwikkelaar kan tussen de haakjes van de methode de reeks specificeren die hij naar een nieuwe array wil kopiëren. Om te zien hoe de methode werkt en om het zelf te proberen, bekijk en probeer het onderstaande voorbeeld uit:

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

De uitvoer is: Hier hebben we een array myArray gemaakt , uitgeprint en een nieuw element toegevoegd met behulp van onze addElement- methode, die is gebouwd op System.arrayCopy() .

4. Apache Commons gebruiken om arrays te kopiëren

Laten we een niet-standaard manier gebruiken. Namelijk een bibliotheek van derden Apache Commons lang. Het maakt deel uit van het Apache Commons-project dat zich richt op alle aspecten van herbruikbare Java-componenten. Kennis over het project is niet overbodig. De Apache Commons lang heeft een methode add() die speciaal is ontworpen om het uitbreiden van arrays mogelijk te maken, het bespaart programmeurs veel tijd en moeite. Het is de moeite waard om in gedachten te houden dat deze Apache Commons- methode add() is gebaseerd op het aanroepen van de methode System.arraycopy() voor het geval u een lastige examen- of interviewvraag moet beantwoorden. Om de bibliotheken aan uw project toe te voegen, gaat u naar de Apache Commons- website en downloadt u de bibliotheken. Ga dan naar Bestand → Projectstructuur → Bibliotheken > + en selecteer de gedownloade jar-bestanden.

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

De uitvoer is:

5. ArrayCopyOf() implementeren

ArrayCopyOf() is nog een methode om een ​​nieuw element aan een array toe te voegen. Zoals Apache Commons lang add() roept het intern System.arraycopy() aan om deze bewerking uit te voeren. De meeste ontwikkelaars geven echter de voorkeur aan ArrayCopyOf() omdat het hen in staat stelt de code beknopt en leesbaar te houden. Hier is een voorbeeld van het gebruik van ArrayCopyOf() om nieuwe elementen aan een array toe te voegen:

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

De uitvoer is:

Conclusie

Weten hoe ze elementen aan een array moeten toevoegen, helpt ontwikkelaars de oude code snel bij te werken zonder de functionaliteit en leesbaarheid op te offeren... Of gewoon om het interview te halen. Aangezien er verschillende manieren zijn om elementen aan Java-arrays toe te voegen, kunt u gerust de methode kiezen waarmee u vertrouwd bent.