Új elem hozzáadása Java tömbhöz

Ó, Java tömbök. Kezdő szoftverfejlesztők százainak heves szeretetének és gyűlöletének tárgya. Elemeket hozzáadni egy már inicializált tömbhöz lehetetlen, mondták… Valójában lehetséges, de nem klasszikus értelemben… és nem túl kényelmes. Új elemek hozzáadása egy már inicializált tömbhöz egyfajta trükk. Ezek a trükkök azonban jól jöhetnek egy interjún... és néha egy programozói munkában is. Annak érdekében, hogy élvezze az adattípus használatát, és tudja, hogyan kell azt hatékonyan csinálni, írtunk egy útmutatót egy új elem Java tömbhöz való hozzáadásához. Az elmélet és a kódminták gondos áttekintése mellett mindenképpen nézze meg és fejezze be a bejegyzésben szereplő gyakorlati problémákat.

Mi az a tömb a Java nyelven

Emlékezzünk vissza, mi az a tömb, és hogyan hozhatjuk létre Java-ban. Ha emlékszik erre, nyugodtan ugorjon a következő alcímre: „5 módszer új elemek hozzáadására a Java tömbökhöz”. Az Oracle hivatalos Java-dokumentációja szerint a tömbök azonos adattípushoz tartozó értékek sorozata. Az egész számok halmaza tökéletes példa egy Java tömbre . Minden megadott értéknek van egy adott pozíciója a tömbben, amelyet indexnek nevezünk . Íme a tömbök deklarálásának és inicializálásának módjai:

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

Az első esetben definiáltunk egy myArray tömböt , és Java-t készítettünk, hogy helyet foglaljon egy 10 elemből álló tömb számára, a második myArray1- ben pedig azonnal 10 értéket adtunk meg. A 11-es elemet egyik esetben sem lehet egyszerűen a tömbbe tolni. A tömbökkel végzett műveletek végrehajtásához a fejlesztők manipulálják a tömbben lévő értékek indexeit. Mit tehetünk? Vessünk egy pillantást a tömbhöz való hozzáadás leggyakoribb módjaira.

5 módszer új elemek hozzáadására a Java tömbökhöz

Nos, itt a mi trükkjeink, amelyekkel a megváltoztathatatlant megváltoztathatónak tegyük.

• Tömb átalakítása listává
• Hozzon létre egy nagyobb kapacitású új tömböt, és adjon hozzá egy új elemet a tömbhöz
• A System.arraycopy() megvalósítása
• Tömbök másolása Apache Commons segítségével
• Az ArrayCopyOf() metódus alkalmazása

Nézzük meg közelebbről az elemek tömbhöz való hozzáadásának módjait.

1. Tömb átalakítása listává

Mivel nem tudunk közvetlenül új elemet hozzáadni egy tömbhöz, a következő legjobb megoldás az, ha listákká alakítjuk, új elemeket adunk hozzá, és az értékeket visszakonvertáljuk tömbökké. A tömb listává alakításának első módja az asList() használatával egy új ArrayList létrehozása. Az értéktartomány sikeres átalakítása után a ListAdd() segítségével szúrja be az értéket. Ha már nincs szüksége egy tömb szerkesztésére, a toArray() metódus segítségével konvertálja vissza az eredeti adattípusra . Az összes módszer és átalakítás mellett ez elsőre zavarónak tűnhet. Vessünk egy pillantást az asList() használatára a dolgok tisztázására.

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

A kimenet a következő: Így a programban sikeresen létrehoztunk egy myArray 7 értékből álló tömböt, kitöltöttük és kinyomtattuk. Aztán úgy döntöttünk, hogy tíz érték nekünk nem elég. Nos, a myArray-t ArrayList arrListté alakítottuk az Arrays.asList metódussal. Itt van a 28, a hozzáadandó elem. Hozzáadtuk az ArrayList arrList listához, majd a toArray() metódussal visszaalakítottuk tömbbé, és kinyomtattuk az új tömböt.

2. Hozzon létre egy új, nagyobb kapacitású tömböt

Az egyik leggyakoribb módja annak, hogy több elemet adjunk egy tömbhöz, ha a semmiből hozunk létre egy új, nagyobb tömböt, a régiek elemeit helyezzük el, és új elemeket adunk hozzá. Íme a folyamat lépésről lépésre történő áttekintése:

• Hozzon létre egy új tömböt a+n kapacitással (a – az eredeti tömb kapacitása, n – a hozzáadni kívánt elemek száma).
• Adja hozzá az előző adattartomány összes elemét az újhoz, valamint az új értékeket.
• Nyomtassa ki a kapott tömböt.

Próbáljon meg egyedül létrehozni egy ilyen tömböt, és hasonlítsa össze kódját az alábbi példában szereplővel:

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

A kimenet a következő: Nos, ez a legegyszerűbb módja annak, hogy új elemet adjunk egy tömbhöz.

3. A System.arrayCopy() alkalmazása

A System.arrayCopy() egy széles körben használt módszer egy nagyobb tömb kiosztására a forrástömb rendeltetési helyén. A fejlesztő a metódus zárójelében megadhatja azt a sorozatot, amelyet egy új tömbbe szeretne másolni. Ha látni szeretné, hogyan működik a módszer, és megpróbálhatja saját maga is használni, vessen egy pillantást az alábbi példára, és próbálja meg futtatni:

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

A kimenet a következő: Itt létrehoztunk egy myArray tömböt , kinyomtattuk és hozzáadtunk egy új elemet az addElement metódusunkkal, amely a System.arrayCopy() -ra épül .

4. Apache Commons használata tömbök másolásához

Használjunk nem szabványos módszert. Mégpedig egy harmadik féltől származó Apache Commons lang. Ez az Apache Commons projekt része, amely az újrafelhasználható Java komponensek minden aspektusára összpontosít. A projekt ismerete nem lesz felesleges. Az Apache Commons nyelvnek van egy add() metódusa , amelyet kifejezetten a tömbök bővítésére terveztek, így sok időt és erőfeszítést takarít meg a kódolóknak. Érdemes szem előtt tartani, hogy ez az Apache Commons add() metódusa a System.arraycopy() metódus meghívására épül arra az esetre, ha egy trükkös vizsga- vagy interjúkérdésre kell válaszolnia. A könyvtárak projekthez való hozzáadásához nyissa meg az Apache Commons webhelyet, és töltse le a könyvtárakat. Ezután lépjen a Fájl → Projektstruktúra → Könyvtárak > + menüpontra, és válassza ki a letöltött jar fájlokat.

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

A kimenet a következő:

5. Az ArrayCopyOf() megvalósítása

Az ArrayCopyOf() egy további módszer új elem hozzáadására egy tömbhöz. Mint például az Apache Commons lang add(), belsőleg a System.arraycopy() függvényt hívja meg ehhez a művelethez. A legtöbb fejlesztő azonban az ArrayCopyOf()-ot részesíti előnyben , mivel lehetővé teszi számukra, hogy a kódot tömören és olvashatóan tartsák. Íme egy példa az ArrayCopyOf() használatával új elemek hozzáadására egy tömbhöz:

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

A kimenet a következő:

Következtetés

Az elemek hozzáadásának ismerete egy tömbhöz segít a fejlesztőknek gyorsan frissíteni a régi kódot anélkül, hogy feláldoznák annak funkcionalitását és olvashatóságát… Vagy csak azért, hogy átmenjenek az interjún. Mivel különböző módokon adhat hozzá elemeket a Java tömbökhöz, nyugodtan válassza ki a megfelelő módszert.