Tatasusunan Dinamik di Jawa

Tatasusunan Dinamik dalam Java bermaksud sama ada diregangkan atau mengecilkan saiz tatasusunan bergantung pada keperluan pengguna. Semasa elemen dialih keluar daripada tatasusunan, saiz tatasusunan mesti dikecilkan dan jika sesuatu elemen ditambahkan pada tatasusunan, maka saiz tatasusunan menjadi regangan. Tatasusunan digunakan untuk menyimpan unsur homogen bermakna jenis unsur yang sama boleh disimpan pada satu masa.

Pengisytiharan Tatasusunan Dinamik dalam Java

Contoh: Kita boleh menyimpan nombor integer, nombor apungan, nombor berganda, rentetan, aksara, Objek, dsb. tetapi pada satu masa dan mana-mana jenis tertentu sahaja.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Suatu tatasusunan boleh diisytiharkan dalam 3 cara:

1. Tatasusunan[]

Contoh:

int Array[]={1,2,4};

2. [] Tatasusunan

Contoh:

int[] Array ={1,2,4};

3. []A

Contoh:

int []Array ={1,2,4};

Bagaimanakah Elemen Tatasusunan Diulang?

Elemen tatasusunan diulang dengan menggunakan:

• Untuk gelung
• While loop
• Untuk Setiap gelung

Adakah terdapat cara alternatif lain untuk menjadikan tatasusunan menjadi dinamik?

• Ya, dengan menggunakan koleksi Java, kita boleh mencapai ini.
• Untuk tatasusunan dinamik, kita boleh menggunakan kelas ArrayList.
• Saiz senarai tatasusunan boleh ditingkatkan atau dikurangkan secara automatik berdasarkan tindakan pengguna.

Apakah kelebihan berbanding tatasusunan dinamik biasa kepada Senarai Tatasusunan koleksi?

• Berdasarkan keperluan pengguna, saiz tatasusunan boleh ditingkatkan (diregangkan) atau dikurangkan(mengecil) masuk, tetapi dalam tatasusunan terlebih dahulu, kita mesti membuat tatasusunan biasa kepada tatasusunan dinamik dengan menulis kod tersuai untuk menambah elemen, mengalih keluar elemen, dsb.
• Pelaksanaan Senarai Tatasusunan Dalam adalah pada konsep tatasusunan sahaja.

Bagaimana Tatasusunan Dinamik berfungsi dalam Java?

• Untuk membuat tatasusunan biasa kepada tatasusunan dinamik, kita mesti menulis logik tersuai untuk menambah, mengalih keluar elemen, menambah dan mengurangkan saiz dan kapasiti, dsb.

Sintaks:

class DynamicArray
{
addingElements()
{
//custom logic
}
addingElementsAtIndex(int index, int element)
{
//custom logic
}
removingElements()
{
//custom logic
}
removingElementsAtIndex(int index, int element)
{
//custom logic
}
increasingSize()
{
//custom logic
}
decreasingSize()
{
//custom logic
}
printArrayElements()
{
//custom logic
}
.
.
.
}

• Dalam koleksi ArrayList, tidak perlu menulis logik tersuai. Ia akan menyediakan semua kaedah tersuai untuk menambah, mengalih keluar elemen, mendapatkan saiz dan kapasiti, mendapatkan elemen berdasarkan indeks, mengalih keluar elemen berdasarkan indeks, dsb.

Sintaks:

class ArrayListLogic
{
List<Generic Type> list=new ArrayList<Generic Type>();
list.add();
list.remove(index,element);
.
.
.
}

Contoh Tatasusunan Dinamik dalam Java

Diberikan di bawah adalah contoh Tatasusunan Dinamik dalam Java:

Contoh #1

Menambah elemen pada tatasusunan dan meningkatkan saiz serta kapasiti secara dinamik.

Kod:

package com.dynamicarray;
import java.util.Arrays;
public class DynamicArray {
// declaring an array
int myArray[];
// stores the present size of the array
int sizeOfMyArray;
// stores total capacity of an array
int arrayCapacity;
// initializing array, size and capacity
public DynamicArray() {
myArray = new int[2];
sizeOfMyArray = 0;
arrayCapacity = 2;
}
// method for adding elements
public void addElementsToArray(int element) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
myArray[sizeOfMyArray] = element;
sizeOfMyArray++;
}
// method for adding elements to specific position
public void addElementAtPosition(int position, int value) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
// shifting array elements
for (int p = sizeOfMyArray - 1; p >= position; p--) {
myArray[p + 1] = myArray[p];
}
// adding the element at specific position
myArray[position] = value;
sizeOfMyArray++;
}
// method for getting the element from specific position
public int getElementAtposition(int position) {
return myArray[position];
}
// method for increasing capacity if all the elements in an array filled
public void increaseCapacity(int minimumCapacity) {
int temp[] = new int[arrayCapacity * minimumCapacity];
for (int p = 0; p < arrayCapacity; p++) {
temp[p] = myArray[p];
}
myArray = temp;
arrayCapacity = arrayCapacity * minimumCapacity;
}
// method for array current size
public int displaySize() {
return sizeOfMyArray;
}
// method for array total capacity
public int displayCapacity() {
return arrayCapacity;
}
// method for display all elements
public void displayArrayElements() {
System.out.println("elements in array are :" + Arrays.toString(myArray));
}
public static void main(String[] args) {
DynamicArray array = new DynamicArray();
System.out.println("===================================================================");
System.out.println("Inital array size " + array.displaySize() + " and initial capacity " + array.displayCapacity());
System.out.println("===================================================================");
// adding elements at index 0 and 1
array.addElementsToArray(10);//line 1
array.addElementsToArray(20);//line 2
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.addElementsToArray(30); //line 3
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.displayArrayElements(); //line 4
// adding element at index 1
array.addElementAtPosition(1, 50);
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.displayArrayElements();
// adding element at index 2
array.addElementAtPosition(2, 60);
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.displayArrayElements();
}
}

Output:

Penjelasan:

• Dalam baris 1 dan baris 2 menambah 2 elemen; selepas itu, kami cuba menambah satu lagi elemen dalam baris 3, tetapi kapasiti awal tatasusunan ialah 2 sahaja.
• Apabila kami cuba memasukkan elemen ketiga, kapasiti tatasusunan meningkat kepada 4 (seperti yang kami nyatakan kapasiti=2*saiz awal).
• Jadi, kita boleh menambah elemen 3^rd juga.
• Barisan 4 memaparkan semua elemen tatasusunan.

Contoh #2

• Mengalih keluar elemen daripada tatasusunan dan mengurangkan saiz serta kapasiti secara dinamik.
• Contoh ini adalah kesinambungan daripada contoh di atas.

Kod:

package com.dynamicarray;
import java.util.Arrays;
public class DynamicArray {
// declaring an array
int myArray[];
// stores the present size of the array
int sizeOfMyArray;
// stores total capacity of an array
int arrayCapacity;
// initializing array, size and capacity
public DynamicArray() {
myArray = new int[2];
sizeOfMyArray = 0;
arrayCapacity = 2;
}
// method for adding elements
public void addElementsToArray(int element) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
myArray[sizeOfMyArray] = element;
sizeOfMyArray++;
}
// method for adding elements to specific position
public void addElementAtPosition(int position, int value) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
// shifting array elements
for (int p = sizeOfMyArray - 1; p >= position; p--) {
myArray[p + 1] = myArray[p];
}
// adding the element at specific position
myArray[position] = value;
sizeOfMyArray++;
}
// method for getting the element from specific position
public int getElementAtposition(int position) {
return myArray[position];
}
// method for removing elements
public void removeAtPosition(int position) {
if (position >= sizeOfMyArray || position < 0) {
System.out.println("Opps!No elements found " + position + " position");
} else {
for (int p = position; p < sizeOfMyArray - 1; p++) {
myArray[p] = myArray[p + 1];
}
myArray[sizeOfMyArray - 1] = 0;
sizeOfMyArray--;
}
}
// method for increasing capacity if all the elements in an array filled
public void increaseCapacity(int minimumCapacity) {
int temp[] = new int[arrayCapacity * minimumCapacity];
for (int p = 0; p < arrayCapacity; p++) {
temp[p] = myArray[p];
}
myArray = temp;
arrayCapacity = arrayCapacity * minimumCapacity;
}
// method for make an array size to initial size
public void makeInitialSize() {
System.out.println("Making an array to initial size");
int temp[] = new int[sizeOfMyArray];
for (int q = 0; q < sizeOfMyArray; q++) {
temp[q] = myArray[q];
}
myArray = temp;
arrayCapacity = myArray.length;
}
// method for array current size
public int displaySize() {
return sizeOfMyArray;
}
// method for array total capacity
public int displayCapacity() {
return arrayCapacity;
}
// method for display all elements
public void displayArrayElements() {
System.out.println("elements in array are :" + Arrays.toString(myArray));
}
public static void main(String[] args) {
DynamicArray array = new DynamicArray();
System.out.println("===================================================================");
System.out.println("Inital array size " + array.sizeOfMyArray + " and initial capacity " + array.arrayCapacity);
System.out.println("===================================================================");
array.addElementsToArray(10);
array.addElementsToArray(20);
array.addElementsToArray(30);
array.addElementsToArray(40);
array.displayArrayElements();
array.removeAtPosition(2);
System.out.println("Size after Remove Operation=>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(2);
System.out.println("Size after Remove Operation=>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(1);
System.out.println("Size after Remove Operation=>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(2);
System.out.println("Size after Remove Operation =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(1);
System.out.println("Size after Remove Operation =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
// Make the array to initial size
array.makeInitialSize();
System.out.println(" After trimming Size of myArray =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.addElementsToArray(-5);
System.out.println("After trimming Size of myArray =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.addElementsToArray(-6);
System.out.println("After trimming Size of myArray =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
}
}

Output:

Contoh #3

Susun atur dinamik dengan ArrayList.

Kod:

package com.dynamicarray;
import java.util.ArrayList;
import java.util.List;
public class ArrayListDynamic {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(10);
list.add(20);
list.add(30);
list.add(40);
System.out.println("Adding the elements ArrayList =>"+list);
System.out.println("Adding the elements ArrayList size =>"+list.size());
/*Array List capacity formula newCapacity = (oldCapacity * 3/2) + 1*/
list.add(4, 50);
System.out.println("After adding the element at specific index =>"+list+" and size "+list.size());
list.remove(4);
list.remove(3);
System.out.println("After removing the elements =>"+list+" and size "+list.size());
}
}

Output:

Kesimpulan

Dalam tatasusunan dinamik biasa, pembangun pelaksanaan mesti menulis logik tersuai, manakala, dalam ArrayList koleksi, semua kaedah yang dipratentukan tersedia, jadi tidak perlu menulis logik tersuai.

Atas ialah kandungan terperinci Tatasusunan Dinamik di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!