Java 如何实现`范围（）` 简介

如何在Java 6中编写公共静态范围方法或范围类，以便它至少涵盖在其他编程语言中实现的常见功能

如果你想回答这个问题，那么你可以忽略以下内容

---

关于 一次又一次，我错过了其他语言所拥有的功能。对于我写的任何语言，我都有不同的编码风格，我不愿意改变这种习惯。所以，如果我想重用一个我用另一种语言编写的算法，那么我必须做一些恼人的小改动或变通方法，以覆盖缺失的功能。我想为

range（）

找到永久有效的修复方法

对我来说-

range（）

方法返回输入的范围，可能是以惰性的方式，并且它有默认值。在任何一点上，它都有一个开始、一个结束的条件和一种获取下一个元素的方法。对于每个循环，它应该在中以及在其外部都能完美工作

笔记 我真的不想使用任何外部库，除了谷歌番石榴或类似的。我所说的等效代码是指经过适当测试的代码，它与JDK配合使用非常出色，并且不被认为是不推荐使用的

可能不清楚，因此：

• 通过

  如何编写

  我的意思是-您不必编写它，只需描述常见的陷阱以及推荐方法的优缺点
• 这是循环代码，但也可以使用
• 这不是家庭作业：P

除了整数输入之外，这将是最常用的特性，我真的希望它能够很好地处理BigInteger和Joda DateTime类的类型实例

思想

• 必须能够在

  中为每个
  循环使用

• 通用，但类型安全
• 使用预先存在的容器方法启用，如：.cycle（）、.filter（）、.all（）、.any（）、transform（）等

作为一种方法，

range（）

头可以如下所示：

/**TODO: Think about why / how to add step, limit, offset and cycle detection. */
public static <T extends Comparable<T>> Iterable<T> //
range(T from, Predicate<T> to, Function<T, T> fNext) //
        throws NullPointerException, IllegalArgumentException {

还是懒惰的选择

//eats first element
public static <T extends Comparable<T>> Iterator<T> //
range2(final T from, final Predicate<T> to, final Function<T, T> fNext)
        throws NullPointerException, UnsupportedOperationException {
    Preconditions.checkNotNull(from);
    Preconditions.checkNotNull(to);
    Preconditions.checkNotNull(fNext);
    return new Iterator<T>() {
        T current = from;
        @Override public boolean hasNext() {return to.apply(current);}
        @Override public T next() {return current = Preconditions.checkNotNull(fNext.apply(current));}
        @Override public void remove() {throw new UnsupportedOperationException();}
    };
}

//吃第一个元素
公共静态迭代器//
range2（最终T from、最终谓词to、最终函数fNext）
抛出NullPointerException、UnsupportedOperationException{
先决条件。checkNotNull（来自）；
先决条件。checkNotNull（to）；
先决条件。checkNotNull（fNext）；
返回新的迭代器（）{
T电流=从；
@重写公共布尔hasNext（）{返回到.apply（当前）；}
@重写公共T next（）{return current=premissions.checkNotNull（fNext.apply（current））；}
@重写公共void remove（）{抛出新的UnsupportedOperationException（）；}
};
}

我会选择最近的路径。创建如下界面：

interface Steppable<T>{
    T defaultStep(); //Returns 1 for most number types
    T value(); //Returns the value itself
    Steppable<T> step(T amount); //the stepping logic
}

接口可步进{
T defaultStep（）；//对于大多数数字类型，返回1
T value（）；//返回值本身
可步进（T量）；//步进逻辑
}

为我想在range函数中使用的每种类型（int、long、dates等）编写一整套接口实现。然后为每个可步进类型创建一个重载的

range（）

函数，以便于使用

---

我会选择这种方法，因为它使添加更多的可步进类型变得相当简单。至于缺点，这种方法有些冗长。

难点可能是必须为每种类型编写函数：

  public static Function<Integer, Integer> intIncrementer(final int step) {
    class IntIncrementer implements Function<Integer, Integer> {
      private final int _step = step;

      @Override public Integer apply(Integer i) {
        return i + _step;
      }

      @Override public boolean equals(Object obj) {
        return (obj instanceof IntIncrementer) 
           && ((IntIncrementer) obj)._step == _step;
      }

      @Override public int hashCode() {
        return _step;
      }
    }

    return new IntIncrementer();
  }

---

对于原语，在创建包装器对象时会有开销。与仅对循环使用传统的递增

相比，在大范围内，这可能会大大降低效率。
这并不是您想要的，但它很接近……尽管有您的描述，我发现我正在对您的
范围
中想要的内容进行假设。如果您可以指出一种特定的语言和/或指向您试图模拟的另一种语言/库的
范围
关键字/类/方法/API的文档，这可能会有所帮助。我想不出任何数据结构，它不应该与
方法进行比较，并且是
范围
的主题。我也不明白为什么我必须在第一时间强制执行平等合同。而
的难点在于确保代码正常工作，而不是编写代码。此外，我可以存储
I+\u步骤的默认映射或枚举，但无论如何更改该部分是很常见的，所以我看不出问题。Java没有一个通用的原语选项，我想，我说过我想使用BigInteger，我不在乎这个。
  public static Function<Integer, Integer> intIncrementer(final int step) {
    class IntIncrementer implements Function<Integer, Integer> {
      private final int _step = step;

      @Override public Integer apply(Integer i) {
        return i + _step;
      }

      @Override public boolean equals(Object obj) {
        return (obj instanceof IntIncrementer) 
           && ((IntIncrementer) obj)._step == _step;
      }

      @Override public int hashCode() {
        return _step;
      }
    }

    return new IntIncrementer();
  }

public interface Range<T> extends Iterable<T> {
  // TODO: write the terms of the contract
  @Override public boolean equals(Object obj);
  @Override public int hashCode();
  // TODO: other useful methods?
}