Java 过滤掉a"；中的元素列表；“懒惰”；方式

我有一个对象列表，我想创建另一个列表，其中只包括方法

acceptable（）

返回“true”的对象。我的问题是，我只想按需进行选择。换句话说，我只希望在调用其

iterator（）

方法时计算并填充一个新列表。Java中是否有用于此的库

---

我使用的是JDK7，您可以使用Java 8流：

List<YourClass> list = ...;

Stream<YourClass> filteredList = list.filter(YourClass::acceptable());

List=。。。；
Stream filteredList=list.filter（YourClass:：acceptable（））；

---

现在，只有在流上运行终端操作时，它才会使用源列表并找到通过过滤器的元素。

我不知道是否有库可以实现这一点，但您可以制作某种列表包装器，其功能如下：

public class ResolveList<T extends MyClass> implements Iterable<T> {
//T extends MyClass for access to MyClass.acceptable()
    private final List<T> rawList;
    private List<T> processedList;
    public List<T> getList() {
        if(processedList == null) {
            processList();
        }
        return processedList; //check if null
    }

    public ResolveList(List<T> list) {
        this.rawList = list;
    }

    private void processList() {
        processedList = new ArrayList<T>(); //or whatever kind of list you prefer.
        for(T t : rawList) {
            if(t.acceptable()) {
                processedList.add(t);
            }
        }
    }

    @Override
    public Iterator<T> iterator() {
        return this.getList().iterator();
    }
}

公共类ResolveList实现了Iterable{
//T扩展MyClass以访问MyClass.acceptable（）
私人最终名单；
私有列表处理列表；
公共列表getList（）{
if（processedList==null）{
processList（）；
}
return processedList；//检查是否为null
}
公共解决方案列表（列表）{
this.rawList=list；
}
私有void进程列表（）{
processedList=new ArrayList（）；//或您喜欢的任何类型的列表。
for（T:rawList）{
如果（t.可接受（））{
processedList.add（t）；
}
}
}
@凌驾
公共迭代器迭代器（）{
返回此.getList（）.iterator（）；
}
}

您可以使用内置迭代器或获取列表本身。

---

或者，您可以删除

getList（）

函数，自己实现

List

接口。

不知道是否有用于此的库，但这是一项简单的任务。这是一个懒散的迭代器：

public class LazyIterator<E extends Acceptable> implements Iterator<E> {
    private final Iterator<E> iterator;
    private boolean hasNext;
    private E next;

    public LazyIterator(Iterator<E> iterator) {
        this.iterator = iterator;
        iterate();
    }

    private void iterate() {
        hasNext = false;
        while (iterator.hasNext()) {
            next = iterator.next();
            if (next.accept()) {
                hasNext = true;
                break;
            }
        }
    }

    @Override public boolean hasNext() { return hasNext; }

    @Override public E next() {
        if (!hasNext) throw new NoSuchElementException();
        E out = next;
        iterate();
        return out;
    }

    @Override public void remove() { throw new RuntimeException("N/A"); }
}

公共类LazyIterator实现迭代器{
私有最终迭代器；
私有布尔hasneat；
下一步是私人股本；
公共懒散迭代器（迭代器迭代器）{
this.iterator=迭代器；
迭代（）；
}
私有void iterate（）{
hasNext=false；
while（iterator.hasNext（））{
next=迭代器.next（）；
if（next.accept（））{
hasNext=true；
打破
}
}
}
@重写公共布尔值hasNext（）{return hasNext；}
@覆盖公共E next（）{
如果（！hasNext）抛出新的NoSuchElementException（）；
E out=下一个；
迭代（）；
返回；
}
@重写public void remove（）{throw new RuntimeException（“N/A”）；}
}

这就是那个懒散的包装

public class LazyIterable<E extends Acceptable> implements Iterable<E> {

    private final Iterable<E> wrapped;

    public LazyIterable(Iterable<E> wrapped) {
        this.wrapped = wrapped;
    }

    @Override
    public Iterator<E> iterator() {
        return new LazyIterator<E>(wrapped.iterator());
    }
}

公共类LazyIterable实现了Iterable{
私人终审法院；
公共休闲包（可折叠包装）{
this.wrapped=wrapped；
}
@凌驾
公共迭代器迭代器（）{
返回新的LazyIterator（wrapped.iterator（））；
}
}

---

有了测试和一切

谷歌番石榴（GoogleGuava）有很多帮助方法来实现这类功能。你想要的已经实现了

如果要从集合中筛选迭代器

如果您需要Iterable的实例，例如在“for each”类型的循环中使用它

---

还有Collections2.filter，如果您还需要使用该筛选器对其他收集方法进行预处理。

看起来不错。。。但我还不懂Java8。我们仍然使用JDK7，这是离题的，但是Guava（在许多其他伟大的特性中）提供了这一点。请参见Iterables和Fluentitable：