# 100 arraylists mit for-schleife erstellen und in hashmap einbinden



## Jagito (13. Okt 2009)

Hi,
folgendes Problem (ich verwende Eclipse als Editor): Ich möchte gerne eine große Anzahl an arraylists mit einem Schleifendurchlauf erstellen, so dass ich dann Listen mit dem Namen:
myList1
myList2
myList3 etc. habe. 

Dazu funktioniert aber weder der folgende Versuch, indem ich zuerst die 100 Namen in einem Array erzeuge und dann den Namen jeweils eine ArrayLists zuweise (Fehler:Type mismatch: cannot convert from ArrayList<LabelType> to ArrayList<LabelType>[])

```
String[]name = new String[100];
	for(int i=0; i<100; i++){
		name[i]=(String)"myList"+i;
	}
	for(int j=0; j<100; j++){
		ArrayList<LabelType> name[j] = new ArrayList<LabelType>();
	}
```

Versuche ich das Folgende, so erhalte ich als Fehlermeldung
	- String cannot be resolved
	- Syntax error on token "=", != expected
	- Syntax error on token ")", AssignmentOperator expected after 
	 this token
	- myList cannot be resolved
	- Syntax error on token(s), misplaced construct(s)

```
for(int j=0; j<3; j++){
		ArrayList<LabelType> (String)myList+j = new ArrayList<LabelType>();
	}
```

Wie kann dies gelöst werden? 

Das weitere, was mir unklar ist, ist, wie ich die (hoffentlich erfolgreich) erzeugten Listen per Schleife in eine Hashmap einfügen kann. Folgendes erzeugt "myList cannot be resolved or is not a field"


```
HashMap hm = new HashMap();
    for (int k=0;k<100;k++){
    hm.put(k, myList+k);
    }
```

Gruß,
Jan


----------



## SlaterB (13. Okt 2009)

es gibt doch nur ein paar Grundregeln, wie man Arrays deklariert, darauf zugreif usw., 
da kann man doch nicht irgendwelchen Quatsch zusammenbauen

>  ArrayList<LabelType> name[j] = new ArrayList<LabelType>();
was soll in dieser Zeile passieren?

1.
willst du ein neues Array von ArrayList deklarieren?
dann hat das j da nichts zu suchen, außer vielleicht als Größe
->
ArrayList<LabelType>[] neuesArray = new ArrayList<LabelType>[anzahl];
(mit der Nebenbemerkung, dass man leider keine generische Array anlegen darf)

2.
willst in ein Array an Stelle j eine neue ArrayList setzen?
dann muss dieses Array schon vorher definiert sein, dann sieht das ganz anders aus:
->
array[j] = new ArrayList<LabelType>();

3.
willst du in eine Liste an Stelle j einen Wert einfügen?
->
liste.set(j,wert);
oder
liste.add(wert);


----------



## 0x7F800000 (13. Okt 2009)

Jagito hat gesagt.:


> ```
> ArrayList<LabelType> name[j] = new ArrayList<LabelType>();
> ```


Was war denn damit ungefähr beabsichtigt? Oben ist [c]name[/c] doch als string-array deklariert, und überhaupt: was für ein Sprachkonstrukt soll das denn sein? Deklauslesarisation? :autsch:



> Das weitere, was mir unklar ist, ist, wie ich die (hoffentlich erfolgreich) erzeugten Listen per Schleife in eine Hashmap einfügen kann.


Und mir ist nicht mal klar, wie du auf eine HashMap überhaupt kommst. Wenn alle deine Listen durchgehend durchnummeriert sind, dann reicht doch ein Array bzw. ArrayList, woher kommt denn die notwendigkeit einer HashMap?

Ansonsten:

```
HashMap<String,ArrayList<LabelType>> map = new HashMap<String,ArrayList<LabelType>>();
for(int i=0; i<100; i++) map.put("myList"+i,new ArrayList<LabelType>());
```


----------



## bygones (13. Okt 2009)

nochmals kurz zusammengefasst 

dynamische Variablen namen ala [c]"myList" + i[/c] gibt es nicht in java.

alles in allem frag ich mich eher - was willst du eigentlich machen... 100 ArrayLists klingt schon mehr als merkwuerdig


----------



## Jagito (13. Okt 2009)

Die Anregungen gaben mir einige Einsichten.Danke! 
Mein Problem, was ich abbilden will, ist Folgendes: 
Angenommen wir haben 100 Schubladen. In jeder Schublade ist eine unterschiedliche Anzahl an (selbstdefinierten) Elementen enthalten, welche sich im Laufe des Programmdurchlaufs ändert, da Elemente hinzugefügt und gelöscht werden. 

Daher hätte ich, um die Elemente zu speichern, eine Arraylist angewendet. Da ich im Laufe des Algorithmuses auf Elemente zugreifen will, welche in einer bestimmten Schubladen enthalten sind, wollte ich die Schubladen durch eine Hashmap abbilden, welche die Zahlen 1-100 als key verwendet. 

Die Arraylists einzeln zu erstellen ist bei 100 Arraylists zu aufwendig. 

Alternativideen, wie ich dies umsetzen könnte?


----------



## Gast2 (13. Okt 2009)

Jagito hat gesagt.:


> Die Anregungen gaben mir einige Einsichten.Danke!
> Mein Problem, was ich abbilden will, ist Folgendes:
> Angenommen wir haben 100 Schubladen. In jeder Schublade ist eine unterschiedliche Anzahl an (selbstdefinierten) Elementen enthalten, welche sich im Laufe des Programmdurchlaufs ändert, da Elemente hinzugefügt und gelöscht werden.
> 
> ...



Jo mach dir eine Klasse Schublade mit einer List<Elemente> drin und eventuell einen Key?


----------



## ARadauer (13. Okt 2009)

> Die Arraylists einzeln zu erstellen ist bei 100 Arraylists zu aufwendig.


wieso?

```
HashMap<Integer, ArrayList<Element>> schubladen = new HashMap<Integer, ArrayList<Element>>();
       for(int i = 1; i<=100;i++){
         schubladen.put(i, new ArrayList<Element>());
      }
```

Wobei das natürlich nicht sehr sinnvoll ist. macht mehr sinn, dass man beim Lesen und Schreiben für einen bestimmten key auf Vorhandensein der ArrayList überprüft und bei Bedarf erstellt.


----------



## SlaterB (13. Okt 2009)

einzeln == ohne Map


----------



## 0x7F800000 (13. Okt 2009)

@ARadauer: musst du dem OP unbedingt seine falsche Lösung zum zweiten mal an den Kopf werfen? Wenn er denselben irrsinn einmal denkt und zwei mal sieht, hält er es evtl. versehentlich für richtig. :noe:

```
ArrayList<ArrayList<Stuff>> x=new ArrayList<ArrayList<Stuff>>(100);
for(int i=0; i<100; i++) x.set(i,new ArrayList<Stuff>());
```
Wo ist hier bitte eine Map? Und was tut es anderes?


----------



## Jagito (13. Okt 2009)

Danke euch, besonders auch ARadauer. Deine Umsetzung scheint auf mein Problem anwendbar zu sein . Es ist auch sinnvoll, da ich von Anfang an weiß, dass in jeder Schublade eine arraylist reingehört, welche auch sicherlich Elemente enthält. Daher ist das Überprüfen auf Vorhandensein einer Arraylist und Erstellung nur bei Bedarf im konkreten Fall nicht notwenidg. 
:toll:


----------



## JAVATOOOR (21. Jun 2012)

0x7F800000 hat gesagt.:


> @ARadauer: musst du dem OP unbedingt seine falsche Lösung zum zweiten mal an den Kopf werfen? Wenn er denselben irrsinn einmal denkt und zwei mal sieht, hält er es evtl. versehentlich für richtig. :noe:
> 
> ```
> ArrayList<ArrayList<Stuff>> x=new ArrayList<ArrayList<Stuff>>(100);
> ...



ich hab mal eine Frage zu 





> "ArrayList<ArrayList<Stuff>> x=new ArrayList<ArrayList<Stuff>>(100);
> 
> for(int i=0; i<100; i++) x.set(i,new ArrayList<Stuff>());"



was wird hier gemacht? 
sowei ich das verstanden habe werden 100 ArrayList angelegt und "x" ist der Name der ArrayList. 
aber wie würde die 2. ArrayList heißen
GRUß 

GAST


----------



## njans (21. Jun 2012)

Er erstellt eine ArrayList, welche ArrayList<Stuff> hält. Praktisch die ArrayList Variante eines 2 Dimensionalen Arrays 
x.set(index i, ArrayList Objekt) setzt an stelle i ein ArrayList-Objekt
Zugriff läuft über

```
x.get(indexDerSchublade i).get(indexDesElementsInDerSchublade j);
```


----------

