Tableau dynamique en Java

Dynamic Array en Java signifie étendre ou réduire la taille du tableau en fonction des besoins de l'utilisateur. Lorsqu'un élément est supprimé d'un tableau, la taille du tableau doit être réduite, et si un élément est ajouté à un tableau, la taille du tableau devient alors extensible. Les tableaux sont utilisés pour stocker des éléments homogènes, ce qui signifie que le même type d'éléments peut être stocké à la fois.

Déclaration de tableau dynamique en Java

Exemple : Nous pouvons stocker des nombres entiers, des nombres flottants, des nombres doubles, des chaînes, des caractères, des objets, etc. mais à un moment donné et de tout type spécifique uniquement.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Un tableau peut être déclaré de 3 manières :

1. Tableau[]

Exemple :

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

2. [] Tableau

Exemple :

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

3. []UNE

Exemple :

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

Comment les éléments du tableau sont-ils itérés ?

Les éléments du tableau sont itérés en utilisant :

• Boucle For
• Boucle while
• Pour chaque boucle

Existe-t-il un autre moyen alternatif de rendre le tableau dynamique ?

• Oui, en utilisant des collections Java, nous pouvons y parvenir.
• Pour un tableau dynamique, on peut utiliser la classe ArrayList.
• La taille de la liste de tableaux peut être automatiquement augmentée ou diminuée en fonction de l'action de l'utilisateur.

Quel est l'avantage par rapport au tableau dynamique normal des collections Arraylist ?

• En fonction des besoins de l'utilisateur, la taille du tableau peut être augmentée (étirée) ou diminuée (rétrécie), mais dans les tableaux, nous devons d'abord transformer un tableau normal en tableau dynamique en écrivant du code personnalisé pour ajouter des éléments, supprimer des éléments, etc.
• L'implémentation de Inside Arraylist concerne uniquement le concept de tableaux.

Comment fonctionne Dynamic Array en Java ?

• Pour transformer un tableau normal en tableau dynamique, nous devons écrire une logique personnalisée pour ajouter, supprimer des éléments, augmenter et diminuer la taille et la capacité, etc.

Syntaxe :

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

• Dans la collection ArrayList, il n'est pas nécessaire d'écrire une logique personnalisée. Il fournira toutes les méthodes personnalisées pour ajouter, supprimer des éléments, obtenir la taille et la capacité, obtenir des éléments basés sur l'index, supprimer des éléments basés sur l'index, etc.

Syntaxe :

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

Exemples de tableau dynamique en Java

Vous trouverez ci-dessous des exemples de Dynamic Array en Java :

Exemple n°1

Ajout des éléments au tableau et augmentation dynamique de la taille et de la capacité.

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

Sortie :

Explication :

• Dans les lignes 1 et 2, j'ai ajouté 2 éléments ; après cela, nous essayons d'ajouter un élément supplémentaire à la ligne 3, mais la capacité initiale d'un tableau est de 2 seulement.
• Lorsque nous essayons d'insérer le troisième élément, la capacité du tableau augmente à 4 (car nous spécifions capacité=2*taille initiale).
• Ainsi, nous pouvons également pouvoir ajouter le 3^ème élément.
• La ligne 4 affichait tous les éléments du tableau.

Exemple n°2

• Supprimer les éléments d'un tableau et réduire la taille et la capacité de manière dynamique.
• Cet exemple est la suite de l'exemple ci-dessus.

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

Sortie :

Exemple #3

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

Sortie :

Conclusion

Dans un tableau dynamique normal, le développeur d'implémentation doit écrire une logique personnalisée, alors que, dans la collection ArrayList, toutes les méthodes prédéfinies sont disponibles, donc pas besoin d'écrire une logique personnalisée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!