Java 使用iterable的next（）查找下一个唯一元素

我需要在我的包装器类中重写迭代器的

next（）

函数，这样每次调用

next（）

，它都会遍历

ScrollableResults

，添加详细信息，并最终返回唯一的记录

由于事情已经设置到位，每个具有相同序列号的记录除了细节名称和细节值之外应该完全相同。我需要将这些细节添加到同一条记录中（这就是

record.addDetail（name，value）

所做的），并最终返回唯一的记录。下面是我的自定义

next（）

所需的详细说明：

迭代

可滚动结果

，将详细信息名称和详细信息值添加到唯一记录（它可以添加到任何一个唯一记录）

一旦光标遇到不同的序列号，它就会跳出循环并返回唯一的记录/对象

返回后，对

next（）

的下一次调用将重新启动该过程，但光标将在其停止的位置拾取，并且

previousSequence

也应在其停止的位置拾取

Wrapper.java:

public class Wrapper<T> implements Iterable<T>, AutoCloseable {

    private ScrollableResults scrollableResults;
    private Session session;

    public Wrapper(ScrollableResults scrollableResults, Session session) {
        this.scrollableResults = scrollableResults;
        this.session = session;
    }

    public Iterator<T> iterator() { return new WrapperIterator(); }

    @Override
    public void close() {
        scrollableResults.close();
    }

    public class WrapperIterator implements Iterator<T> {

        private Integer previousSequence;

        @Override
        public boolean hasNext() {
            boolean hasNext = scrollableResults.next();
            return hasNext;
        }

        /**
         * This next() method should return the next UNIQUE record.
         * But before returning the unique record, it should add all the appropriate details to the respective record.
         */
        @Override
        public T next() {
            boolean hasNext = scrollableResults.next();
            if (!hasNext) {
                throw new NoSuchElementException();
            }
            // For previousSequence, first result needs to be retrieved explicitly
            Object[] row = (Object[]) scrollableResults.get();
            Record record = (Record) row[0];
            Integer currentSequence = previousSequence = record.getSequence();
            String detailName = (String) row[1];
            String detailValue = (String) row[2];
            record = setDetails(record, detailName, detailValue);

            Object[] mainRow = row;

            // First one should always be unique since it's starting a new set of records of same sequence.
            while(scrollableResults.next()) {
                 // Get record
                row = (Object[]) scrollableResults.get();
                record = (Record) row[0];
                // Update current sequence
                currentSequence = record.getSequence();
                // If current sequence is different from previous sequence, break
                // First result needs to be accounted for
                if(!currentSequence.equals(previousSequence)) {
                    previousSequence = currentSequence;
                    session.evict(row);
                    return (T) row;
                }
                // Add detail
                detailName = (String) row[1];
                detailValue = (String) row[2];
                record = setDetails(record, detailName, detailValue);
            }
            previousSequence = currentSequence;
            return (T) mainRow;
        }

        private Record setDetails(Record record, String detailName, String detailValue) {
            record.addDetail(detailName, detailValue);
            return record;
        }
    }
}

public类包装器实现了Iterable、AutoCloseable{
私有滚动结果滚动结果；
非公开会议；
公共包装器（ScrollableResults ScrollableResults，会话）{
this.scrollableResults=scrollableResults；
this.session=会话；
}
公共迭代器迭代器（）{返回新的包装迭代器（）；}
@凌驾
公众假期结束（）{
scrollableResults.close（）；
}
公共类包装器迭代器实现迭代器{
私有整数序列；
@凌驾
公共布尔hasNext（）{
boolean hasNext=scrollableResults.next（）；
返回hasNext；
}
/**
*此next（）方法应返回下一条唯一记录。
*但是在返回唯一记录之前，它应该将所有适当的细节添加到相应的记录中。
*/
@凌驾
公共交通工具{
boolean hasNext=scrollableResults.next（）；
如果（！hasNext）{
抛出新的NoTouchElementException（）；
}
//对于previousSequence，需要显式检索第一个结果
对象[]行=（对象[]）scrollableResults.get（）；
记录记录=（记录）行[0]；
整数currentSequence=previousSequence=record.getSequence（）；
String detailName=（字符串）行[1]；
字符串详细信息值=（字符串）行[2]；
记录=设置详细信息（记录、详细名称、详细值）；
对象[]mainRow=行；
//第一个应该总是唯一的，因为它开始了一组相同序列的新记录。
while（scrollableResults.next（））{
//获得记录
行=（对象[]）scrollableResults.get（）；
记录=（记录）行[0]；
//更新当前序列
currentSequence=record.getSequence（）；
//如果当前序列与前一序列不同，则断开
//第一个结果需要说明
如果（！currentSequence.equals（previousSequence））{
previousSequence=currentSequence；
会议.驱逐（世界其他地区）；
返回（T）行；
}
//添加细节
detailName=（字符串）行[1]；
detailValue=（字符串）行[2]；
记录=设置详细信息（记录、详细名称、详细值）；
}
previousSequence=currentSequence；
返回（T）主行；
}
私有记录setDetails（记录记录、字符串detailName、字符串detailValue）{
record.addDetail（detailName，detailValue）；
返回记录；
}
}
}

我一直在努力实现这一点，这是我所能做到的。我当前的方法遍历并输入细节很好，但是我的问题是返回正确的行。由于当前序列需要与前一个序列进行检查，因此我无法返回新序列记录之前的最后一条记录，因为光标已经过了它。

有没有关于如何解决这个问题的建议？任何事情都将不胜感激

---

注意：迭代器不能向后遍历。由于滚动模式的PSQL错误需要仅向前，滚动模式被设置为仅向前。

确切的问题是什么？（您是否注意到您正在调用

scrollableResults.next（）

您可能不应该调用的地方？@ernest_k我更新了它，以便更清楚地了解我的问题。我只是不确定如何实现这一点。我可能没有完全理解你的目标。但听起来这可能是一个“准备”下一个元素的单独步骤。这里偶尔使用的模式是：1。下一步定义一个

private T。2.执行
hasNext
as
next=空
。3.创建一个方法
prepareNext
，该方法将计算要返回的下一个元素。4.在构造函数中，执行this.next=prepareNext（）

。5.在

next

中，do

T result=next；this.next=prepareNext（）；返回结果。如果你认为这可以解决你的问题，我会试着把它转换成一个答案。