Paano Magdagdag ng bagong Elemento Sa Isang Array Sa Java

Oh, mga array ng Java. Sila ang layon ng matinding pagmamahal at pagkamuhi ng daan-daang mga baguhan na software developer. Ang pagdaragdag ng mga elemento sa isang array na nasimulan na ay imposible, sabi nila... Sa totoo lang, posible ito, ngunit hindi sa isang klasikal na kahulugan... at hindi ito masyadong maginhawa. Ang pagdaragdag ng mga bagong elemento sa isang array na nasimulan na ay isang uri ng trick. Gayunpaman, ang mga trick na ito ay maaaring magamit sa isang pakikipanayam ... at kung minsan sa trabaho ng isang programmer. Upang matiyak na nasisiyahan ka sa paggamit ng uri ng data at alam kung paano ito gagawin nang mahusay, sumulat kami ng gabay sa pagdaragdag ng bagong elemento sa isang Java array. Maliban sa maingat na pagsusuri sa teorya at mga sample ng code, tiyaking tingnan at kumpletuhin ang mga problema sa pagsasanay na itinampok sa post.

Ano ang isang Array sa Java

Alalahanin natin kung ano ang Array at kung paano ito likhain sa Java. Kung natatandaan mo iyon, huwag mag-atubiling lumaktaw sa susunod na subheading na "5 Paraan para Magdagdag ng Mga Bagong Elemento sa Java Arrays". Sinasabi ng opisyal na dokumentasyon ng Java ng Oracle na ang mga array ay isang serye ng mga halaga na kabilang sa parehong uri ng data. Ang isang set ng mga integer ay isang perpektong halimbawa ng isang array sa Java . Ang lahat ng mga halaga na iyong tinukoy ay may isang tiyak na posisyon sa loob ng array na tinatawag na isang index . Narito ang mga paraan upang ideklara at simulan ang mga array:

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

Sa unang kaso, tinukoy namin ang isang array myArray at ginawa ang Java upang maglaan ng espasyo para sa isang hanay ng 10 elemento, sa pangalawang myArray1 , agad kaming nagpasok ng 10 mga halaga dito. Sa alinmang kaso, ang elemento 11 ay hindi maaaring itulak lamang sa array. Upang magsagawa ng mga pagpapatakbo gamit ang mga array, minamanipula ng mga developer ang mga indeks ng mga value na naglalaman ng array. Ano ang dapat nating gawin? Tingnan natin ang mga pinakakaraniwang paraan upang idagdag sa array.

5 Paraan para Magdagdag ng Mga Bagong Elemento sa Mga Array ng Java

Well, narito ang aming mga trick upang gawin ang hindi nababago na tila nababago.

• I-convert ang isang Array sa isang Listahan
• Gumawa ng bagong array na may mas malaking kapasidad at magdagdag ng bagong elemento sa array
• Implementing System.arraycopy()
• Pagkopya ng mga array gamit ang Apache Commons
• Paglalapat ng ArrayCopyOf() na pamamaraan

Tingnan natin ang mga paraan na ito upang magdagdag ng elemento sa isang array.

1. Pag-convert ng Array sa isang Listahan

Dahil hindi kami direktang makakapagdagdag ng bagong elemento sa isang array, ang susunod na pinakamagandang gawin ay i-convert ang mga ito sa mga listahan, magdagdag ng mga bagong elemento, at muling i-convert ang mga value pabalik sa array. Ang unang paraan para mag-convert ng array sa isang listahan ay ang paggamit ng asList() para gumawa ng bagong ArrayList. Kapag ang hanay ng mga halaga ay matagumpay na nabago, gamitin ang ListAdd() upang ipasok ang halaga. Kapag hindi mo na kailangang mag-edit ng array, i-convert pabalik sa orihinal na uri ng data sa tulong ng toArray() method. Sa lahat ng mga pamamaraan at conversion, ito ay maaaring mukhang nakakalito sa simula. Tingnan natin ang halimbawa ng paggamit ng asList() para i-clear ang mga bagay-bagay.

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

Ang output ay: Kaya, sa programa ay matagumpay naming nalikha ang isang array myArray ng 7 mga halaga, napunan ito at nai-print ito. Pagkatapos ay nagpasya kami na ang sampung halaga ay hindi sapat para sa amin. Well, na-convert namin ang myArray sa isang ArrayList arrList gamit ang Arrays.asList na paraan. Narito ang 28, ang elementong idaragdag. Idinagdag namin ito sa ArrayList arrList , at pagkatapos ay na-convert ito pabalik sa isang array gamit ang toArray() na paraan at nag-print ng bagong array.

2. Gumawa ng bagong array na may mas malaking kapasidad

Ang isa sa mga pinakakaraniwang paraan upang magdagdag ng higit pang mga elemento sa isang array ay sa pamamagitan ng paglikha ng bago, mas malaki, array mula sa simula, paglalagay ng mga elemento ng mga luma at pagdaragdag ng mga bagong elemento. Narito ang isang step-by-step na walkthrough ng proseso:

• Gumawa ng bagong array na may kapasidad na a+n (a — ang orihinal na array capacity, n — ang bilang ng mga elementong gusto mong idagdag).
• Idagdag ang lahat ng elemento ng nakaraang hanay ng data sa bago, pati na rin ang mga bagong halaga.
• I-print ang resultang array.

Subukang gumawa ng ganoong array nang mag-isa at ihambing ang iyong code doon sa halimbawa sa ibaba:

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

Ang output ay: Well, ang ganitong paraan upang magdagdag ng bagong elemento sa isang array ay ang pinakamadali.

3. Paglalapat ng System.arrayCopy()

Ang System.arrayCopy() ay isang malawakang ginagamit na paraan para sa paglalaan ng mas malaking array sa destinasyon ng source array. Maaaring tukuyin ng isang developer ang sequence na gusto niyang kopyahin sa isang bagong array sa mga bracket ng pamamaraan. Upang makita kung paano gumagana ang pamamaraan at subukang gamitin ito para sa iyong sarili, tingnan at subukang patakbuhin ang halimbawa sa ibaba:

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

Ang output ay: Dito kami gumawa ng array myArray , na-print ito at nagdagdag ng bagong elemento gamit ang aming addElement method, na binuo sa System.arrayCopy() .

4. Paggamit ng Apache Commons upang kopyahin ang mga array

Gumamit tayo ng hindi karaniwang paraan. Ibig sabihin, isang third-party na library na Apache Commons lang. Ito ay bahagi ng proyekto ng Apache Commons na nakatuon sa lahat ng aspeto ng magagamit muli na mga bahagi ng Java. Ang kaalaman tungkol sa proyekto ay hindi magiging kalabisan. Ang Apache Commons lang ay may pamamaraang add() na partikular na idinisenyo upang payagan ang pagpapalawak ng mga array, nakakatipid ito ng mga codder ng maraming oras at pagsisikap. Dapat tandaan na ang pamamaraang ito ng Apache Commons add() ay batay sa pagtawag sa System.arraycopy() na paraan kung sakaling kailanganin mong sagutin ang isang mapanlinlang na tanong sa pagsusulit o panayam. Upang idagdag ang mga aklatan sa iyong proyekto pumunta sa website ng Apache Commons at i-download ang mga aklatan. Pagkatapos ay pumunta sa File → Structure ng Proyekto → Mga Aklatan > + at piliin ang mga na-download na jar file.

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

Ang output ay:

5. Pagpapatupad ng ArrayCopyOf()

Ang ArrayCopyOf() ay isa pang paraan upang magdagdag ng bagong elemento sa isang array. Tulad ng Apache Commons lang add() ito ay panloob na tinatawag na System.arraycopy() para sa paggawa ng operasyong ito. Gayunpaman, mas gusto ng karamihan sa mga developer ang ArrayCopyOf() dahil pinapayagan silang panatilihing maigsi at nababasa ang code. Narito ang isang halimbawa ng paggamit ng ArrayCopyOf() upang magdagdag ng mga bagong elemento sa isang 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));
   }
}

Ang output ay:

Konklusyon

Ang pag-alam kung paano magdagdag ng mga elemento sa isang array ay nakakatulong sa mga developer na i-update nang mabilis ang lumang code nang hindi sinasakripisyo ang functionality at pagiging madaling mabasa nito... O para lang makapasa sa interview. Dahil may iba't ibang paraan upang magdagdag ng mga elemento sa mga array ng Java, huwag mag-atubiling piliin ang paraan kung saan ka komportable.