Collection vs. LinkedList, Abstrakt vs. Konkret

[chaosbringer]

Hallo,
gibt es eine Daumenregel o.ä., welchen Typen ich für meine Referenzen benutze?

Zum Beispiel benutze ich in meiner Klasse eine LinkedList, sollte die Referenz dann auch vom Typen LinkedList sein, oder sollte man lieber einen abstrakteren Typen nehmen, also z.B. List und den Rest der späten Bindung überlassen.

Gibt es da eine Empfehlung?

Danke.

 

[byte]

Als Referenztyp immer das Interface nehmen (List, Set, Map, ...). Der konkrete Objekttyp variiert dann je nach Einsatzgebiet (siehe Pros/Cons der einzelnen Implementierungen in der Javadoc).

 

[chaosbringer]

Hi,
dass hatte ich bisher auch so gehandhabt. Das Problem ist nur, dass ich z.B. auf das erste element meiner List zugreifen möchte, und da wäre zum Beispiel getFirst() von LinkedList deutlisch besser, als get(0) von List.
Die Frage ist, was nun?
Caste ich einfach vor dem Aufruf von getFirst(), oder deklariere ich die Liste von Vornherein als LinkedList?

MfG,
chaosbringer

 

[SlaterB]

Cast ist Quatsch, wenn du dein Programm davon abhängig machst, dass LinkedList drinsteht,
dann muss auch die Variable LinkedList sein, alles andere wäre Verschleierung,

er stellt sich nur die Frage, ob du wirklich getFirst() brauchst

 

[chaosbringer]

Mhm, naja, ich muss leider auch auf as letzte Element der Liste zugreifen, und da bringt ein getLast() schon deutlich mehr Performance als ein get( list.size()-1 );
Mhm, irgendwie blöd. Bin mit beiden Lösungen nicht glücklich. ArrayList geht leider auch nicht, weil ich viele add's in bestimmte Listenpositionen mache, und das wohl auch zuviel Laufzeit kosten würde.

MfG,
chaosbringer

 

[maki]

Dann brauchst du wohl ganz konkret LinkedList

Die regel für die Interfaces anstatt Implementierungen funktioniert natürlich nur, wenn die interfaces alles gewünschte zur Verfügung stellen.

 

[SlaterB]

Notlösung wäre evtl. noch

List l = new LinkedList();
l.add("a");
l.add("b");
System.out.println(l.listIterator(l.size()).previous());
l = new ArrayList();
l.add("a");
l.add("b");
System.out.println(l.listIterator(l.size()).previous());

bei LinkedList wird bei hohem Index rückwärts gelaufen (wieso nicht auch bei get()?..)

aber schön kann man das auch nicht nennen

edit: halt, bei get() passiert das auch, get( list.size()-1 ); sollte dann auch schnell gehen,
hat wohl mal wieder niemand ausprobiert
oder meinst du wirklich, dass das immer noch zu langsam ist?
wenn von Position 0 aus alle Elemente durchlaufen werden müssten, könnte ich das ja verstehen

 

[Illuvatar]

Sourcecode von LinkedList:
[HIGHLIGHT="Java"]
public E get(int index) {
return entry(index).element;
}
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
if (index < (size >> 1)) { // Anmerkung: (size >> 1) ist (size / 2) (sollte sowas der Compiler nicht automatisch optimieren?)
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
public E getFirst() {
if (size==0)
throw new NoSuchElementException();

return header.next.element;
}
[/HIGHLIGHT]

get( list.size()-1 ) ist also im Endeffekt gleichschnell wie getFirst - ok, es gibt vielleicht einen minimalsten Unterschied aber darauf kommt es wirklich nicht an.

Edit: Args, es geht natürlich um getLast :autsch: Aber das ist ja exakt das gleiche, nur mit header.previous

 

[chaosbringer]

Also, um es zusammenfassen:
Sowohl getLast() als auch get( list.size()-1 ) habe für LinkedList konstante Laufzeit?

Mfg,
chaosbringer

 

[0x7F800000]

Bei der LinkedList: ja.
Bei einer allgemeinen Liste muss das nicht möglich sein, jemand kann ja auch eine enfachverkettete übergeben, dann wirds extrem lahm.

Wenn du eigentlich nur eine List ausgeben willst, aber deine methode beispielsweise rekursiv ist, und intern mit LinkedLists arbeiten will, dann könntest du die rekursiv aufgerufene methode private machen, und nach außen einen wrapper der methode bereitstellen, der lediglich Rückgabe einer allgemeinen List garantiert, und die rekursive variante startet. Das mag sich seltsam anhören, aber so versprichst du nicht zu viel, und am Interface ändert sich nichts, wenn du dich später doch noch für eine Implementierung mit ArrayList entscheidest.