Kürzeste präzise lesbare Syntax über mehrere aufeinander folgende Zahlen aus gegebenen Bereich

Question

In groovy iterieren ich durch Zahlen mit, dass einfache Syntax laufen kann:

(1..10).each { 
    do_domething it 
} 

Was die kürzeste Syntax, dass in Java zu tun ist? Ich bin jetzt Ströme zu erforschen und ich kam mit einer solchen Idee:

IntStream.range(0, 10) 
     .forEach(do_domething()); 

Es ist sogar länger als die traditionelle Art und Weise (siehe unten), scheint aber prägnanter zu sein.

for (int i = 0; i < 10; i++) 
    do_domething() 

Ich bin nur neugierig, ob es kürzere und lesbare Art und Weise ist, es zu tun. Ich weiß nicht alles über Java, also frage ich nur, wahrscheinlich gibt es so etwas nicht, aber ich möchte sichergehen.

Answer 1

Wenn Sie IntStream.range wiederholt in einer Klasse verwenden müssen, können Sie Ausführlichkeit unter Verwendung eines statischen Import reduzieren:

import static java.util.stream.IntStream.range; 

Dann wird die Syntax wird

range(0, 10).forEach(...) 

Darüber hinaus, gibt es nicht viel anderes Ich kann vorschlagen. Aus meiner Sicht ist es ist ein bisschen lächerlich, dass wir for(int i = 0; i < n; i++) wiederholt schreiben müssen, aber zumindest hat es den Vorteil, sofort erkennbar zu sein.

Answer 2

Es gibt einige große Unterschiede zwischen diesen beiden, die nicht dazu führen, dass sie sich gegenseitig ersetzen.

Eine Rückgabe von einer regulären for-Schleife wird von Ihrer Methode zurückgegeben, aber für die Stream/Lambda-Version wird von der Lambda-Funktion zurückgegeben. Siehe unten.

for (int i = 0; i < 10; i++) { 
     if (i == 5) { 
      return;//returns from the whole method 
     } 
    } 

    IntStream.range(0, 10).forEach((i -> { 
     if (i == 5) { 
      return; //returns only from the lambda 
     } 
    })); 

Ein weiterer wichtiger Unterschied ist, wie die beiden Codeblöcke mit Variablen interagieren. Damit Lambdas mit Variablen interagieren können, die außerhalb unseres Gültigkeitsbereichs liegen, müssen sie endgültig sein. Daher wird der Stream/Lambda-Code nicht kompiliert.

String x = ""; 

    for (int i = 0; i < 10; i++) { 
     if (i == 5) { 
      x = "5"; 
     } 
    } 

    IntStream.range(0, 10).forEach((i -> { 
     if (i == 5) { 
      x = "5"; //wont compile 
     } 
    })); 

Es könnte weitere Unterschiede zwischen den beiden geben. Aber für mich hat diese letzte Probleme verursacht, die dazu geführt haben, dass ich weiterhin die normale For-Schleife benutze.

Answer 3

Sie könnten eine Hilfsfunktion erstellen ein Array erstellen

public static int[] range(final int length){ 
    return IntStream.range(0, length).toArray(); 
} 

Dann eine foreach-Schleife alles, was Sie schreiben müssen, ist:

for(int i : range(10)) { 
    do_domething(); 
} 

Answer 4

Sie verwenden können, die so genannte „Facetious Pfeil "operator (es sieht aus wie ein Pfeil" -> "), um die Schleife etwas kürzer zu schreiben.[Pro Tipp: Es ist nicht wirklich ein Pfeil]

for (int i=10;i-->0;)doSomething(); 

Zum Beispiel:

for (int i=10;i-->0;)System.out.println(i); 

Drucke:

9 
8 
7 
6 
5 
4 
3 
2 
1 
0 

Answer 5

Wenn Sie prägnante wollen Sie eine Hilfsmethode verwenden können.

public static void each(int start, int end, IntConsumer consumer) { 
    IntStream.range(start, end).forEach(consumer); 
} 

und dann können Sie

import static java.lang.System.out; 

each(0, 10, out::println); 

schreiben Wenn "jeder" ist ein bisschen ausführlicher könnte man einen connector Charakter wie

public static void ⁀(int start, int end, IntConsumer consumer) { 
    IntStream.range(start, end).forEach(consumer); 
} 

public static void main(String... args) { 
    ⁀(0, 10, out::println); 
} 

Drucke verwenden

0 
1 
2 
3 
4 
5 
6 
7 
8 
9