Wie reformiere ich diese Schleife?

Question

Ich habe eine Anwendung, wo ich primitive Arrays und Listen für eine Klasse namens Artikel verwenden. Diese werden aus Legacy-Gründen austauschbar verwendet (ich wünschte auch, das wäre nur ein Typ, aber so ist es).

Jetzt habe ich eine neue Methode wie folgt hinzufügen, die über eine für-jede Schleife funktioniert:

public void something(Item... items) { 
    for (Item i : items) { 
     doStuff(); 
    } 
} 

public void something(List<Item> items) { 
    for (Item i : items) { 
     doStuff(); 
    } 
} 

Mit anderen Worten, genau die gleiche Methode zweimal für beide primitive Arrays und Listen. Gibt es eine Möglichkeit, dies in eine einzige Methode umzuwandeln?

Answer 1

Sie kann nicht sollte nicht (*) dies in einer einzigen Methode tun. Item[] und List<Item> sind nicht verwandte Typen.

sollten Sie zu einem der Überlastung des anderen rufen: entweder something(Item... items) Anrufe something(List<Item>) oder something(List<Item>) Anrufe something(Item... items).

Von den beiden Optionen ist es besser, für das Array die Liste Überlastung zu nennen Überlastung:

public void something(Item... items) { 
    something(Arrays.asList(item)); 
} 

Das ist billig, weil es nicht das Array kopiert, sondern wickelt es: die Schaffung der List ist O(1).

Wenn Sie waren die Array-Überlastung aus der Liste Überlastung aufzurufen:

public void something(List<Item> items) { 
    something(items.toArray(new Item[0])); 
} 

Diese teurer sein würde, da der toArray Aufruf erstellen hat und ein Array zu füllen: es ist ein O(n) Betrieb, wo n ist die Größe der Liste. Es hat jedoch den leichten Vorteil, dass something den Inhalt von List nicht ersetzen kann, da alle Aktualisierungen des Arrays nach der Ausführung einfach verworfen werden.

---

(*) Sie können , aber es wäre wirklich gross sein, und nicht typsicher, wie Sie einen Object Parameter akzeptieren müssten, da es keine anderen gemeinsamen Supertyp List<Item> ist und Item[]; und du würdest immer noch die Schleifen für die zwei Typen wiederholen müssen; und Sie müssten mit der Möglichkeit umgehen, dass ein völlig unzusammenhängender Typ (zur Laufzeit) übergeben wird:

public void something(Object obj) { 
    if (obj instanceof List) { 
    for (Object element : (List<?>) obj) { 
     Item item = (Item) element; // Potential ClassCastException. 
     doStuff(); 
    } 
    } else if (obj instanceof Item[]) { 
    for (Item item : (Item[]) obj) { 
     doStuff(); 
    } 
    } else { 
    throw new IllegalArgumentException(); 
    } 
} 

Was für ein Durcheinander. Danke dem Hersteller für Überladungen.

Answer 2

Sie sollten dies erreichen, indem Sie List nach dem Konvertieren in Array übergeben.

Bewahren Sie diese als einzige Methode,

public void something(Item... items) { 
    for (Item i : items) { 
     doStuff(); 
    } 
} 

und wenn Sie ein List<Item> dann passieren, wie dies passieren wollen,

something(listItem.toArray(new Item[listItem.size()]))

Answer 3

Sie können eine einzelne Methode implementieren, in diesem Fall , die zweite, weil sie eine Liste als Parameter hat.Anstelle der ersten Methode können Sie das Array in einer Liste mit Arrays.asList(items) konvertieren und dann können Sie die erste Methode aufrufen. Am Ende haben Sie nur eine einzige Methode (die eine Liste als Parameter hat).

Auch wenn die Artikel Liste wenige Elemente hat, können Sie die Lambda-Ausdrücke aus Java 8 verwenden:

items.foreach(item -> doStuff(item)); 

Also, werden Sie nicht eine Methode, die nur eine Schleife und der Code enthält, wird leichter sein, lesen.

Answer 4

Wenn Sie Java 8 verwenden, können Sie auch einfach forEach oder map auf Ihrem Stream anrufen, und Sie sind fertig, z.

yourStream.forEach(doStuff()); 

wo doStuff() ist die consumer mit dem String zu tun oder yourStream.forEach(s -> doStuff()) verwenden, wenn Sie möchten die Zeichenfolge nicht handhaben und nur do stuff.

Sie können einen Strom erhalten wie folgt:

Stream.of(yourArray) // or Arrays.stream(yourArray) 
     .forEach(doStuff()); 

und für die Liste:

list.stream() 
    .forEach(doStuff()); 

Der Hauptvorteil der Ströme verwendet, ist wahrscheinlich die Lesbarkeit. Es kann in Bezug auf die Leistung verlieren und es kann auch verlieren, wenn Sie nicht Stream.of/Arrays.stream oder Collection.stream() aufrufen möchten, nur um den Stream zu erhalten.

Wenn Sie wirklich behalten wollen die something(...) Methode (sowohl mit der Lage zu befassen: die varargs und die Liste) Sie noch eine überladene Methode oder verwenden Andy Turner's proposal mit dem Object -parameter-Verfahren erfordern.