Java：相当于Python'；s范围（int，int）？

Java是否有一个与Python的

范围（int，int）

方法等价的方法？

public int[]范围（int start，int length）{
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;
}

int[]范围=新的int[长度-开始+1]；
对于（int i=start；i
public int[]范围（int start，int stop）
{
int[]结果=新int[停止-启动]；
for（int i=0；i如果你想像在Python循环中一样使用它，Java会很好地使用for语句，这使得这个结构不需要用于这个目的。
我正在开发一个名为的Java utils库，它包含一个类
范围
，它提供了你需要的功能（有一个可下载的JAR）。

构造函数要么是
Range（int-stop）
，
Range（int-start，int-stop）
，要么是
Range（int-start，int-stop，int-step）
（类似于for循环），您可以使用惰性计算对其进行迭代，也可以使用其
toList（）
方法显式获取范围列表

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]

还提供类似于Python的
范围的内容：

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

您还可以使用Guava的AbstractIterator实现一个相当简单的迭代器来完成同样的事情：

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

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

返回新的AbstractIterator（）{
int next=getStart（）；
@重写受保护的整数computeNext（）{
如果（IsBeyondnd（下一个））{
返回endOfData（）；
}
整数结果=下一个；
next=next+getStep（）；
返回结果；
}
};
Groovy的漂亮功能可以从Java中使用，尽管它肯定不如Groovy。
自Guava 15.0以来，已被弃用，并计划在版本16中删除。请改用以下功能：

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

“Functional Java”库允许以这种方式编程到有限的程度，它有一个range（）方法创建一个fj.data.Array实例

见：




类似地，“完全惰性”库提供了惰性范围方法：
旧问题，新答案（适用于Java 8）

或使用方法引用：

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

可以使用以下代码段来获取整数的范围集：

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

Set iset=IntStream.rangeClosed（1,5）.boxed（）.collect
（toSet（））；
Java 9-
由于Java 9，您可以使用
IntStream:：iterate
，甚至可以自定义步骤。例如，如果您想要
int
数组：

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

然后使用它：

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

IntStream.range（0,10）.boxed（）.collect（Collectors.toUnmodifiableList（））；
我知道这是一篇老文章，但如果您正在寻找一个返回对象流且不想或不能使用任何其他依赖项的解决方案：

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

开始-包括
停止-独占
Java 8

private static int[] range(int start, int stop, int step) {
    int[] result = new int[(stop-start)%step == 0 ? (stop-start)/step : (stop-start)/step+1];
    int count = 0;
    Function<Integer, Boolean> condition = step > 0 ? (x) -> x < stop : (x) -> x > stop;
    for (int i = start; condition.apply(i); i += step) {
        result[count] = i;
        count++;
    }
    return result;
}

private static int[]范围（int start、int stop、int step）{
int[]结果=新int[（停止-开始）%step==0？（停止-开始）/步骤：（停止-开始）/步骤+1]；
整数计数=0；
功能条件=步骤>0？（x）->x<停止：（x）->x>停止；
for（int i=开始；condition.apply（i）；i+=步骤）{
结果[计数]=i；
计数++；
}
返回结果；
}
在python中，你通常也不会在循环中使用它。几乎总是有一种更干净的迭代方式。在for循环中通常使用范围。但是for循环通常不使用范围。既然Vivien Barousse给了你一个答案，为什么你不删除你的循环以避免任何重复。当然，除非你真的打算很好地充实它。下面是你也一样；我认为我的更具可读性。他对“长度”的使用有误导性，我认为他不符合Python规范（他包括上限，这表示在Python中不会发生）.如果你认为自己是个傻瓜，我相信你有足够的声誉自己来处理它。你是指返回列表的Python 2.x范围，还是返回迭代器的Python 3.x范围（相当于2.x xrange）？前者的实现相对简单，正如下面其他人所做的那样，但迭代器版本有点棘手。对于任何
可比的
s范围，请参见Answer。对于带步进的范围，请参见，请参见python 3中的“范围”，python 2中首选的“xrange”返回“活动”对象，该对象不会为其包含的每个项占用内存。在Java中实现它会更大。我希望在实现自己的通用范围之前看到这一点。这很好，但仍然提醒我们，与更多函数式语言相比，Java有多笨重。
range\asSet
似乎已经不受欢迎了。您现在可以需要这样做：
contiguusset.create（Range.closed（low，high），DiscreteDomain.integers（））
我需要导入什么库才能使用它？从Java 8中，IntStream和LongStream有Range和rangeClosed方法。什么包？我如何导入它？@Justin这是Java 8语言的特性。第一个示例可能是：
IntStream.Range（0,10）.forEach（n->System.out.println（n））
如果你解释一下这段代码是如何解决问题的，那会很有帮助。欢迎来到StackOverflow。虽然这段代码可能会解决这个问题，但这段代码如何以及为什么解决这个问题会真正有助于提高你的文章的质量，并可能导致更多的投票。记住，你是在将来为读者回答这个问题，而不是j请立即回答问题。请在回答中添加解释，并说明适用的限制和假设。
int[] range = getInRange(0, 10, 1);

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

private static int[] range(int start, int stop, int step) {
    int[] result = new int[(stop-start)%step == 0 ? (stop-start)/step : (stop-start)/step+1];
    int count = 0;
    Function<Integer, Boolean> condition = step > 0 ? (x) -> x < stop : (x) -> x > stop;
    for (int i = start; condition.apply(i); i += step) {
        result[count] = i;
        count++;
    }
    return result;
}