下面列出了java.util.stream.Stream#iterator ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public static Rectangle getBounds(Stream<Node> nodes) {
final Iterator<Node> i = nodes.iterator();
if (i.hasNext()) {
float xMin = Float.MAX_VALUE;
float xMax = Float.MIN_VALUE;
float yMin = Float.MAX_VALUE;
float yMax = Float.MIN_VALUE;
while (i.hasNext()) {
final Node n = i.next();
xMin = Math.min(xMin, n.getX());
yMin = Math.min(yMin, n.getY());
xMax = Math.max(xMax, n.getX() + n.getWidth());
yMax = Math.max(yMax, n.getY() + n.getHeight());
}
return new Rectangle(xMin, yMin, xMax - xMin, yMax - yMin);
} else
return Rectangle.EMPTY;
}
public void testIterator() throws IOException {
MockLineReader r = new MockLineReader(6);
BufferedReader br = new BufferedReader(r);
String line = br.readLine();
assertEquals(r.getLineNumber(), 1, "Read one line");
Stream<String> s = br.lines();
Iterator<String> it = s.iterator();
// Ensure iterate with only next works
for (int i = 0; i < 5; i++) {
String str = it.next();
assertEquals(str, "Line " + (i + 2), "Addtional five lines");
}
// NoSuchElementException
try {
it.next();
fail("Should have run out of lines.");
} catch (NoSuchElementException nsse) {}
}
public void testIterator() throws IOException {
MockLineReader r = new MockLineReader(6);
BufferedReader br = new BufferedReader(r);
String line = br.readLine();
assertEquals(r.getLineNumber(), 1, "Read one line");
Stream<String> s = br.lines();
Iterator<String> it = s.iterator();
// Ensure iterate with only next works
for (int i = 0; i < 5; i++) {
String str = it.next();
assertEquals(str, "Line " + (i + 2), "Addtional five lines");
}
// NoSuchElementException
try {
it.next();
fail("Should have run out of lines.");
} catch (NoSuchElementException nsse) {}
}
private static void assertContains(Stream<User> expected, List<User> actual) {
Iterator<User> expIt = expected.iterator();
if (!expIt.hasNext()) {
return;
}
User exp = expIt.next();
for (User act : actual) {
if (act.equals(exp)) {
if (!expIt.hasNext()) {
break;
}
exp = expIt.next();
}
}
assertFalse("Not all expected elements are in the actual list. E.g.: " + exp, expIt.hasNext());
}
public void testIterator() throws IOException {
MockLineReader r = new MockLineReader(6);
BufferedReader br = new BufferedReader(r);
String line = br.readLine();
assertEquals(r.getLineNumber(), 1, "Read one line");
Stream<String> s = br.lines();
Iterator<String> it = s.iterator();
// Ensure iterate with only next works
for (int i = 0; i < 5; i++) {
String str = it.next();
assertEquals(str, "Line " + (i + 2), "Addtional five lines");
}
// NoSuchElementException
try {
it.next();
fail("Should have run out of lines.");
} catch (NoSuchElementException nsse) {}
}
/**
* Variation of {@link Parser#sequence(IList)} for {@link Stream}.
* @param spt the stream of {@code Parser} values
* @param <E> the error type
* @param <T> the value type of the {@code Parser}s in the stream
* @return a {@code Parser} which wraps an {@link Stream} of values
*/
static <E, T> Parser<E, Stream<T>> sequence(Stream<Parser<E, T>> spt) {
final Iterator<Parser<E, T>> iter = spt.iterator();
Parser<E, IList<T>> plt = pure(IList.empty());
while (iter.hasNext()) {
final Parser<E, T> pt = iter.next();
plt = ap(plt.map(lt -> lt::add), pt);
}
return plt.map(IList::stream);
}
public void testInterlacedRead() throws IOException {
MockLineReader r = new MockLineReader(10);
BufferedReader br = new BufferedReader(r);
char[] buf = new char[5];
Stream<String> s = br.lines();
Iterator<String> it = s.iterator();
br.read(buf);
assertEquals(new String(buf), "Line ");
assertEquals(it.next(), "1");
try {
s.iterator().next();
fail("Should failed on second attempt to get iterator from s");
} catch (IllegalStateException ise) {}
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "Li");
// Get stream again should continue from where left
// Only read remaining of the line
br.lines().limit(1L).forEach(line -> assertEquals(line, "ne 2"));
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "Li");
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "ne");
assertEquals(it.next(), " 3");
// Line 4
br.readLine();
// interator pick
assertEquals(it.next(), "Line 5");
// Another stream instantiated by lines()
AtomicInteger line_no = new AtomicInteger(6);
br.lines().forEach(l -> assertEquals(l, "Line " + line_no.getAndIncrement()));
// Read after EOL
assertFalse(it.hasNext());
}
/**
* Check all targets are reachable from the starters.
* <p>
* In this implementation, it is recommended to put the most popular
* starters (e.g. refs/heads tips) at the beginning.
*/
@Override
public Optional<RevCommit> areAllReachable(Collection<RevCommit> targets,
Stream<RevCommit> starters) throws MissingObjectException,
IncorrectObjectTypeException, IOException {
List<RevCommit> remainingTargets = new ArrayList<>(targets);
walk.reset();
walk.sort(RevSort.TOPO);
// Filter emits only commits that are unreachable from previously
// visited commits. Internally it keeps a bitmap of everything
// reachable so far, which we use to discard reachable targets.
BitmapIndex repoBitmaps = walk.getObjectReader().getBitmapIndex();
ReachedFilter reachedFilter = new ReachedFilter(repoBitmaps);
walk.setRevFilter(reachedFilter);
Iterator<RevCommit> startersIter = starters.iterator();
while (startersIter.hasNext()) {
walk.markStart(startersIter.next());
while (walk.next() != null) {
remainingTargets.removeIf(reachedFilter::isReachable);
if (remainingTargets.isEmpty()) {
return Optional.empty();
}
}
walk.reset();
}
return Optional.of(remainingTargets.get(0));
}
@Override
void assertValue(List<T> value, Supplier<Stream<T>> source, boolean ordered)
throws ReflectiveOperationException {
if (!List.class.isAssignableFrom(value.getClass()))
fail(String.format("Class mismatch in ListAssertion: %s", value.getClass()));
Stream<T> stream = source.get();
List<T> result = new ArrayList<>();
for (Iterator<T> it = stream.iterator(); it.hasNext(); ) // avoid capturing result::add
result.add(it.next());
if (StreamOpFlagTestHelper.isStreamOrdered(stream) && ordered)
assertContents(value, result);
else
assertContentsUnordered(value, result);
}
public void testInterlacedRead() throws IOException {
MockLineReader r = new MockLineReader(10);
BufferedReader br = new BufferedReader(r);
char[] buf = new char[5];
Stream<String> s = br.lines();
Iterator<String> it = s.iterator();
br.read(buf);
assertEquals(new String(buf), "Line ");
assertEquals(it.next(), "1");
try {
s.iterator().next();
fail("Should failed on second attempt to get iterator from s");
} catch (IllegalStateException ise) {}
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "Li");
// Get stream again should continue from where left
// Only read remaining of the line
br.lines().limit(1L).forEach(line -> assertEquals(line, "ne 2"));
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "Li");
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "ne");
assertEquals(it.next(), " 3");
// Line 4
br.readLine();
// interator pick
assertEquals(it.next(), "Line 5");
// Another stream instantiated by lines()
AtomicInteger line_no = new AtomicInteger(6);
br.lines().forEach(l -> assertEquals(l, "Line " + line_no.getAndIncrement()));
// Read after EOL
assertFalse(it.hasNext());
}
public void testInterlacedRead() throws IOException {
MockLineReader r = new MockLineReader(10);
BufferedReader br = new BufferedReader(r);
char[] buf = new char[5];
Stream<String> s = br.lines();
Iterator<String> it = s.iterator();
br.read(buf);
assertEquals(new String(buf), "Line ");
assertEquals(it.next(), "1");
try {
s.iterator().next();
fail("Should failed on second attempt to get iterator from s");
} catch (IllegalStateException ise) {}
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "Li");
// Get stream again should continue from where left
// Only read remaining of the line
br.lines().limit(1L).forEach(line -> assertEquals(line, "ne 2"));
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "Li");
br.read(buf, 0, 2);
assertEquals(new String(buf, 0, 2), "ne");
assertEquals(it.next(), " 3");
// Line 4
br.readLine();
// interator pick
assertEquals(it.next(), "Line 5");
// Another stream instantiated by lines()
AtomicInteger line_no = new AtomicInteger(6);
br.lines().forEach(l -> assertEquals(l, "Line " + line_no.getAndIncrement()));
// Read after EOL
assertFalse(it.hasNext());
}
@Override
void assertValue(Collection<T> value, Supplier<Stream<T>> source, boolean ordered)
throws ReflectiveOperationException {
if (!clazz.isAssignableFrom(value.getClass()))
fail(String.format("Class mismatch in CollectionAssertion: %s, %s", clazz, value.getClass()));
Stream<T> stream = source.get();
Collection<T> result = clazz.newInstance();
for (Iterator<T> it = stream.iterator(); it.hasNext(); ) // avoid capturing result::add
result.add(it.next());
if (StreamOpFlagTestHelper.isStreamOrdered(stream) && targetOrdered && ordered)
assertContents(value, result);
else
assertContentsUnordered(value, result);
}
public static <T> Stream<T> adaptStream(Stream<T> stream, Function<? super T, ? extends DateTime> timestamp_fn, Duration stepsize) {
if (stepsize.getMillis() <= 0L) return stream;
final Iterator<T> iter = new SkippingIterator<>(stream.iterator(), timestamp_fn, stepsize);
final Spliterator<T> spliter = Spliterators.spliteratorUnknownSize(iter, NONNULL | IMMUTABLE | ORDERED);
return StreamSupport.stream(spliter, false);
}
public static <T,U> boolean zip(final Iterable<T> ct, final Stream<U> cu, final ZipIterator<T,U> each) {
final Iterator<T> it = ct.iterator();
final Iterator<U> iu = cu.iterator();
while (it.hasNext() && iu.hasNext()) {
each.each(it.next(), iu.next());
}
return !it.hasNext() && !iu.hasNext();
}
@Override
void assertValue(List<T> value, Supplier<Stream<T>> source, boolean ordered)
throws ReflectiveOperationException {
if (!List.class.isAssignableFrom(value.getClass()))
fail(String.format("Class mismatch in ListAssertion: %s", value.getClass()));
Stream<T> stream = source.get();
List<T> result = new ArrayList<>();
for (Iterator<T> it = stream.iterator(); it.hasNext(); ) // avoid capturing result::add
result.add(it.next());
if (StreamOpFlagTestHelper.isStreamOrdered(stream) && ordered)
assertContents(value, result);
else
assertContentsUnordered(value, result);
}
@Test
public void headAndTailTest(){
Stream<String> s = Stream.of("hello","world");
Iterator<String> it = s.iterator();
String head = it.next();
Stream<String> tail = Streams.stream(it);
tail.forEach(System.out::println);
}
public StreamDataScanner(
Transaction transaction, String[] fieldNames, Column[] schema,
Stream<DataAccessor> wrapped
) {
super(transaction, fieldNames, schema);
this.wrapped = wrapped.iterator();
fetchNext();
if (transaction != null) {
transaction.increaseRefcount();
}
}
CloseableRemoteIterator(Stream<T> stream) {
this.stream = stream;
this.iterator = stream.iterator();
}
/**
* Java 8 streams don't support streaming groupings, just materialized grouping.
* This groups a stream by a key, using the keying function provided.
*
* The stream must be sorted by the key for this to function properly.
*
* Note - when you use this operator, you need to be aware that you are relinquishing
* ALL control of the base stream. Do NOT try to reuse the inputted stream. Do NOT
* try to close the underlying stream. All interactions must now be done with the
* stream you get in return.
*
* @param stream stream to group.
* @param keyingFunction function to generate the key to be grouped by.
* @return grouped stream.
*/
public static <TYPE, KEY> Stream<List<TYPE>> groupBy(Stream<TYPE> stream, Function<TYPE, KEY> keyingFunction) {
final Iterator<TYPE> iterator = stream.iterator();
final Iterator<List<TYPE>> iter = new KeyedBufferIterator<>(iterator, keyingFunction);
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iter, 0), false)
// Whenever the grouped stream is closed, we need to close the
// underlying stream.
.onClose(stream::close);
}
/**
* Left-fold a function over a {@link Stream}.
* @param f the binary function to be applied for the fold
* @param z the starting value for the fold
* @param str the stream to be folded over
* @param <T> the stream element type
* @param <R> the result type of fold operation
* @param <X> the exception type
* @return the folded value
* @throws X the exception thrown by the function
*/
public static <T, R, X extends Exception> R foldLeft(F2<R, T, R, X> f, R z, Stream<T> str) throws X {
R acc = z;
for (Iterator<T> iter = str.iterator(); iter.hasNext();) {
acc = f.apply(acc, iter.next());
}
return acc;
}