Hat Java eine Entsprechung zu Pythons range(int, int)Methode?

Guave bietet auch etwas Ähnliches wie Python range:

Range.closed(1, 5).asSet(DiscreteDomains.integers());

Sie können auch einen ziemlich einfachen Iterator implementieren, um dasselbe mit Guavas AbstractIterator zu tun:

return new AbstractIterator<Integer>() {
  int next = getStart();

  @Override protected Integer computeNext() {
    if (isBeyondEnd(next)) {
      return endOfData();
    }
    Integer result = next;
    next = next + getStep();
    return result;
  }
};

Alte Frage, neue Antwort (für Java 8)

    IntStream.range(0, 10).forEach(
        n -> {
            System.out.println(n);
        }
    );

oder mit Methodenreferenzen:

IntStream.range(0, 10).forEach(System.out::println);

Seit Guava 15.0 ist Range.asSet () veraltet und soll in Version 16 entfernt werden. Verwenden Sie stattdessen Folgendes:

ContiguousSet.create(Range.closed(1, 5), DiscreteDomain.integers());

Ich arbeite an einer kleinen Java-Utils-Bibliothek namens Jools , die eine Klasse enthält, Rangedie die von Ihnen benötigte Funktionalität bietet (es gibt eine herunterladbare JAR).
Konstruktoren sind entweder Range(int stop), Range(int start, int stop)oder Range(int start, int stop, int step)(ähnlich einer for-Schleife), und Sie können sie entweder durchlaufen, wobei eine verzögerte Auswertung verwendet wurde, oder Sie können ihre toList()Methode verwenden, um die Bereichsliste explizit abzurufen.

for (int i : new Range(10)) {...} // i = 0,1,2,3,4,5,6,7,8,9

for (int i : new Range(4,10)) {...} // i = 4,5,6,7,8,9

for (int i : new Range(0,10,2)) {...} // i = 0,2,4,6,8

Range range = new Range(0,10,2);
range.toList(); // [0,2,4,6,8]

public int[] range(int start, int stop)
{
   int[] result = new int[stop-start];

   for(int i=0;i<stop-start;i++)
      result[i] = start+i;

   return result;
}

Verzeihen Sie Syntax- oder Stilfehler. Normalerweise programmiere ich in C #.

Sie können das folgende Codefragment verwenden, um einen Bereichssatz von Ganzzahlen abzurufen:

    Set<Integer> iset = IntStream.rangeClosed(1, 5).boxed().collect
            (Collectors.toSet());

public int[] range(int start, int length) {
    int[] range = new int[length - start + 1];
    for (int i = start; i <= length; i++) {
        range[i - start] = i;
    }
    return range;
}

(Lange Antwort, nur um "Nein" zu sagen)

Java 9 - IntStream::iterate

Seit Java 9 können IntStream::iterateSie den Schritt verwenden und sogar anpassen. Zum Beispiel, wenn Sie intArray wollen :

public static int[] getInRange(final int min, final int max, final int step) {
    return IntStream.iterate(min, i -> i < max, i -> i + step)
            .toArray();
}

oder List:

public static List<Integer> getInRange(final int min, final int max, final int step) {
    return IntStream.iterate(min, i -> i < max, i -> i + step)
            .boxed()
            .collect(Collectors.toList());
}

Und dann benutze es:

int[] range = getInRange(0, 10, 1);

Groovys raffinierte Range-Klasse kann von Java aus verwendet werden, obwohl sie sicherlich nicht so groovig ist.

Die Bibliothek "Functional Java" ermöglicht ein begrenztes Programmieren. Sie verfügt über eine range () -Methode, mit der eine fj.data.Array-Instanz erstellt wird.

Sehen:

• http://functionaljava.googlecode.com/svn/artifacts/3.0/javadoc/fj/data/Array.html#range%28int,%20int%29

In ähnlicher Weise bietet die Bibliothek "Totally Lazy" eine Lazy Range-Methode: http://code.google.com/p/totallylazy/

Wenn Sie es wie in einer Python-Schleife verwenden möchten, führt Java eine gute Schleife mit der for-Anweisung durch, wodurch diese Struktur für diesen Zweck unnötig wird.

IntStream.range(0, 10).boxed().collect(Collectors.toUnmodifiableList());

Ich weiß, dass dies ein alter Beitrag ist, aber wenn Sie nach einer Lösung suchen, die einen Objektstrom zurückgibt und keine zusätzlichen Abhängigkeiten verwenden möchte oder kann:

Stream.iterate(start, n -> n + 1).limit(stop);

Start - inklusive Stopp - exklusiv