# Mehrere Listen ineinander verschachteln



## SmartGuy (2. Nov 2009)

Hallo, 
wie verhindere ich ausdrücke wie  

```
List<List<List<List<List<List<List>>>>> Liste1=null
```
?

Klar ist die Antwort "mit OOP". 
Aber wie genau?:rtfm:


----------



## maki (2. Nov 2009)

Eigener Datentyp (klasse) mit vernünftiger Struktur & Schnittstelle


----------



## SmartGuy (2. Nov 2009)

hmm... kommt das nicht aufs gleich hinaus? Kann mir das gerade nicht vorstellen, wie?


----------



## 0x7F800000 (2. Nov 2009)

SmartGuy hat gesagt.:


> Hallo,
> wie verhindere ich ausdrücke wie
> 
> ```
> ...


raw types & @SuppressWarnings("all")^^ 

In welchem Kontext ist denn ein derartiger Ausruck aufgetreten? Sieht irgendwie von der Realität losgerissen aus. ???:L


----------



## Landei (2. Nov 2009)

Man könnte z.B. eine Map<Coord, Bla> verwenden, wobei Coord die Koordinaten speichert.

Ungetestet:

```
public class Coord {
   private int[] coords;
   public Coord(int... coords) {
        this.coords = coords;
   } 
   
   public int hashCode() {
        int r = 1;
        for(int c : coords) {
           r = 17*r + c; 
        }  
        return r; 
   }

   public boolean equals(Object o) {
       if(o instanceof Coord) {
          return Arrays.equals(coords, ((Coord)o).coords);
       } else return false;
   }
}


Map<Coord,String> = new HashMap<Coord, String>();
map.put(Coord(1,2,5,3), "test");
if(map.get(Coord(1,2,5,3)).equals("test")) {
   //tu was
}
```


----------



## maki (2. Nov 2009)

Das hier:

```
List<List<List<List<List<List<List>>>>> Liste1
```
ist keine vernünftige Struktur 

Was brauchst du denn genau?


----------



## SmartGuy (2. Nov 2009)

Ich benötige es für folgendes:

Ich lese eine XML-Datei ein. 
die sieht folgendermaßen aus

[XML]
<A>
	<aa>
		<aaa>
			<aaaa>
				<aaaaa>
                                                    ...
			<aaab>
			<aaac>			
		<aab>
			...
		<aac>
			...
	<ab>	
		<aba>
		...
	<ac>
		...
[/XML]

Wenn ich nun mit der ganzen XML arbeiten möchte, muss ich auf alle Tags und deren Unterelemente zugreifen können?

Und wenn ich nun alle Tags durchgehen oder mit den Values von <aaaaa> arbeiten möchte und z.b. von <aaaaa> und <aaaba> vergleichen möchte brauch ich sowas.

z.B. hätte man so etwas: 


```
for (int i=0; i<listA.size();i++){
        for (int j=0;j<listA.get(i).size();j++){
                  usw...
        }
}
```


----------



## Marco13 (2. Nov 2009)

Das ist ein Baum 

Node root = <A>
List<Node> children = <A>.children() = { <aa>, <ab>, <ac> }
List<Node> grandchildren = children.get(0).children() = { <aaa>, <aab> ... }
...


----------



## bygones (2. Nov 2009)

JDOM oder Groovy helfen hier weiter


----------



## maki (2. Nov 2009)

Werfe da mal das Composite  Pattern ein.


----------



## SmartGuy (2. Nov 2009)

Marco13 hat gesagt.:


> Das ist ein Baum
> 
> Node root = <A>
> List<Node> children = <A>.children() = { <aa>, <ab>, <ac> }
> ...



Bin auch dabei, das mit JDOM zu realisieren.
Hab bis jetzt: 

```
public static void main (String args[]) throws Exception {

		/** Erstellt document aus der xml-Datei. */
		SAXBuilder builder = new SAXBuilder();

		Document doc = builder.build("C:/test.xml");

Element person = doc.getRootElement();}
```

Aber müsste halt auf die ururururururenkel zugreifen und mit denen arbeiten können.


----------



## bygones (2. Nov 2009)

SmartGuy hat gesagt.:


> [XML]
> <A>
> <aa>
> <aaa>
> ...


mit Java mitteln wirst du hier nicht weiterkommen als zb JDom und dann auch ueber List.get(xx) gehen...

groovy ist da intuitiver
[groovy]
def A = new XmlParser().parse(...)
println A.aa.aaa.aaaa.text()
[/groovy]


----------



## SmartGuy (2. Nov 2009)

bygones hat gesagt.:


> mit Java mitteln wirst du hier nicht weiterkommen als zb JDom und dann auch ueber List.get(xx) gehen...
> 
> groovy ist da intuitiver
> [groovy]
> ...



Ja richtig, dann würde es doch auch wieder so aussehen, wie z.B. listA.get(i).get(j).get(k).get(l).get.(m).get(n).getName() :lol: 

Also ich würds machen, aber gibts ne leichtere und unkompliziertere Alternative?

Groovy? hmm... :rtfm: ist ja wieder ne neue Sprache. Mit OOP wär dies nicht einfacher möglich?


----------



## bygones (2. Nov 2009)

du kannst natuerlich das XML parsen und in eine bessere OOP struktur bringen... was aber dennoch bleibt dass du einmal im Jaba weg das XML parsen musst


----------



## 0x7F800000 (2. Nov 2009)

Was ist denn das globale Ziel? Was willst du mit dieser XML-Datei denn anstellen? Bist du dir sicher, dass du da mit java drangehen solltest, und nicht etwa mit XSLT o.ä?


----------



## Andreas29 (2. Nov 2009)

Hi,

wäre nicht XPath auch eine Alternative. Damit könntest du dir dann unter Angabe des Pfades ohne iterieren über diverse Listen die entsprechenden Elemente holen. Nur so als Tipp.

Grüße,
Andy


----------



## SmartGuy (3. Nov 2009)

0x7F800000 hat gesagt.:


> Was ist denn das globale Ziel? Was willst du mit dieser XML-Datei denn anstellen? Bist du dir sicher, dass du da mit java drangehen solltest, und nicht etwa mit XSLT o.ä?


Ziel: s.o., weiterarbeiten mit den untersten "Baumeinträgen" in der XML nach Vergleich der oberen Baumelemente. Ne, es muss mit Java realisiert werden.



bygones hat gesagt.:


> du kannst natuerlich das XML parsen und in eine bessere OOP struktur bringen... was aber dennoch bleibt dass du einmal im Jaba weg das XML parsen musst


Ist es nicht schon geparsed worden? 
Habs jetzt auch so gemacht, dass ich es mit Hilfe von OOP und rekursiven Methoden angefangen hab. Bis jetzt läufts ganz gut. Mal schauen, ob so alles realisierbar bleibt.



Andreas29 hat gesagt.:


> Hi,
> wäre nicht XPath auch eine Alternative. Damit könntest du dir dann unter Angabe des Pfades ohne iterieren über diverse Listen die entsprechenden Elemente holen. Nur so als Tipp.


Das wäre dann aber ne neue Prog. bzw. Skriptsprache. Es soll mit Java gelöst werden. :rtfm:


----------



## maki (3. Nov 2009)

Nochmals: Composite Pattern


----------



## 0x7F800000 (3. Nov 2009)

SmartGuy hat gesagt.:


> Das wäre dann aber ne neue Prog. bzw. Skriptsprache. Es soll mit Java gelöst werden. :rtfm:


Du willst irgendwas mit java lösen, und scheust davor zurück, auf die Standard API (in diesem Fall XPath) zurückzugreifen? Wieso nimmst du dann überhaupt java? :noe:


----------



## Unregistriert (4. Nov 2009)

weil die Einarbeitung zu viel Zeit beanspruchen würde?!


----------



## Nader (4. Nov 2009)

SmartGuy hat gesagt.:


> Ich benötige es für folgendes:
> 
> [XML]
> <A>
> ...



natürlich kann man mit ein bisschen Spielereien was einfaches basteln:


```
import java.util.HashMap;

public class XmlMap extends HashMap<XmlMap.Key, XmlMap.Value> {

	/**
	 * @param  data
	 */
	public void put(Object... data) {
		if (data.length < 2) {
			throw new IllegalArgumentException("blabla..");
		}
		super.put(createPutKey(data), new Value(data[data.length - 1]));
	}

	/**
	 * @param   data
	 *
	 * @return  Object
	 */
	public Object get(Object... data) {
		return super.get(createGetKey(data));
	}

	private Key createPutKey(Object... data) {
		StringBuffer key = new StringBuffer();
		for (int i = 0; i < data.length - 1; i++) {
			key.append(data[i].toString());
		}
		return new Key(key.toString());
	}

	private Key createGetKey(Object... data) {
		StringBuffer key = new StringBuffer();
		for (int i = 0; i < data.length; i++) {
			key.append(data[i].toString());
		}
		return new Key(key.toString());
	}

	static class Key {
		final Object key;

		public Key(Object key) {
			this.key = key;
		}

		public boolean equals(Object other) {
			return key.equals(((Key) other).key);
		}

		public int hashCode() {
			return key.hashCode();
		}

		public String toString() {
			return key.toString();
		}
	}

	static class Value {
		final Object value;

		/**
		 * @param  value
		 */
		public Value(Object value) {
			this.value = value;
		}

		public String toString() {
			return value.toString();
		}
	}

	/**
	 * @param  _
	 */
	public static void main(String... _) {
		XmlMap xm = new XmlMap();

		xm.put("A", "aa", "aaa", "aaaa", "aaaaa", "Hello World A");
		xm.put("A", "ab", "aba", "abaa", "abaaa", "Hello World B");

		System.out.println(xm.get("A", "aa", "aaa", "aaaa", "aaaaa"));
		System.out.println(xm.get("A", "ab", "aba", "abaa", "abaaa"));
	}
}
```


----------



## Unregistriert (4. Nov 2009)

wofür stehen die 3 Pünktchen in 

public void put(Object... data)

?


----------



## Vayu (4. Nov 2009)

das sind sogenannte "varargs"

Varargs


----------

