Java 番石榴：通过中间处理进行迭代

我得到了：对象数组：

{o1，o2，o3，o4，…}

。假设我从

o2

对象开始迭代。我可能会遇到这样的情况：几乎没有相同的对象。我的意思是

o2

same

o3

same

o4

通过

same

我理解

o1.getSomeField（）.equals（o2.getSomeField（））

我想要：迭代数组，每次切换到不同的对象时进行一些处理

示例：假设

o2

相同

o3

但不相同

o4

。然后是迭代的步骤：

• 从

  o2

  切换到

  o3

• 啊哈，他们都一样，什么也不做
• 从

  o3

  切换到

  o4

• o3

  和

  o4

  不一样。在{o2，o3，o4}子阵列上做一些额外的逻辑

问题：怎么做？番石榴中有什么对我有帮助的吗

---

问题2:是否存在允许我将初始数组划分为具有相同

元素的子数组的库？（通过
same
我理解
o1.getSomeField（）.equals（o2.getSomeField（））
）
将上一个元素保留在变量中：

Foo previous = null;
for (Foo foo : iterable) {
    if (!foo.getSomeField().equals(previous.getSomeField())) {
        doSomething(foo);
    } 
    previous = foo;
}

将上一个元素保留在变量中：

Foo previous = null;
for (Foo foo : iterable) {
    if (!foo.getSomeField().equals(previous.getSomeField())) {
        doSomething(foo);
    } 
    previous = foo;
}

将上一个元素保留在变量中：

Foo previous = null;
for (Foo foo : iterable) {
    if (!foo.getSomeField().equals(previous.getSomeField())) {
        doSomething(foo);
    } 
    previous = foo;
}

将上一个元素保留在变量中：

Foo previous = null;
for (Foo foo : iterable) {
    if (!foo.getSomeField().equals(previous.getSomeField())) {
        doSomething(foo);
    } 
    previous = foo;
}

这就是我在评论中所说的想法，你可以实现这样一个迭代器（可能会做一些修改，因为这样它会使用第一个不同的元素）

{o1，o1，o2，o2，o3}
将是
{o1，o1，o2}{o2，o3}
，但这很容易修复

public class CollectingIterator implements Iterator<Collection<MyClass>> {


    private boolean hasNext;
    private LinkedList<MyClass> next = new LinkedList<MyClass>();

    private final Iterator<MyClass> baseIterator;

    public CollectingIterator(Iterator<MyClass> baseIterator) {
        this.baseIterator = baseIterator;
        toNext();
    }

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

    @Override
    public Collection<MyClass> next() {
        Collection<MyClass> next = new LinkedList<MyClass>(this.next);
        toNext();
        return next;
    }

    private void toNext() {
        next.clear();
        boolean isSame = true;
        while (baseIterator.hasNext() && isSame) {
            if (next.isEmpty()) {
                next.add(baseIterator.next());
            } else {
                final MyClass nextElement = baseIterator.next();
                final MyClass last = next.getLast();
                next.add(nextElement);
                if (!last.getSomeField().equals(nextElement.getSomeField())) {
                    isSame = false;
                }
            }
        }

        this.hasNext = baseIterator.hasNext() || !next.isEmpty();
    }
}

公共类CollectionIterator实现迭代器{
私有布尔hasnet；
private LinkedList next=新建LinkedList（）；
私有最终迭代器baseIterator；
公共集合迭代器（迭代器base迭代器）{
this.baseIterator=baseIterator；
toNext（）；
}
@凌驾
公共布尔hasNext（）{
返回hasNext；
}
@凌驾
下一次公开募捐（）{
Collection next=新的LinkedList（this.next）；
toNext（）；
下一步返回；
}
私有void toNext（）{
next.clear（）；
布尔值IsName=true；
while（baseIterator.hasNext（）&&IsName）{
if（next.isEmpty（））{
add（baseIterator.next（））；
}否则{
final MyClass nextElement=baseIterator.next（）；
final MyClass last=next.getLast（）；
next.add（nextElement）；
如果（！last.getSomeField（）.equals（nextElement.getSomeField（）））{
IsName=假；
}
}
}
this.hasNext=baseIterator.hasNext（）| |！next.isEmpty（）；
}
}

然后你可以使用guavas或者做进一步的逻辑。虽然这是一次性的处理，但是你可能会因为另一个答案中的建议而受益
这是我的想法，正如我在评论中所说的，你可以实现这样的迭代器（可能会做一些修改，因为这样它会消耗第一个不同的元素，所以

{o1，o1，o2，o2，o3}
将是
{o1，o1，o2}{o2，o3}
，但这很容易修复

public class CollectingIterator implements Iterator<Collection<MyClass>> {


    private boolean hasNext;
    private LinkedList<MyClass> next = new LinkedList<MyClass>();

    private final Iterator<MyClass> baseIterator;

    public CollectingIterator(Iterator<MyClass> baseIterator) {
        this.baseIterator = baseIterator;
        toNext();
    }

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

    @Override
    public Collection<MyClass> next() {
        Collection<MyClass> next = new LinkedList<MyClass>(this.next);
        toNext();
        return next;
    }

    private void toNext() {
        next.clear();
        boolean isSame = true;
        while (baseIterator.hasNext() && isSame) {
            if (next.isEmpty()) {
                next.add(baseIterator.next());
            } else {
                final MyClass nextElement = baseIterator.next();
                final MyClass last = next.getLast();
                next.add(nextElement);
                if (!last.getSomeField().equals(nextElement.getSomeField())) {
                    isSame = false;
                }
            }
        }

        this.hasNext = baseIterator.hasNext() || !next.isEmpty();
    }
}

公共类CollectionIterator实现迭代器{
私有布尔hasnet；
private LinkedList next=新建LinkedList（）；
私有最终迭代器baseIterator；
公共集合迭代器（迭代器base迭代器）{
this.baseIterator=baseIterator；
toNext（）；
}
@凌驾
公共布尔hasNext（）{
返回hasNext；
}
@凌驾
下一次公开募捐（）{
Collection next=新的LinkedList（this.next）；
toNext（）；
下一步返回；
}
私有void toNext（）{
next.clear（）；
布尔值IsName=true；
while（baseIterator.hasNext（）&&IsName）{
if（next.isEmpty（））{
add（baseIterator.next（））；
}否则{
final MyClass nextElement=baseIterator.next（）；
final MyClass last=next.getLast（）；
next.add（nextElement）；
如果（！last.getSomeField（）.equals（nextElement.getSomeField（）））{
IsName=假；
}
}
}
this.hasNext=baseIterator.hasNext（）| |！next.isEmpty（）；
}
}

然后你可以使用guavas或者做进一步的逻辑。虽然这是一次性的处理，但是你可能会因为另一个答案中的建议而受益
这是我的想法，正如我在评论中所说的，你可以实现这样的迭代器（可能会做一些修改，因为这样它会消耗第一个不同的元素，所以

{o1，o1，o2，o2，o3}
将是
{o1，o1，o2}{o2，o3}
，但这很容易修复

public class CollectingIterator implements Iterator<Collection<MyClass>> {


    private boolean hasNext;
    private LinkedList<MyClass> next = new LinkedList<MyClass>();

    private final Iterator<MyClass> baseIterator;

    public CollectingIterator(Iterator<MyClass> baseIterator) {
        this.baseIterator = baseIterator;
        toNext();
    }

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

    @Override
    public Collection<MyClass> next() {
        Collection<MyClass> next = new LinkedList<MyClass>(this.next);
        toNext();
        return next;
    }

    private void toNext() {
        next.clear();
        boolean isSame = true;
        while (baseIterator.hasNext() && isSame) {
            if (next.isEmpty()) {
                next.add(baseIterator.next());
            } else {
                final MyClass nextElement = baseIterator.next();
                final MyClass last = next.getLast();
                next.add(nextElement);
                if (!last.getSomeField().equals(nextElement.getSomeField())) {
                    isSame = false;
                }
            }
        }

        this.hasNext = baseIterator.hasNext() || !next.isEmpty();
    }
}

公共类CollectionIterator实现迭代器{
私有布尔hasnet；
private LinkedList next=新建LinkedList（）；
私有最终迭代器baseIterator；
公共集合迭代器（迭代器base迭代器）{
this.baseIterator=baseIterator；
toNext（）；
}
@凌驾
公共布尔hasNext（）{
返回hasNext；
}
@凌驾
下一次公开募捐（）{
Collection next=新的LinkedList（this.next）；
toNext（）；
下一步返回；
}
私有void toNext（）{
next.clear（）；
布尔值IsName=true；
while（baseIterator.hasNext（）&&IsName）{
if（next.isEmpty（））{
add（baseIterator.next（））；
}否则{
final MyClass nextElement=baseIterator.next（）；
final MyClass last=next.getLast（）；
next.add（nextElement）；
如果（！last.getSomeField（）.e