Cara Menambah Elemen baharu Pada Tatasusunan Di Java

Oh, tatasusunan Java. Mereka adalah objek cinta yang mendalam dan kebencian ratusan pembangun perisian pemula. Menambah elemen pada tatasusunan yang telah dimulakan adalah mustahil, kata mereka... Sebenarnya, ia mungkin, tetapi bukan dalam makna klasik... dan ia tidak begitu mudah. Menambah elemen baharu pada tatasusunan yang telah dimulakan adalah sejenis helah. Walau bagaimanapun, helah ini boleh berguna dalam temu duga ... dan kadangkala dalam kerja pengaturcara. Untuk memastikan anda menikmati menggunakan jenis data dan mengetahui cara melakukannya dengan cekap, kami menulis panduan untuk menambah elemen baharu pada tatasusunan Java. Selain meneliti sampel teori dan kod dengan teliti, pastikan anda menyemak dan menyelesaikan masalah amalan yang dipaparkan dalam siaran.

Apakah itu Array di Jawa

Mari kita ingat apa itu Array dan cara menciptanya dalam Java. Jika anda masih ingat itu, sila langkau ke hadapan ke subtajuk seterusnya "5 Cara Menambah Elemen Baharu pada Tatasusunan Java". Dokumentasi Java rasmi Oracle mengatakan bahawa tatasusunan ialah satu siri nilai yang dimiliki oleh jenis data yang sama. Satu set integer ialah contoh sempurna tatasusunan dalam Java . Semua nilai yang anda tentukan mempunyai kedudukan tertentu dalam tatasusunan yang dipanggil index . Berikut ialah cara untuk mengisytiharkan dan memulakan tatasusunan:

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

Dalam kes pertama, kami menentukan tatasusunan myArray dan menjadikan Java untuk memperuntukkan ruang untuk tatasusunan 10 elemen, dalam myArray1 kedua , kami segera memasukkan 10 nilai ke dalamnya. Dalam mana-mana kes, elemen 11 tidak boleh ditolak begitu sahaja ke dalam tatasusunan. Untuk melaksanakan operasi dengan tatasusunan, pembangun memanipulasi indeks nilai yang terkandung dalam tatasusunan. Apa yang patut kita buat? Mari kita lihat cara paling biasa untuk menambah pada tatasusunan.

5 Cara Menambah Elemen Baharu pada Tatasusunan Java

Nah, di sini helah kami untuk menjadikan yang tidak berubah kelihatan boleh berubah.

• Tukar Tatasusunan kepada Senarai
• Buat tatasusunan baharu dengan kapasiti yang lebih besar dan tambahkan elemen baharu pada tatasusunan
• Melaksanakan System.arraycopy()
• Menyalin tatasusunan menggunakan Apache Commons
• Menggunakan kaedah ArrayCopyOf().

Mari kita lihat lebih dekat cara ini untuk menambah elemen pada tatasusunan.

1. Menukar Tatasusunan kepada Senarai

Memandangkan kita tidak boleh menambah elemen baharu pada tatasusunan secara langsung, perkara terbaik seterusnya yang perlu dilakukan ialah menukarnya kepada senarai, menambah elemen baharu dan menukar semula nilai kembali kepada tatasusunan. Cara pertama untuk menukar tatasusunan kepada senarai ialah menggunakan asList() untuk mencipta ArrayList baharu. Setelah julat nilai berjaya diubah, gunakan ListAdd() untuk memasukkan nilai. Sebaik sahaja anda tidak lagi perlu mengedit tatasusunan, tukar kembali kepada jenis data asal dengan bantuan kaedah toArray() . Dengan semua kaedah dan penukaran, ini boleh kelihatan mengelirukan pada mulanya. Mari kita lihat contoh menggunakan asList() untuk mengosongkan perkara.

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

Outputnya ialah: Jadi, dalam program ini kami telah berjaya mencipta array myArray daripada 7 nilai, mengisinya dan mencetaknya. Kemudian kami memutuskan bahawa sepuluh nilai tidak mencukupi untuk kami. Nah, kami menukar myArray kepada ArrayList arrList menggunakan kaedah Arrays.asList . Berikut ialah 28, elemen yang akan ditambah. Kami menambahkannya pada ArrayList arrList , dan kemudian menukarnya kembali kepada tatasusunan menggunakan kaedah toArray() dan mencetak tatasusunan baharu.

2. Buat tatasusunan baharu dengan kapasiti yang lebih besar

Salah satu cara yang paling biasa untuk menambah lebih banyak elemen pada tatasusunan ialah dengan mencipta tatasusunan baharu, lebih besar, dari awal, meletakkan elemen lama dan menambah elemen baharu. Berikut ialah panduan langkah demi langkah bagi proses tersebut:

• Cipta tatasusunan baharu dengan kapasiti a+n (a — kapasiti tatasusunan asal, n — bilangan elemen yang anda mahu tambah).
• Tambahkan semua elemen julat data sebelumnya kepada yang baharu, serta nilai baharu.
• Cetak tatasusunan yang terhasil.

Cuba buat tatasusunan sedemikian sendiri dan bandingkan kod anda dengan kod dalam contoh di bawah:

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

Outputnya ialah: Nah, cara ini untuk menambah elemen baharu ke dalam tatasusunan adalah yang paling mudah.

3. Menggunakan System.arrayCopy()

System.arrayCopy() ialah kaedah yang digunakan secara meluas untuk memperuntukkan tatasusunan yang lebih besar di destinasi tatasusunan sumber. Pembangun boleh menentukan jujukan yang ingin disalinnya ke tatasusunan baharu dalam kurungan kaedah. Untuk melihat cara kaedah itu berfungsi dan cuba gunakannya untuk diri sendiri, lihat dan cuba jalankan contoh di bawah:

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

Outputnya ialah: Di sini kami telah mencipta tatasusunan myArray , mencetaknya dan menambah elemen baharu menggunakan kaedah addElement kami , yang dibina pada System.arrayCopy() .

4. Menggunakan Apache Commons untuk menyalin tatasusunan

Mari kita gunakan cara yang tidak standard. Iaitu, perpustakaan pihak ketiga Apache Commons lang. Ia adalah sebahagian daripada projek Apache Commons yang memfokuskan pada semua aspek komponen Java boleh guna semula. Pengetahuan tentang projek tidak akan berlebihan. Apache Commons lang mempunyai kaedah tambah() yang direka khusus untuk membolehkan tatasusunan berkembang, ia menjimatkan banyak masa dan usaha. Perlu diingat bahawa kaedah add() Apache Commons ini adalah berdasarkan memanggil kaedah System.arraycopy() sekiranya anda perlu menjawab soalan peperiksaan atau temu duga yang rumit. Untuk menambah perpustakaan ke dalam projek anda pergi ke tapak web Apache Commons dan muat turun perpustakaan. Kemudian pergi ke Fail → Struktur Projek → Perpustakaan > + dan pilih fail balang yang dimuat turun.

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

Outputnya ialah:

5. Melaksanakan ArrayCopyOf()

ArrayCopyOf() ialah satu lagi kaedah untuk menambah elemen baharu pada tatasusunan. Seperti Apache Commons lang add() ia secara dalaman memanggil System.arraycopy() untuk melakukan operasi ini. Walau bagaimanapun, kebanyakan pembangun lebih suka ArrayCopyOf() kerana ia membolehkan mereka memastikan kod itu ringkas dan boleh dibaca. Berikut ialah contoh menggunakan ArrayCopyOf() untuk menambah elemen baharu pada tatasusunan:

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

Outputnya ialah:

Kesimpulan

Mengetahui cara menambah elemen pada tatasusunan membantu pembangun mengemas kini kod lama dengan cepat tanpa mengorbankan fungsi dan kebolehbacaannya... Atau hanya untuk lulus temu duga. Memandangkan terdapat pelbagai cara untuk menambah elemen pada tatasusunan Java, sila pilih kaedah yang anda selesa.