Dynamisches Array in Java

Dynamisches Array bedeutet in Java, dass die Größe des Arrays je nach Benutzeranforderungen entweder gestreckt oder verkleinert wird. Während ein Element aus einem Array entfernt wird, muss die Array-Größe verkleinert werden, und wenn ein Element zu einem Array hinzugefügt wird, wird die Array-Größe gestreckt. Arrays werden zum Speichern homogener Elemente verwendet, was bedeutet, dass derselbe Elementtyp gleichzeitig gespeichert werden kann.

Deklaration eines dynamischen Arrays in Java

Beispiel:Wir können Ganzzahlen, Gleitkommazahlen, Doppelzahlen, Zeichenfolgen, Zeichen, Objekte usw. speichern, jedoch jeweils nur für einen bestimmten Typ.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Ein Array kann auf drei Arten deklariert werden:

1. Array[]

Beispiel:

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

2. [] Array

Beispiel:

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

3. []A

Beispiel:

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

Wie werden Array-Elemente iteriert?

Array-Elemente werden iteriert mit:

• For-Schleife
• While-Schleife
• Für jede Schleife

Gibt es eine andere alternative Möglichkeit, das Array dynamisch zu machen?

• Ja, durch die Verwendung von Java-Sammlungen können wir dies erreichen.
• Für ein dynamisches Array können wir die ArrayList-Klasse verwenden.
• Die Arraylistengröße kann je nach Benutzeraktion automatisch erhöht oder verringert werden.

Was ist der Vorteil gegenüber der normalen dynamischen Array-Sammlungs-Arraylist?

• Je nach Benutzeranforderung kann die Array-Größe vergrößert (gedehnt) oder verringert (verkleinert) werden, aber bei Arrays müssen wir zunächst ein normales Array in ein dynamisches Array umwandeln, indem wir benutzerdefinierten Code zum Hinzufügen von Elementen, Entfernen von Elementen usw. schreiben.
• Inside Arraylist-Implementierung bezieht sich nur auf das Array-Konzept.

Wie funktioniert Dynamic Array in Java?

• Um aus einem normalen Array ein dynamisches Array zu machen, müssen wir eine benutzerdefinierte Logik zum Hinzufügen, Entfernen von Elementen, Erhöhen und Verringern von Größe und Kapazität usw. schreiben.

Syntax:

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
}
.
.
.
}

• In der ArrayList-Sammlung ist es nicht erforderlich, benutzerdefinierte Logik zu schreiben. Es stellt alle benutzerdefinierten Methoden zum Hinzufügen und Entfernen von Elementen, zum Abrufen von Größe und Kapazität, zum Abrufen von Elementen basierend auf dem Index, zum Entfernen von Elementen basierend auf dem Index usw. bereit.

Syntax:

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

Beispiele für dynamische Arrays in Java

Im Folgenden finden Sie Beispiele für dynamische Arrays in Java:

Beispiel #1

Elemente zum Array hinzufügen und Größe und Kapazität dynamisch erhöhen.

Code:

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

Ausgabe:

Erklärung:

• In Zeile 1 und Zeile 2 wurden 2 Elemente hinzugefügt; Danach versuchen wir, in Zeile 3 ein weiteres Element hinzuzufügen, aber die anfängliche Kapazität eines Arrays beträgt nur 2.
• Wenn wir versuchen, das dritte Element einzufügen, erhöht sich die Array-Kapazität auf 4 (da wir Kapazität=2*Anfangsgröße angeben).
• So können wir auch das 3.^rdElement hinzufügen.
• Zeile 4 zeigte alle Array-Elemente an.

Beispiel #2

• Entfernen der Elemente aus einem Array und dynamisches Reduzieren von Größe und Kapazität.
• Dieses Beispiel ist die Fortsetzung des obigen Beispiels.

Code:

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

Ausgabe:

Beispiel #3

Dynamisches Array mit ArrayList.

Code:

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

Ausgabe:

Fazit

In einem normalen dynamischen Array muss der Implementierungsentwickler benutzerdefinierte Logik schreiben, während in der Sammlung ArrayList alle vordefinierten Methoden verfügbar sind, sodass keine benutzerdefinierte Logik geschrieben werden muss.

Das obige ist der detaillierte Inhalt vonDynamisches Array in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!