Java 迭代器循环一次，从中间开始答案

【问题标题】：Java Iterator Loop once, start in middleJava 迭代器循环一次，从中间开始
【发布时间】：2018-04-21 09:13:17
【问题描述】：

我有一个迭代器 - 放置在我的集合中间的某个位置。

我想从那里循环遍历集合，如果找到它，则返回一个特殊元素。

如果我到达 !hasNext() 那么我想从头开始，但如果我到达我最开始的地方我想停下来。

目前解决该问题的最佳方法似乎是保存“第一个”（我开始时迭代器指向的位置）元素，然后如果我再次找到该元素则停止。

只要项目在我的集合中只能出现一次（即在 HasSet 中），它就可以工作。

任何更好的想法如何做这样的事情？迭代器似乎没有向我提供可以比较的指针/数字。

【问题讨论】：

迭代器是什么意思，迭代器是什么意思 - 放置在我的集合中间的某个地方
获取mid到end的两个子列表，结束从start到mid；然后分别迭代它们。
HashSet 没有固定的迭代顺序，因此可能是整个“中间迭代器”的最糟糕的例子。 - 但除此之外：您可以只计算您迭代的项目数，并在达到集合大小时停止。
是否需要使用迭代器？看起来更像是一个 for 循环。
你们可能是对的——我不应该使用迭代器。是否不必更改太多代码 - 但现在我可能会。

标签： java loops collections iterator

【解决方案1】：

如果你这样做，解决方案会变得更简单：

不要使用Iterator，这样会更复杂

使用List 而不是Set 因为Set 不适合这个用例

public static void main(String[] args) {
    Set<String> yourStartingCollection = new HashSet<>();
    List<String> fooList = new ArrayList<>(yourStartingCollection);

    Optional<String> specialElement = findSpecialElementStartingFromMiddle(fooList);
    if (specialElement.isPresent()) {
        // found it!
    }
}

private static Optional<String> findSpecialElementStartingFromMiddle(List<String> elements) {
    int middleIndex = elements.size() / 2;
    Optional<String> result = Optional.empty();

    for (int i = middleIndex; i < elements.size(); i++) {
        String element = elements.get(i);
        if (isSpecial(element)) {
            result = Optional.of(element);
            break;
        }
    }

    if (result.isPresent()) {
        return result;
    }

    for (int i = 0; i < middleIndex; i++) {
        String element = elements.get(i);
        if (isSpecial(element)) {
            result = Optional.of(element);
            break;
        }
    }

    return result;
}

private static boolean isSpecial(String element) {
    return element.equals("I'm special");
}

【讨论】：

【解决方案2】：

使用 Guava 迭代器 (Java 7)：

Iterator<YourType> iterator = Iterators.concat(yourIteratorPlaceSomewhereInMiddle, Iterators.limit(yourCollection.iterator(), positionOfSomewhereInMiddle));

使用流 (Java 8)：

Optional<YourType> theAnswer = IntStream.iterate(positionOfSomewhereInMiddle, pos -> ++pos)
                                        .map(pos -> pos % sizeOfCollection)
                                        .mapToObj(yourCollection::get)
                                        .limit(sizeOfCollection)
                                        .filter(element -> element is 42)
                                        .findFirst();

【讨论】：

【解决方案3】：

如果集合是一个列表，那么可以用下面的代码来完成

private void Object traverseList(List namesList, int startIndex ) {
    int index = 0;
    Iterator iterator = namesList.listIterator(startIndex);
    while (iterator.hasNext() && index < namesList.size()){
        Object element = iterator.next();
        /*if(element.isSpecialElement()){
         return element;
         }
        */
        index++;
        System.out.println(element);
        if(!iterator.hasNext()){
            iterator = namesList.iterator();
        }
    }
}

由于您想横向遍历列表中的所有元素，因此我正在使用列表大小。并且在迭代过程中，如果找到特殊元素，就可以返回。

【讨论】：

【解决方案4】：

要从定义的值开始迭代 Set ：

    public void iterate(Set<Sample> set, Sample definedValue){
        Iterator<Sample> iterator = set.iterator();
        while(iterator.hasNext()){
            Sample currentSample = iterator.next();
            if(currentSample.equals(definedValue)){
                while(iterator.hasNext()){
                Sample sampleToConsider = iterator.next();
                //Then do anything
                }
            }
        }
    }

【讨论】：