Question

我不禁想知道为什么我不能写那样的东西：

for (int i : 3) {
  System.out.println(i);
}

打印出来：

0
1
2

我的意思是，3可以自动装入Integer，可以是Iterable。我知道，我已经选择了第一个元素0，但我认为这是常见的情况，并且它可以利用这种ForEach构造进行倒计时。

Answer 1

这有点愚蠢，但你可以这样写：

    for (int i : iter(3)) {
        System.out.println(i);  // 0, 1, 2
    }

    for (int i : iter(-5)) {
        System.out.println(i);  // 0, -1, -2, -3, -4
    }

    for (int i : iter(1, 7)) {
        System.out.println(i);  // 1, 2, 3, 4, 5, 6
    }

如果您要静态导入方法：

import static your.package.IterUtil.iter;

来自此自定义类：

public class IterUtil {

    public static Iterable<Integer> iter(int to) {
        return new IntIterable(0, to);
    }

    public static Iterable<Integer> iter(int from, int to) {
        return new IntIterable(from, to);
    }


    private static class IntIterable implements Iterable<Integer> {

        private int start;
        private int end;

        private IntIterable(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public Iterator<Integer> iterator() {
            return new Iterator<Integer>() {
                private int actual = start;

                @Override
                public boolean hasNext() {
                    return actual != end;
                }

                @Override
                public Integer next() {
                    int value = actual;

                    if (actual < end) {
                        actual++;
                    } else if (actual > end) {
                        actual--;
                    }

                    return value;
                }

                @Override
                public void remove() {
                    // do nothing
                }
            };
        }
    }
}

Answer 2

因为数字不是范围。将数字转换为范围是不明确的。没有什么可以阻止你编写可迭代的Range类，例如

public class IntegerRange implements Iterable<Integer> {
  private final int _fromInclusive;
  private final int _toExclusive;

  public IntegerRange(int fromInclusive, int toExclusive) {
    _fromInclusive = fromInclusive;
    _toExclusive = toExclusive;
  }

  public Iterator<Integer> iterator() {
    return new Iterator<Integer>() {
      int c = _fromInclusive;
      public boolean hasNext() {
        return c < _toExclusive;
      }

      public Integer next() {
        if (c >= _toExclusive) {
          throw new NoSuchElementException();
        }
        return c++;
      }

      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }
}

请注意，使用这种方法，您可以轻松添加功能，例如指定增量，范围是否包含在两侧等等。

Answer 3

在for(x : c)语法中，c必须是Iterable; 3不是。你可以做到

    for (int i : new int[]{0,1,2}) {
          System.out.println(i);
     }

Answer 4

迭代对象集合。和Integer是一个单独的Object，没有什么可以迭代的。但是，您可以这样做：

for(int i=0;i<number;i++)

Answer 5

在java中，foreach循环只迭代数组，或者实现Iterable接口的集合，而包装类型Integer则没有。

但是当你想到它时，这是有道理的。什么“对于3中的每个整数，这样做”是什么意思？ 3中有多少个整数？我们从零开始，所以有4个整数（0,1,2,3）？我们从1开始吗？我们必须一个接一个地走吗？

如果你想模仿那种行为，TheOtherGuy的答案会起作用，但一个简单的for循环可能更好。

Answer 6

正如其他人所指出的那样，Java for-each遍历数组或集合。 “3”不是数组或集合，它是单个值。如果Java允许你建议的构造，唯一一致的实现就是“迭代”单个值，即3.

for (int i : 3) {   System.out.println(i); }

会输出：

这似乎没有用，这可能就是他们没有实现的原因。

您的问题假设像“3”这样的单个值意味着范围。但为什么你会假设{0,1,2,3}？为什么不{1,2,3}？或{-3，-2，-1,0,1,2,3}？或{0.5,1.0,1.5,2.0,2.5,3}？或者无数其他可能的变化。

要使其具体化，您必须指定起始值，结束值和增量。嗯，也许我们可以想出这样的符号：

for (int i=0,3,1)

但那仍然含糊不清。目前尚不清楚我们是否要继续直到i == 3，或直到最后一个值<3。我们可能需要区分加号和减号。那么这个更灵活的符号怎么样：

for (int i=0; i<=3; i=i+1)

哦，等等，已经支持了。： - ）

Answer 7

Number具有非整数子类，例如Float和BigDecimal，因此在Number上实现Iterable <Integer>没有意义。有Integer和Long实现Iterable <Integer|Long＆gt;会很好。

为什么java数字不可迭代

7 个答案: