Eigener Assoziativ-Speicher

[redbomber]

Ich brauche eure Hilfe:

Ich muss gerade den folgenden Assoziativspeicher verwenden, blicke da aber nicht durch.

public class SuperHashMap<K, V> extends TreeMap<K, Object> {

	protected LinkedList<V> cast(Object o) {
		return (LinkedList<V>)o;
	}

	public List<V> get(K key) {
		Object o = super.get(key);
		List<V> list=Collections.EMPTY_LIST;
		if (o!=null) {
			if (o instanceof LinkedList) {
				list=Collections.unmodifiableList(cast(o));
			} else {
				ArrayList arrayList = new ArrayList<V>(1); // less overhead than linkedlist
				arrayList.add((V)o);
				list= Collections.unmodifiableList(arrayList);
			}
		}			
		return list;
	}
	
	public void put(K key, V value) {
		Object o = super.get(key);
		if (o==null) {
			super.put(key, value);
		} else {
			if (o instanceof LinkedList) {
				if (!cast(o).contains(value)) {
					cast(o).add(value);
				}
			} else {
				LinkedList<V> linkedList = new LinkedList<V>();
				linkedList.add((V)o);
				linkedList.add(value);					
				super.put(key, linkedList );
			}
		}			
	}	
}

Ich benötige diese super hashmap, diese soll mir für einen key (Long) eine LinkedList<MeinObjekt> liefern

-------------------------------------------------------------------------------------------------------
1. Frage:
Wie initialisiere ich diese HashMap?

ich dachte zuerst:
code]
SuperHashMap<Long, LinkedList<MeinObjekt> >
[/code]
ABer das muss glaub wie folgt sein:
SuperHashMap<Long, MeinObjekt>

--------------------------------------------------------------------------------------------------------
2. Frage:
Wenn ich mir dann für einen Key die LinkedList<MeinObjekt> erhalten möchte habe ich das problem, dass diese immer vom Typ List<MeinObjekt> ist.
Wie kann ich diese List<MeinObjekt> in eine LinkedList<MeinObjekt> "kopieren"?

Durch die Methode: list=Collections.unmodifiableList(cast(o));
besitze ich ja nur lesezugriff auf die Liste.

 

[redbomber]

Also mir geht es z.B. um folgendes:
Ich möchte die LinkedList<MeinObjekt> von dem Assoziativspeicher in eine ArrayList<LinkedList<MeinObjekt> > kopieren, und ich versteh nicht wieso das nicht geht:

// MultiHashMap<Long,MeinObjekt> wholeObjects

Iterator<Long> it = wholeObjects.keySet().iterator();
while(it.hasNext()){
	long key = it.next();
	LinkedList<MeinObjekt> linkedList = new LinkedList<MeinObjekt>();
				
	List<MeinObjekt> list = new LinkedList<MeinObjekt>();
	list = wholeObjects.get(key);
				
	System.out.println("SIZE OF LIST " + list.size()); // -> SIZE 1
				
	for(int i = 0; i < list.size(); i++){
		System.out.println("MeinObjekt" + list.get(i) + " size " + list.size()); // SIZE 1, aber 2 Objekte sind drin
		linkedList.add((MeinObjekt)list.get(i));
	}
// ArrayList<LinkedList<MeinObjekt>> shortObjects
	shortObjects.add(linkedList);
}

 

[Ebenius]

ABer das muss glaub wie folgt sein:
SuperHashMap<Long, MeinObjekt>

Sieht gut aus.

Wenn ich mir dann für einen Key die LinkedList<MeinObjekt> erhalten möchte habe ich das problem, dass diese immer vom Typ List<MeinObjekt> ist.
Wie kann ich diese List<MeinObjekt> in eine LinkedList<MeinObjekt> "kopieren"?

Die erste Frage ist: Brauchst Du denn wirklich eine LinkedList oder reicht Dir auch der Typ des List-Interface? Wenn Du unbedingt eine LinkedList brauchst, könntest Du die Liste einfach casten, aber das würde Wissen über die Interna der SuperHashMap voraussetzen das Du eigentlich nicht haben darfst. [HIGHLIGHT="Java"]final LinkedList<Long, MeinObjekt> linkedList = (LinkedList<Long, MeinObjekt>)
superHashMap.get(new Long(42));[/HIGHLIGHT]
Was willst Du denn danach mit der Liste machen?

BTW: Die SuperHashMap gefällt mir gar nicht, weil sie die Schnittstelle zu einer List<T, Object> abbildet, sich aber intern darauf verlässt, dass das von außen jeder ignoriert.

// EDIT: Du kannst natürlich die ganzen Listen alle kopieren. [HIGHLIGHT="Java"]new LinkedList<Long, MeinObjekt>(superHashMap.get(new Long(42)));[/HIGHLIGHT]

Ebenius

 

[redbomber]

also ich muss immer nur über die listen iterieren und auf die Objekte darin zugreifen
also keine Änderungen oder so vornehmen

 

[redbomber]

aber wieso meinst du folgendes:

final LinkedList<Long, MeinObjekt> linkedList = (LinkedList<Long, MeinObjekt>)
        superHashMap.get(new Long(42));

muss dass nicht so sein?

final LinkedList<MeinObjekt> linkedList = (LinkedList<MeinObjekt>)
        superHashMap.get(new Long(42));

Ich verstehe folgendes einfach nicht:
Ich möchte von meiner SuperHashMap für einen Key die LinkedList an der entsprechenden Position bekommen

[HIGHLIGHT="Java"]List<MeinObjekt> list = superHashMap.get(key);
LinkedList<MeinObjekt> linkedList = new LinkedList<MeinObjekt>();
linkedList.addAll(list);

for(int i = 0; i < linkedList.size(); i++){
System.out.println("MeinObjekt " + linkedList.get(i) + " size " + linkedList.size());
}[/HIGHLIGHT]

Hier hat meine linkedList immer die Size 1, obwohl sich aber darin z.b. 3 Objekte befinden, also das sehe ich ja am System out.

 

[Ebenius]

muss dass nicht so sein? [...]

Selbstverständlich. Hab gepennt.

Ich verstehe folgendes einfach nicht:
Ich möchte von meiner SuperHashMap für einen Key die LinkedList an der entsprechenden Position bekommen

Dann ist LinkedList die schlechteste Wahl die Du treffen kannst. Nimm eine Listenimplementierung die wahlfreien Zugriff erlaubt: RandomAccess.

Hier hat meine linkedList immer die Size 1, obwohl sich aber darin z.b. 3 Objekte befinden, also das sehe ich ja am System out.

Das verstehe ich auch nicht. Benutz einen Debugger und guck Dir alles genau an. Oder gib dir mal list.size() mit aus. Oder gib gleich list und linkedList aus, da bekommste auch einen vernünftigen String.

Ebenius

 

[redbomber]

Dann ist LinkedList die schlechteste Wahl die Du treffen kannst. Nimm eine Listenimplementierung die wahlfreien Zugriff erlaubt: RandomAccess.

Ne das war ein missverständnis, ich benötige nur sequentiellen Zugriff, also daher nehme ich eine LinkedList

Also ich kann das Problem jetzt wie folgt umgehen:

ArrayList<LinkedList<MeinObjekt> > arrayList = new ArrayList<LinkedList<MeinObjekt> >();

List<MeinObjekt> list = superHashMap.get(key);
LinkedList<MeinObjekt> linkedList = new LinkedList<MeinObjekt>();
if(!list.isEmpty()){
	arrayList.add(linkedList);
}

Nur erscheint mir das "kopieren" zuerst in eine List und dann das hinzufügen der List in die LinkedList als ziemlicher Speicher und Zeitverbrauch.

 

[Ebenius]

Ne das war ein missverständnis, ich benötige nur sequentiellen Zugriff, also daher nehme ich eine LinkedList

In Deinem Quelltext oben greifst Du per Index auf die Liste mit get(int) zu. Wenn das Bestandteil des Missverständnisses ist und es sich nur um Debug-Code handelt, dann ignorier den Hinweis.

Nur erscheint mir das "kopieren" zuerst in eine List und dann das hinzufügen der List in die LinkedList als ziemlicher Speicher und Zeitverbrauch.

Mir auch. Daher die Frage, warum Du unbedingt eine LinkedList benötigst und nicht einfach die List da rein packst. Designfehler in der Schnittstelle oder Denk-/Verständnisproblem?

Ebenius