Package org.roaringbitmap.longlong
Interface PeekableLongIterator
-
- All Superinterfaces:
Cloneable
,LongIterator
public interface PeekableLongIterator extends LongIterator
Simple extension to the IntIterator interface. It allows you to "skip" values using the advanceIfNeeded method, and to look at the value without advancing (peekNext). This richer interface enables efficient algorithms over iterators of longs.
-
-
Method Summary
All Methods Instance Methods Abstract Methods Modifier and Type Method Description void
advanceIfNeeded(long minval)
If needed, advance as long as the next value is smaller than minval The advanceIfNeeded method is used for performance reasons, to skip over unnecessary repeated calls to next.PeekableLongIterator
clone()
Creates a copy of the iterator.long
peekNext()
Look at the next value without advancing The peek is useful when working with several iterators at once.-
Methods inherited from interface org.roaringbitmap.longlong.LongIterator
hasNext, next
-
-
-
-
Method Detail
-
advanceIfNeeded
void advanceIfNeeded(long minval)
If needed, advance as long as the next value is smaller than minval The advanceIfNeeded method is used for performance reasons, to skip over unnecessary repeated calls to next. Suppose for example that you wish to compute the intersection between an ordered list of longs (e.g., longs[] x = {1,4,5}) and a PeekableIntIterator. You might do it as follows...
The benefit of calling advanceIfNeeded is that each such call can be much faster than repeated calls to "next". The underlying implementation can "skip" over some data.PeekableLongIterator j = // get an iterator long val = // first value from my other data structure j.advanceIfNeeded(val); while ( j.hasNext() ) { if(j.next() == val) { // ah! ah! val is in the intersection... // do something here val = // get next value? } j.advanceIfNeeded(val); }
- Parameters:
minval
- threshold
-
peekNext
long peekNext()
Look at the next value without advancing The peek is useful when working with several iterators at once. Suppose that you have 100 iterators, and you want to compute their intersections without materializing the result. You might do it as follows...
Notice how the peek method allows you to compare iterators in a way that the next method could not do.PriorityQueue pq = new PriorityQueue(100, new Comparator<PeekableIntIterator>() { public int compare(PeekableIntIterator a, PeekableIntIterator b) { return a.peek() - b.peek(); } }); //... populate pq while(! pq.isEmpty() ) { // get iterator with a smallest value PeekableLongIterator pi = pq.poll(); long x = pi.next(); // advance // do something with x if(pi.hasNext()) pq.add(pi) }
- Returns:
- next value
-
clone
PeekableLongIterator clone()
Creates a copy of the iterator.- Specified by:
clone
in interfaceLongIterator
- Returns:
- a clone of the current iterator
-
-