Comment créer une liste multidimensionnelle ArrayList en Java?
Quoi qu'il en soit, je suis assez nouveau dans ArrayLists mais j'en ai besoin pour ce projet. Si vous pouviez m'aider, je vous en serais plus que reconnaissant!
Fondamentalement, je dois créer une ArrayList multidimensionnelle pour contenir les valeurs String. Je sais comment faire cela avec un tableau standard, comme par exemple public static String[][] array = {{}}, mais ce n’est pas bon, car je ne connais pas la taille de mon tableau, tout ce que je sais, c’est le nombre de demensions qu’il aura.
Donc, si vous savez comment faire un 'tableau redimensionnable dynamiquement avec 2/+ demensions', pourriez-vous me dire s'il vous plaît.
Merci d'avance,
Andy
Modifier/mettre à jour
Peut-être serait-il plus facile de redimensionner ou de définir un tableau standard en utilisant une variable? Mais je ne sais pas?
Il est probablement plus facile d’utiliser mon idée originale de ArrayList cependant… Tout ce dont j’ai besoin est un code exemple complet pour créer un tableau ArrayList 2D et ajouter ainsi des valeurs d’exemple aux deux dimensions sans connaître l’index.
Si vous êtes autorisé à utiliser des classes Java prédéfinies, vous pouvez effectuer les opérations suivantes:
private static ArrayList<ArrayList<String>> biDemArrList = new ArrayList<ArrayList<String>>();
Ensuite, vous pouvez ajouter de nouveaux éléments, quelque chose comme:
ArrayList<String> temp = new ArrayList<String>(); // added ()
temp.add("Hello world.");
biDemArrList.add(temp);
J'espère que vous pourrez comprendre ce que je veux dire et ce qui se passe. En outre, vous devez importer Java.util.ArrayList; pour cela, si vous utilisez la classe Java.
ArrayList<ArrayList<String>>
http://download.Oracle.com/javase/6/docs/api/Java/util/ArrayList.html
Vous pouvez avoir ArrayList avec des éléments qui seraient ArrayLists lui-même.
List<ArrayList<String>> 2dlist = new ArrayList<ArrayList<String>>(); ne serait-il pas une meilleure mise en œuvre (plus efficace)?
Je peux penser à un tableau dans un tableau ou à une carte multi-carte Guava ?
par exemple.
ArrayList<ArrayList<String>> matrix = new ArrayList<ArrayList<String>>();
Une fois que j'ai eu besoin de arrayList 2D et que j'ai créé en utilisant List et ArrayList, le code est le suivant:
import Java.util.*;
public class ArrayListMatrix {
public static void main(String args[]){
List<ArrayList<Integer>> a = new ArrayList<>();
ArrayList<Integer> a1 = new ArrayList<Integer>();
ArrayList<Integer> a2 = new ArrayList<Integer>();
ArrayList<Integer> a3 = new ArrayList<Integer>();
a1.add(1);
a1.add(2);
a1.add(3);
a2.add(4);
a2.add(5);
a2.add(6);
a3.add(7);
a3.add(8);
a3.add(9);
a.add(a1);
a.add(a2);
a.add(a3);
for(ArrayList obj:a){
ArrayList<Integer> temp = obj;
for(Integer job : temp){
System.out.print(job+" ");
}
System.out.println();
}
}
}
Sortie:
1 2 3
4 5 6
7 8 9
Source: https://www.codepuran.com/Java/2d-matrix-arraylist-collection-class-Java/
JAcob Tomao mérite le crédit pour le code ..__ J'ai ajouté seulement quelques commentaires pour aider les débutants comme moi à le comprendre . J'espère que cela aide.
// read about Generic Types In Java & the use of class<T,...> syntax
// This class will Allow me to create 2D Arrays that do not have fixed sizes
class TwoDimArrayList<T> extends ArrayList<ArrayList<T>> {
public void addToInnerArray(int index, T element) {
while (index >= this.size()) {
// Create enough Arrays to get to position = index
this.add(new ArrayList<T>()); // (as if going along Vertical axis)
}
// this.get(index) returns the Arraylist instance at the "index" position
this.get(index).add(element); // (as if going along Horizontal axis)
}
public void addToInnerArray(int index, int index2, T element) {
while (index >= this.size()) {
this.add(new ArrayList<T>());// (as if going along Vertical
}
//access the inner ArrayList at the "index" position.
ArrayList<T> inner = this.get(index);
while (index2 >= inner.size()) {
//add enough positions containing "null" to get to the position index 2 ..
//.. within the inner array. (if the requested position is too far)
inner.add(null); // (as if going along Horizontal axis)
}
//Overwrite "null" or "old_element" with the new "element" at the "index 2" ..
//.. position of the chosen(index) inner ArrayList
inner.set(index2, element); // (as if going along Horizontal axis)
}
}
Que penseriez-vous de cela pour 3D ArrayList - peut être utilisé de la même manière que les tableaux - voir les commentaires dans le code:
import Java.util.ArrayList;
import Java.util.List;
/**
* ArrayList3D simulates a 3 dimensional array,<br>
* e.g: myValue = arrayList3D.get(x, y, z) is the same as: <br>
* myValue = array[x][y][z] <br>
* and<br>
* arrayList3D.set(x, y, z, myValue) is the same as:<br>
* array[x][y][z] = myValue; <br>
* but keeps its full ArrayList functionality, thus its
* benefits of ArrayLists over arrays.<br>
* <br>
* @param <T> data type
*/
public class ArrayList3D <T> {
private final List<List<List<T>>> arrayList3D;
public ArrayList3D() {
arrayList3D = newArrayDim1();
}
/**
* Get value of the given array element.<br>
* E.g: get(2, 5, 3);<br>
* For 3 dim array this would equal to:<br>
* nyValue = array[2][5][3];<br>
* <br>
* Throws: IndexOutOfBoundsException
* - if any index is out of range
* (index < 0 || index >= size())<br>
* <br>
* @param dim1 index of the first dimension of the array list
* @param dim2 index of the second dimension of the array list
* @param dim3 index of the third dimension of the array list
* @return value of the given array element (of type T)
*/
public T get(int dim1, int dim2, int dim3) {
List<List<T>> ar2 = arrayList3D.get(dim1);
List<T> ar3 = ar2.get(dim2);
return ar3.get(dim3);
}
/**
* Set value of the given array.<br>
* E.g: set(2, 5, 3, "my value");<br>
* For 3 dim array this would equal to:<br>
* array[2][5][3]="my value";<br>
* <br>
* Throws: IndexOutOfBoundsException
* - if any index is out of range
* (index < 0 || index >= size())<br>
* <br>
* @param dim1 index of the first dimension of the array list
* @param dim2 index of the second dimension of the array list
* @param dim3 index of the third dimension of the array list
* @param value value to assign to the given array
* <br>
*/
public void set(int dim1, int dim2, int dim3, T value) {
arrayList3D.get(dim1).get(dim2).set(dim3, value);
}
/**
* Set value of the given array element.<br>
* E.g: set(2, 5, 3, "my value");<br>
* For 3 dim array this would equal to:<br>
* array[2][5][3]="my value";<br>
* <br>
* Throws: IndexOutOfBoundsException
* - if any index is less then 0
* (index < 0)<br>
* <br>
* @param indexDim1 index of the first dimension of the array list
* @param indexDim2 index of the second dimension of the array list
* If you set indexDim1 or indexDim2 to value higher
* then the current max index,
* the method will add entries for the
* difference. The added lists will be empty.
* @param indexDim3 index of the third dimension of the array list
* If you set indexDim3 to value higher
* then the current max index,
* the method will add entries for the
* difference and fill in the values
* of param. 'value'.
* @param value value to assign to the given array index
*/
public void setOrAddValue(int indexDim1,
int indexDim2,
int indexDim3,
T value) {
List<T> ar3 = setOrAddDim3(indexDim1, indexDim2);
int max = ar3.size();
if (indexDim3 < 0)
indexDim3 = 0;
if (indexDim3 < max)
ar3.set(indexDim3, value);
for (int ix = max-1; ix < indexDim3; ix++ ) {
ar3.add(value);
}
}
private List<List<List<T>>> newArrayDim1() {
List<T> ar3 = new ArrayList<>();
List<List<T>> ar2 = new ArrayList<>();
List<List<List<T>>> ar1 = new ArrayList<>();
ar2.add(ar3);
ar1.add(ar2);
return ar1;
}
private List<List<T>> newArrayDim2() {
List<T> ar3 = new ArrayList<>();
List<List<T>> ar2 = new ArrayList<>();
ar2.add(ar3);
return ar2;
}
private List<T> newArrayDim3() {
List<T> ar3 = new ArrayList<>();
return ar3;
}
private List<List<T>> setOrAddDim2(int indexDim1) {
List<List<T>> ar2 = null;
int max = arrayList3D.size();
if (indexDim1 < 0)
indexDim1 = 0;
if (indexDim1 < max)
return arrayList3D.get(indexDim1);
for (int ix = max-1; ix < indexDim1; ix++ ) {
ar2 = newArrayDim2();
arrayList3D.add(ar2);
}
return ar2;
}
private List<T> setOrAddDim3(int indexDim1, int indexDim2) {
List<List<T>> ar2 = setOrAddDim2(indexDim1);
List<T> ar3 = null;
int max = ar2.size();
if (indexDim2 < 0)
indexDim2 = 0;
if (indexDim2 < max)
return ar2.get(indexDim2);
for (int ix = max-1; ix < indexDim2; ix++ ) {
ar3 = newArrayDim3();
ar2.add(ar3);
}
return ar3;
}
public List<List<List<T>>> getArrayList3D() {
return arrayList3D;
}
}
Et voici un code de test:
ArrayList3D<Integer> ar = new ArrayList3D<>();
int max = 3;
for (int i1 = 0; i1 < max; i1++) {
for (int i2 = 0; i2 < max; i2++) {
for (int i3 = 0; i3 < max; i3++) {
ar.setOrAddValue(i1, i2, i3, (i3 + 1) + (i2*max) + (i1*max*max));
int x = ar.get(i1, i2, i3);
System.out.println(" - " + i1 + ", " + i2 + ", " + i3 + " = " + x);
}
}
}
Résultat obtenu:
- 0, 0, 0 = 1
- 0, 0, 1 = 2
- 0, 0, 2 = 3
- 0, 1, 0 = 4
- 0, 1, 1 = 5
- 0, 1, 2 = 6
- 0, 2, 0 = 7
- 0, 2, 1 = 8
- 0, 2, 2 = 9
- 1, 0, 0 = 10
- 1, 0, 1 = 11
- 1, 0, 2 = 12
- 1, 1, 0 = 13
- 1, 1, 1 = 14
- 1, 1, 2 = 15
- 1, 2, 0 = 16
- 1, 2, 1 = 17
- 1, 2, 2 = 18
- 2, 0, 0 = 19
- 2, 0, 1 = 20
- 2, 0, 2 = 21
- 2, 1, 0 = 22
- 2, 1, 1 = 23
- 2, 1, 2 = 24
- 2, 2, 0 = 25
- 2, 2, 1 = 26
- 2, 2, 2 = 27