Gibt es eine kurze und süße Möglichkeit, aList<Integer>oder vielleicht einInteger[] oderint[], mit sequentiellen Werten von einigenstart Wert auf einend Wert?

Das heißt, etwas kürzer als, aber äquivalent zu1 folgende:

<code>void List<Integer> makeSequence(int begin, int end) {
  List<Integer> ret = new ArrayList<>(end - begin + 1);
  for (int i=begin; i<=end; i++) {
    ret.add(i);
  }
  return ret;  
}
</code>

Die Verwendung von Guave ist in Ordnung.

Aktualisieren:

Leistungsüberprüfung

Da diese Frage mehrere gute Antworten erhalten hat, sowohl mit nativen Java 8-Bibliotheken als auch mit Bibliotheken von Drittanbietern, dachte ich, ich würde die Leistung aller Lösungen testen.

Der erste Test testet einfach die Erstellung einer Liste mit 10 Elementen[1..10] mit den folgenden Methoden:

classicArrayList: der oben in meiner Frage angegebene Code (und im Wesentlichen derselbe wie die Antwort von adarshr).eclipseCollections: der Code inDonalds Antwort unten mit Eclipse Collections 8.0.guavaRange: der Code inDavebs Antwort unten. Technisch gesehen schafft dies keineList<Integer> sondern einContiguousSet<Integer> - aber da es implementiertIterable<Integer> In Ordnung, es funktioniert meistens für meine Zwecke.intStreamRange: der Code inDie Antwort von Vladimir unten, welche verwendetIntStream.rangeClosed() - die in Java 8 eingeführt wurde.streamIterate: der Code inCatalins Antwort unterhalb derer auch verwendetIntStream Funktionalität in Java 8 eingeführt.

Hier sind die Ergebnisse in Kilooperationen pro Sekunde (höhere Zahlen sind besser) für alle oben genannten mit Listen der Größe 10:

... und nochmal für Listen der Größe 10.000:

Das letzte Diagramm ist richtig - die Lösungen mit Ausnahme von Eclipse und Guava sind zu langsam, um auch nur einen Pixelbalken zu erhalten! Die schnellen Lösungen sind 10.000 bis 20.000mal schneller als der Rest.

Was hier natürlich vor sich geht, ist, dass die Guaven- und Eclipse-Lösungen keinerlei 10.000-Elemente-Listen enthalten - sie sind einfach Wrapper mit fester Größe um den Start- und Endpunkt. Jedes Element wird bei Bedarf während der Iteration erstellt. Da wir in diesem Test nicht iterieren, werden die Kosten zurückgestellt. Alle anderen Lösungen verwirklichen die gesamte Liste im Speicher und zahlen einen hohen Preis in einem Benchmark nur für die Erstellung.

Lassen Sie uns etwas Realistischeres tun und alle ganzen Zahlen durchlaufen und sie summieren. Also im Fall derIntStream.rangeClosed Variante sieht der Benchmark so aus:

<code>@Benchmark
public int intStreamRange() {
    List<Integer> ret = IntStream.rangeClosed(begin, end).boxed().collect(Collectors.toList());  

    int total = 0;
    for (int i : ret) {
        total += i;
    }
    return total;  
}
</code>

Hier ändern sich die Bilder sehr, obwohl die nicht materialisierenden Lösungen immer noch die schnellsten sind. Hier ist Länge = 10:

... und Länge = 10.000:

Die lange Iteration über viele Elemente gleicht vieles aus, aber Finsternis und Guave bleiben auch beim 10.000-Elemente-Test mehr als doppelt so schnell.

Also wenn duJa wirklich will einList<Integer>, Eclipse-Sammlungen scheinen die beste Wahl zu sein - aber natürlich, wenn Sie Streams nativer verwenden (z. B. vergessen).boxed() Wenn Sie den primitiven Bereich verkleinern, werden Sie wahrscheinlich schneller als alle diese Varianten sein.

1 Vielleicht mit Ausnahme der Fehlerbehandlung, zend < beginoder wenn die Größe einige Implementierungs- oder JVM-Grenzen überschreitet (z. B. Arrays größer als2^31-1.