Je veux créer un tableau contenant des éléments ArrayList <String>.
J'ai essayé
ArrayList<String> name[] = new ArrayList<String>()[];
mais cela ne semble pas fonctionner.
Vous ne pouvez pas créer un tableau d'un type générique.
Au lieu de cela, vous pouvez créer un ArrayList<ArrayList<String>>
.
La bonne façon est:
ArrayList<String> name[] = new ArrayList[9];
Cependant, cela ne fonctionnera pas non plus, car vous ne pouvez pas créer un tableau avec un type générique, ce que vous essayez de faire est une matrice, et cela devrait être fait comme ceci:
String name[][];
Je sais que c'est un peu vieux, mais je vais quand même y répondre pour des vues futures.
Si vous voulez vraiment une structure ArrayList<String>[]
, Vous pouvez simplement créer une classe qui étend ArrayList et créer un tableau de cette classe:
public class StringArrayList extends ArrayList<String>{}
Et dans votre implémentation:
ArrayList<String> name[] = new StringArrayList[9];
Voici un exemple:
package testspace.arrays;
import Java.util.List;
public class TestStringArray {
public static void main(String[] args) {
List<String>[] arr = new StringArrayList[10];
for(int i = 0; i < arr.length; i++){
// CANNOT use generic 'new ArrayList<String>()'
arr[i] = new StringArrayList();
for(int j = 0; j < arr.length; j++){
arr[i].add("list item #(" + j + "|" + i + ")");
}
}
StringBuilder sb = new StringBuilder();
for(final List<String> list : arr){
for(final String str : list){
sb.append(str + " ");
}
sb.append("\n");
}
System.out.println(sb.toString());
}
}
NOTE Vous obtiendrez une erreur d'exécution si vous l'utilisez à la place: arr[i] = new ArrayList<String>()
Ce n'est pas approprié OO et ce type de code est très couplé à l'implémentation. Si vous devez faire une telle chose, vous avez probablement fait quelque chose de mal. Si le code n'est pas le vôtre, la personne qui l'a créé a probablement fait quelque chose de mal.
Si vous savez combien d'éléments sont là (ou même si vous ne l'avez pas fait), pourquoi ne pas utiliser Map<Integer,List<String>>
?
ArrayList<ArrayList<String>> name= new ArrayList<ArrayList<String>>(/*capacity*/);
Si vous voulez un tableau de ArrayList
, vous devrez initialiser chaque position du tableau individuellement:
int size = 9; // 9 is just an example
// you can remove the annotation, but you'll be warned:
// Type safety: The expression of type ArrayList[] needs unchecked conversion
// to conform to ArrayList<String>[]
@SuppressWarnings("unchecked")
ArrayList<String> name[] = new ArrayList[ size];
for( int i = 0; i < size; i++) {
name[ i] = new ArrayList<String>();
}
Il existe un moyen de le faire avec seulement peu de modifications de votre code.
ArrayList<String>[] name = new ArrayList[10];
Cela vous donnera un tableau d'ArrayList.
// This is the not correct way
ArrayList<String> name[] = new ArrayList<String>()[];
// This is the correct way
ArrayList<String> list[] = new ArrayList[2];
list[0] = new ArrayList();
list[1] = new ArrayList();
list[0].add("Some String 11");
list[0].add("Some String 22");
list[1].add("Some String 1111");
list[1].add("Some String 2222");
Tableau de listes de tableaux, exemple avec boucles
//Declare
Object[] arrayLists = new Object[size];
//Fill
for (int j=0; j < size; j++) {
arrayLists[k]= generateAnArrayList(j); //or whatnot
}
//Usage
for (int j=0; j < size; j++) {
ArrayList<Long> al = (ArrayList<Long>) arrayLists[j];
//do something here
}
Je sais que c'est un ancien post, mais quelqu'un vient de poser la même question et puisque personne n'a mentionné la solution suivante, la voici.
Une façon de le contourner pourrait être quelque chose comme un tableau 2d (la question récente concernait un tableau 2d ou ArrayLists) d'objets et alors vous devriez pouvoir mettre des références ArrayList dans le tableau. Je ne l'ai pas testé, mais quelque chose comme ça devrait fonctionner.
Object [][] data = new Object[5][5];
data[0][0] = new ArrayList<String>(); // etc . . .
Vous pouvez essayer ceci:
ArrayList[] arr=new ArrayList[5];
for(int i=0;i<5;i++)
arr[i]=new ArrayList<String>();
arr[1].add("35");
arr[1].add("ME");
arr[1].add("HELLO");
System.out.println(arr[1]);
Production:
[35, ME, HELLO]
J'ai essayé cela sans erreur, même si j'ai mis une limite dans le tableau inférieure au nombre d'éléments ajoutés:
package Testes.src;
import Java.util.ArrayList;
import Java.util.List;
public class Testes {
private List<String> name=new ArrayList<String>(1);
public Testes(){
for (int i = 1; i <= 100; i++) {
name.add("Teste"+Integer.toString(i));
}
for (int i = 0; i < name.size(); i++) {
System.out.println(name.get(i));
}
}
public static void main(String [] args)
{
Testes t1=new Testes();
}
}