Array in List

Ich werfe einfach mal Quellcode (Prototyp) in die Runde:


    LinkedList<String[]> llsa = new LinkedList<>();

    void addSorted(String[][] data) {
        if (data == null || data.length == 0) {
            return;
        }
        Arrays.sort(data, (String[] o1, String[] o2) -> {
            if (o1 == null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return +1;
                }
            } else if (o2 == null) {
                return -1;
            } else {
                return o2.length - o1.length; // beide nicht < 0 :-)
            }
        });
        int i = 0, j = 0;
        while (i < data.length) {
            if (data** == null /* || data**.length == 0 */) {
                return;
            }
            while (j < llsa.size() && data**.length <= llsa.get(j).length) {
                j++;
            }
            llsa.add(j, data**);
            i++;
        }
    }

    public static void main(String[] args) {
        AnArrayAndAList aaaal = new AnArrayAndAList();
        aaaal.addSorted(null);
        aaaal.addSorted(new String[][]{});
        aaaal.addSorted(new String[][]{{}});
        aaaal.addSorted(new String[][]{null, {"sehr"}, {"kreativ", "sein"}, {"ist"}, {"das", "nicht", "immer"}, null});
        aaaal.addSorted(new String[][]{{"hallo"}});
        aaaal.addSorted(new String[][]{{"lang"}, {"wei"}, {}, {"lig"}});
        aaaal.llsa.stream().forEach((strings) -> {
            System.out.println(Arrays.toString(strings));
        });
    }
}```


Ausgabe (weiterlesen):
[spoiler]

[das, nicht, immer]
[kreativ, sein]
[sehr]
[ist]
[hallo]
[lang]
[wei]
[lig]
[]
[]

[/spoiler]

Was macht es?:
- llsa ist absteigend nach der Länge der Elem. sortiert,
- data soll sortiert in llsa eingefügt werden,
- data ist nicht sortiert,
- data kann null und leere Elem. enthalten.

Frage: Kann nach `llsa.get(j)` mit `llsa.add(j, data**);` in O (1) eingefügt werden, da/weil sich LinkedList intern den letzten Zugriff merkt?

Wenn nicht, funktionierte ein Iterator? Wenn nicht, welche DS stattdessen benutzen?

Ich kann mich jetzt lange Zeit nicht mehr melden, freue und bedanke mich aber trotzdem re herzlich über jede Antwort/Hinweis!! :)

Edit: Mit Streams usw. soll es Java 8-konform sein. ;)

(Edit 2: `: - )` in ````....````-Tags mag er nicht!!)

Kleine Anmerkung bezüglich der erwähnten “Streamkonformität”
Aus

            System.out.println(Arrays.toString(strings));
        });```

kann man 

```aaaal.llsa.stream().map(Arrays::toString).forEach(System.out::println);``` machen. Gibt sich letztendlich nicht viel, aber wenn man schon auf Java8 hinweißt ;)

[quote=CyborgBeta]Frage: Kann nach llsa.get(j) mit llsa.add(j, data**); in O (1) eingefügt werden, da/weil sich LinkedList intern den letzten Zugriff merkt?[/quote]Die Zugriffszeit weiß ich jetzt nicht auswendig, aber LinkedList merkt sich den letzten Zugriff nicht. Ein add(j, elem) läuft damit auf das erneute Durchiterieren durch die Liste hinaus, außer im Spezialfall, dass j == size ist.

[quote=CyborgBeta;139894]Wenn nicht, funktionierte ein Iterator?[/Quote]Nein, mit Iterator kann man nur removen. ListIterator wäre die richtige Wahl und damit spart man tatsächlich -wie von Dir gewünscht- die extra Iteration.

[quote=CyborgBeta;139894]Wenn nicht, welche DS stattdessen benutzen?[/Quote]ArrayList mit unsortiertem adden. Erst, wenn alle Elemente geaddet sind, Collections.sort mit passendem Comparator.