A tömb a memória összefüggő helyein tárolt hasonló típusú elemek gyűjteménye. A tömb fő előnye, hogy véletlenszerűen érhetjük el a tömbelemeket, míg a linkelt lista elemeihez nem lehet véletlenszerűen hozzáférni.

Ban ben Jáva , Tömbök változtatható adattípusok, azaz a tömb mérete rögzített, és nem tudunk közvetlenül új elemet hozzáadni az Array-hez. Azonban többféleképpen is hozzáadhat elemeket a tömbhöz. Tegyük fel, hogy van egy tömbünk, amelyhez elemeket kell hozzáadnunk. A következő módszerekkel adhatunk hozzá elemeket az arr-hez.

1. Az arr-nél nagyobb méretű tömb létrehozásával.
2. Az ArrayList használatával
3. Az elem eltolásával az arr méretének beállításához.

Vessünk egy pillantást az általunk leírt módokra.

Nagyobb méretű tömb létrehozása

Ahhoz, hogy elemeket adjunk a java tömbhöz, létrehozhatunk egy másik nagyobb méretű tömböt, átmásolhatjuk az összes elemet a tömbünkből egy másik tömbbe, és az új értéket az újonnan létrehozott tömb utolsó helyére helyezhetjük. Ez azonban nem hatékony módja egy elem hozzáadásának a tömbhöz. Az alábbi példában egy 7 elemet adunk az arr tömbhöz egy újonnan létrehozott newArr tömb segítségével. Tekintsük a következő példát.

 import java.util.Arrays; public class ArrayExample { public static void main(String[] args) { // TODO Auto-generated method stub int arr[] = {1,2,3,4,5,6}; int n = arr.length; int newArr[] = new int[n+1]; int value = 7; System.out.println(Arrays.toString(arr)); for(int i = 0; i<n; i++) { newarr[i]="arr[i];" } newarr[n]="value;" system.out.println(arrays.tostring(newarr)); < pre> <h3>Using ArrayList</h3> <p>We can use <a href="/java-arraylist">ArrayList</a> as the intermediate structure and add the elements into the ArrayList using the add () method. ArrayList is a data structure that allows us to dynamically add elements. However, we can convert the ArrayList to the array by using the toArray() method. Hence this process involves the following steps.</p> <ol class="points"> <li>Convert Array into ArrayList using asList() method.</li> <li>Add elements into the array list using the add() method.</li> <li>Convert the ArrayList again to the array using the toArray() method.</li> </ol> <p>Consider the following example.</p> <pre> import java.util.ArrayList; import java.util.Arrays; public class JavaAddElementUsingList { public static void main(String[] args) { // TODO Auto-generated method stub Integer arr[] = {1,2,3,4,5,6}; System.out.println(&apos;Array:&apos;+Arrays.toString(arr)); ArrayList arrayList = new ArrayList(Arrays.asList(arr)); arrayList.add(7); arr = arrayList.toArray(arr); System.out.println(&apos;Array after adding element: &apos;+Arrays.toString(arr)); } } </pre> <p> <strong>Output:</strong> </p> <pre> Array:[1, 2, 3, 4, 5, 6] Array after adding element: [1, 2, 3, 4, 5, 6, 7] </pre> <h3>Shifting elements to adjust the size of the array</h3> <p>In this method, we will add the elements to the specified index in the array. Likewise, the above two processes will use a new destination array with a larger size than the original array. However, it will be tricky to shift the destination array elements after copying all elements from the original array to destination array.</p> <p>In this method, we will,</p> <ol class="points"> <li>Create a new destination array with a larger size than the original array.</li> <li>Copy all the elements from the original array to the new destination array</li> <li>Shift the elements after the given index to the right until it reaches the end of the array.</li> <li>Insert the new element at the given index.</li> </ol> <p>Consider the following example in which we will add a specific value at the given index 3 in the original array using a destination array.</p> <pre> import java.util.Arrays; public class JavaAddElementArraySpecified { public static void main(String[] args) { Integer arr[] = {1,2,3,4,5,6}; int n = arr.length; int index = 3; System.out.println(&apos;Original Array: &apos;+Arrays.toString(arr)); Integer newArr[] = new Integer[n+1]; int j = 0; for(int i = 0; i<newarr.length; i++) { if(i="=index)" newarr[i]="7;" }else j++; } newarr[index]="7;" system.out.println('array after adding value: '+arrays.tostring(newarr)); < pre> <p> <strong>Output:</strong> </p> <pre> Original Array: [1, 2, 3, 4, 5, 6] Array after adding value: [1, 2, 3, 7, 4, 5, 6] </pre> <hr></newarr.length;></pre></n;>

Kimenet:

 Array:[1, 2, 3, 4, 5, 6] Array after adding element: [1, 2, 3, 4, 5, 6, 7] 

Elemek eltolása a tömb méretének beállításához

Ennél a módszernél az elemeket a tömbben megadott indexhez adjuk. Hasonlóképpen, a fenti két folyamat egy új céltömböt használ, amelynek mérete nagyobb, mint az eredeti tömb. Mindazonáltal bonyolult lesz eltolni a cél tömb elemeit, miután az összes elemet az eredeti tömbből a céltömbbe másolták.

Ezzel a módszerrel

1. Hozzon létre egy új céltömböt, amelynek mérete nagyobb, mint az eredeti tömb.
2. Másolja az összes elemet az eredeti tömbből az új céltömbbe
3. Az adott index utáni elemeket tolja jobbra, amíg az el nem éri a tömb végét.
4. Szúrja be az új elemet a megadott indexbe.

Tekintsük a következő példát, amelyben egy adott értéket adunk hozzá az eredeti tömb adott 3-as indexéhez egy céltömb segítségével.

 import java.util.Arrays; public class JavaAddElementArraySpecified { public static void main(String[] args) { Integer arr[] = {1,2,3,4,5,6}; int n = arr.length; int index = 3; System.out.println(&apos;Original Array: &apos;+Arrays.toString(arr)); Integer newArr[] = new Integer[n+1]; int j = 0; for(int i = 0; i<newarr.length; i++) { if(i="=index)" newarr[i]="7;" }else j++; } newarr[index]="7;" system.out.println(\'array after adding value: \'+arrays.tostring(newarr)); < pre> <p> <strong>Output:</strong> </p> <pre> Original Array: [1, 2, 3, 4, 5, 6] Array after adding value: [1, 2, 3, 7, 4, 5, 6] </pre> <hr></newarr.length;>