verkettete Listen oder Arrays + Indexlisten effizienter?

[luma2]

Welche Version ist effizienter:

1)

// two arrays of the same length:
FirstClass[] firstClassArray = ...;
OtherClass[] otherClassArray = ...;

// index lists with complementary indices:
LinkedList<Integer> indices1 = ...;  // 0,1,4,6,7,9,12,...
LinkedList<Integer> indices2 = ...;  // 2,3,5,8,10,11,...

Iterator<Integer> indexIterator1 = indices1.descendingIterator();
while (indexIterator1.hasNext()) {
  int i = indexIterator1.next();
  FirstClass fc = firstClassArray[i];
  OtherClass oc = otherClassArray[i];
  ...
}

Iterator<Integer> indexIterator2 = indices2.descendingIterator();
// iterate over indexIterator2 in the same way

2)

// two lists of the same length:
LinkedList<FirstClass> firstClassList1 = ...;
LinkedList<OtherClass> otherClassList1 = ...;

// two lists of the same length:
LinkedList<FirstClass> firstClassList2 = ...;
LinkedList<OtherClass> otherClassList2 = ...;

Iterator<FirstClass> firstIterator1 = firstClassList1.descendingIterator();
Iterator<OtherClass> otherIterator1 = otherClassList1.descendingIterator();
while (firstIterator1.hasNext() && otherIterator1.hasNext()) {
  FirstClass fc = firstIterator1.next();
  OtherClass oc = otherIterator1.next();
  ...
}

Iterator<FirstClass> firstIterator2 = firstClassList2.descendingIterator();
Iterator<OtherClass> otherIterator2 = otherClassList2.descendingIterator();
// iterate over firstIterator2 and otherIterator2 in the same way

Brauche hier eine möglichst effiziente Lösung. Und noch ein paar Fragen:
- Sollte man besser die Indexlisten in (1) bzw. alle Listen in (2) umgedreht anlegen und list.iterator() verwenden?
- Wie funktioniert eine for-Schleife über eine LinkedList? Ist das effizienter als einen Iterator anzulegen, oder wird da sowieso implizit ein Iterator angelegt?

danke,
Luma

 

[Landei]

Die beiden Varianten werden sich wohl kaum etwas nehmen. Warum verwendest du die veraltete Schreibwiese und nicht...

for(Integer i : indices1) {
  FirstClass fc = firstClassArray[i];
  OtherClass oc = otherClassArray[i];
  ...
}
...

? Der Compiler macht daraus ziemlich genau dasselbe.

Einen winzigen Tick schneller könnte es werden, wenn du statt der LinkedList<Integer> eine Datenstruktur verwendest, die dir das Boxing/Unboxing der ints spart (etwa GNU Trove).

 

[luma2]

ok wenn man vorwärts durchläuft, dann natürlich eine for-Schleife. Fürs rückwärts durchlaufen gibts ja soviel ich weiß keine solche Kurzschreibweise. Werd wahrscheinlich die Indexliste umgekehrt anlegen mit addFirst() statt add(), dann kann ich vorwärts durchlaufen.

 

[maki]

Der ListIterator kann auch previous() 😉