[Sekundentakt]

Hallo Gemeinde,

wie hier ArrayList und Iterator besprochen, habe ich nun mal einen Fall aus der realen Welt.

Folgende Situation:
Ich habe eine Reihe von Werten in einer Datenbank.
Beispielsweise:
ID Name Gruppe
1 Alfred 5
2 Herbert 5
3 Joey 5
4 Marta 1
...

Ich möchte nun die Mitglieder einer bestimmten Gruppe auslesen und in eine Datei speichern.

In PHP hätte ich jetzt einfach folgendes gemacht:
Ich hätte ein Array initiiert, dieses enthält die Gruppen_ID.
In dieses Array schreibe ich nun ein weiteres Array, welches die Namen enthält.

PHP-Code:

//$gruppe = 5
$array[$gruppe][0] = "Alfred";
$array[$gruppe][1] = "Herbert";
$array[$gruppe][2] = "Joey"; 


In Java würde ich das jetzt folgendermaßen lösen:
HashMap<String, ArrayList> -> String ist die ID (nein, kein Designfehler, der String ist beabsichtigt, da ich nicht mit Zahlen arbeite) und in die ArrayList füge ich meine Werte ein. Dabei schaukle ich hin und her.

Zur Erklärung
rowSyn: entspricht der Gruppennummer
rowVal: ist eine ArrayList, die alle Namen zu dieser Gruppennummer enthält

		while(result.next())
		{
			String rowSyn;
			rowSyn = result.getString("syn");
			ArrayList rowVal = new ArrayList(10);
			
			rowVal.add(result.getString("name"));
			

			while(result.next() && result.getString("syn").equals(rowSyn))
			{
					rowVal.add(result.getString("name"));
					
					//nach vorne "schaukeln" -> gehört der nächste Datensatz noch zur aktuellen Gruppe?
					if(result.next() && result.getString("syn").equals(rowSyn))
					{
						//wenn ja: tu nichts und schaukle wieder zurück.
						result.previous();
					}
					else
					{
						//wenn nicht: füge unsere Gruppe und die Namen hinzu -> schaukle zurück
						synMap.put(rowSyn, rowVal);	
						result.previous();
						break;
					}
			}

Was sagt ihr dazu?
Ist das the Java-way?

[$traight-$hoota]

Grundsätzlich ist das der Java-Way, aber irgendwie ein bischen verkompliziert... Dieses Vor- und Zurück-"Schaukeln" is gar kein guter Stil, da kommt es schnell zu fehlern!

Map<String, ArrayList<String>> syncMap = new HashMap<String, ArrayList<String>>();
while(result.next()) {
    String rowSyn = result.getString("syn");
    if(! syncMap.containsKey(rowSyn)){
        syncMap.put(rowSyn, new ArrayList<String>());
    }
    syncMap.get(rowSyn).add(result.getString("name"));
}
 

[Sekundentakt]

Klasse! Danke Johannes, sieht gleich viel übersichtlicher aus.

[The_S]

Ich weiß, du hasst mich, aber ich hasse solche ArrayList in HashMap Konstrukte ;) .

Möchtest du folgende Struktur:

Datenstruktur
|
+-Gruppe 1
|  |
|  +--ID/Name
|  |
|  +--ID/Name
|
+-Gruppe 2
   |
   +--ID/Name

oder

Datenstruktur
|
+-Gruppe 1
|  |
|  +--Name
|  |
|  +--Name
|
+-Gruppe 2
   |
   +--Name

? Und wie musst du auf die Daten zugreifen? Möchtest du möglichst schnell anhand der Gruppen-ID eine Gruppe erhalten? Möchtest du anhand eines Namens oder einer ID die dazugehörige Gruppe(n) erhalten? Möchtest du deine Datenstruktur schnell nach Gruppen/Namen/ID-Paaren durchsuchen? Oder alles zusammen?

[The_S]

Hm ... irgendwie ist da ein Teil von meinem Beitrag verschwunden .

Was ich noch sagen wollte: Falls der zweitere von meinen Szenarien zutreffen sollte, dann wäre das aber eine andere Struktur als die, die ich in deinem Link kritisiert habe. HashMap<String, ArrayList<String>> könnte ich mich mit zufrieden geben. Wäre die Struktur aber synonym zu meinem ersten Szenario (und somit auch zu der aus deinem Link), würde die Datenstruktur folglich so aussehen: HashMap<String, ArrayList<String[]>>, dann hätte ich dagegen etwas einzuwenden.

Also falls du deinen Code später auf das erste Szenario ausbauen möchtest, müssen wir über die Struktur noch einmal reden. Falls du ständig bei dem zweiten Szenario bleiben möchtest, nicke ich das mal so ab ;) .

[Sekundentakt]

Ich weiß, du hasst mich, aber ich hasse solche ArrayList in HashMap Konstrukte .

Ich möchte so etwas, wie die zweite Datenstruktur hergibt.
Die Daten werden aus einer SQL-Tabelle geladen.
Ziel der Arbeit ist es, diese schnell aus dem ResultSet in einen Behälter (in diesem Fall eine HashMap) zu laden.
Einmal getan, kann ich diese HashMap wieder der Reihe nach auslesen, um sie entweder in eine Datei zu schreiben oder anderweitig in anderen Objekten weiterzuverwenden.

Mit andern Worten: Der Schwerpunkt liegt darauf, dass ich die Gruppen/Namen schnell speichern und der Reihe nach wieder auslesen kann.
In der ArrayList/HashMap etc. muss nichts gesucht werden.

Jetzt bin ich gespannt! :)

EDIT:
Ich habs gemerkt ;).
Ich bleibe ausschließlich beim zweiten Szenario. Aus reiner Neugier: Wie wärs denn im ersten Fall Best Practice?

[The_S]

Bei zweiteren solltest du dir eine eigene Klasse mit den Attributen anlegen:

public class Person {
  
  private String id;
  private String name;

  // Getter/Setter
}

und diese dann in deiner HashMap verwalten: HashMap<String, ArrayList<Person>>

Generell lässt sich natürlich darüber streiten, ob nicht auch eine eigene Klasse für die Gruppen sinnvolle wäre

public class Group {

  private String id;
  private ArrayList<Person> people = new ArrayList<Person>();

  // Getter/Setter für id

  public void addPerson(Person p) {
    people.add(p);
  }

  public void removePerson(Person p) {
    people.remove(p);
  }
}

Und dann HashMap<String, Group> (falls eine Gruppe schnell anhand ihrer ID gefunden werden soll), wenn nicht sogar nur ArrayList<Group>. Das wird halt vor allem dann interessant, wenn eine Person oder eine Gruppe > 1 Attribut hat, wie es bspw. bei deinem ArrayList<ArrayList<String[]>>-Szenario der Fall wäre.

[$traight-$hoota]

Zitat von The_S

Und dann HashMap<String, ArrayList<Group>> (falls eine Gruppe schnell anhand ihrer ID gefunden werden soll)

Das wäre wohl eher Map<String, Group>

Der jeweilige Datencontainer (wie die angesprochene Klasse Person) kann selbstverständlich nach belieben gewählt werde, da im Beispiel nur der Name gegeben war, hab ich das ganze darauf vereinfacht, einen String zu verwenden.

[The_S]

Zitat von $traight-$hoota

Das wäre wohl eher Map<String, Group>

Ja natürlich. Tippfehler meinerseits. Sorry! Habs auch gleich ausgebessert.