How to use

spliterator

method

in

java.util.Collection

@Override
public Spliterator<E> spliterator() {
 synchronized (mutex) {
  return delegate().spliterator();
 }
}

@Override
public Spliterator<K> spliterator() {
 return CollectSpliterators.map(multimap.entries().spliterator(), Map.Entry::getKey);
}

@Override
public Spliterator<E> spliterator() {
 return CollectSpliterators.filter(unfiltered.spliterator(), predicate);
}

@Override
public Spliterator<T> spliterator() {
 return CollectSpliterators.map(fromCollection.spliterator(), function);
}

@Override
public Spliterator<E> spliterator() {
 synchronized (mutex) {
  return delegate().spliterator();
 }
}

@Override
public Spliterator<E> spliterator() {
 return CollectSpliterators.filter(unfiltered.spliterator(), predicate);
}

@Override
public Spliterator<T> spliterator() {
 return CollectSpliterators.map(fromCollection.spliterator(), function);
}

@Override
Spliterator<V> valueSpliterator() {
 return CollectSpliterators.flatMap(
   map.values().spliterator(), Collection::spliterator, Spliterator.SIZED, size());
}

@Override
Spliterator<Entry<K, V>> entrySpliterator() {
 return CollectSpliterators.flatMap(
   map.entrySet().spliterator(),
   keyToValueCollectionEntry -> {
    K key = keyToValueCollectionEntry.getKey();
    Collection<V> valueCollection = keyToValueCollectionEntry.getValue();
    return CollectSpliterators.map(
      valueCollection.spliterator(), (V value) -> Maps.immutableEntry(key, value));
   },
   Spliterator.SIZED,
   size());
}

@Override
Spliterator<Entry<K, V>> entrySpliterator() {
 return CollectSpliterators.flatMap(
   asMap().entrySet().spliterator(),
   keyToValueCollectionEntry -> {
    K key = keyToValueCollectionEntry.getKey();
    Collection<V> valueCollection = keyToValueCollectionEntry.getValue();
    return CollectSpliterators.map(
      valueCollection.spliterator(), (V value) -> Maps.immutableEntry(key, value));
   },
   Spliterator.SIZED | (this instanceof SetMultimap ? Spliterator.DISTINCT : 0),
   size());
}

@Override
Spliterator<V> valueSpliterator() {
 return CollectSpliterators.flatMap(
   map.values().spliterator(), Collection::spliterator, Spliterator.SIZED, size());
}

@CollectionFeature.Require(SUPPORTS_ADD)
public void testSpliteratorNotImmutable_CollectionAllowsAdd() {
 // If add is supported, verify that IMMUTABLE is not reported.
 synchronized (collection) { // for Collections.synchronized
  assertFalse(collection.spliterator().hasCharacteristics(Spliterator.IMMUTABLE));
 }
}

@Override
public Spliterator<K> spliterator() {
 return CollectSpliterators.map(multimap.entries().spliterator(), Map.Entry::getKey);
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testSpliteratorNotImmutable_CollectionAllowsRemove() {
 // If remove is supported, verify that IMMUTABLE is not reported.
 synchronized (collection) { // for Collections.synchronized
  assertFalse(collection.spliterator().hasCharacteristics(Spliterator.IMMUTABLE));
 }
}

@Override
Spliterator<Entry<K, V>> entrySpliterator() {
 return CollectSpliterators.flatMap(
   map.entrySet().spliterator(),
   keyToValueCollectionEntry -> {
    K key = keyToValueCollectionEntry.getKey();
    Collection<V> valueCollection = keyToValueCollectionEntry.getValue();
    return CollectSpliterators.map(
      valueCollection.spliterator(), (V value) -> Maps.immutableEntry(key, value));
   },
   Spliterator.SIZED,
   size());
}

public void testEntriesSpliterator() {
 List<Entry<String, Integer>> expectedEntries =
   asList(
     Maps.immutableEntry("foo", 2),
     Maps.immutableEntry("foo", 3),
     Maps.immutableEntry("bar", 4),
     Maps.immutableEntry("bar", 5),
     Maps.immutableEntry("foo", 6));
 Multimap<String, Integer> multimap = LinkedHashMultimap.create();
 for (Entry<String, Integer> entry : expectedEntries) {
  multimap.put(entry.getKey(), entry.getValue());
 }
 List<Entry<String, Integer>> actualEntries = new ArrayList<>();
 multimap.entries().spliterator().forEachRemaining(actualEntries::add);
 assertThat(actualEntries).containsExactlyElementsIn(expectedEntries).inOrder();
}

 public void testValuesSpliterator() {
  List<Entry<String, Integer>> expectedEntries =
    asList(
      Maps.immutableEntry("foo", 2),
      Maps.immutableEntry("foo", 3),
      Maps.immutableEntry("bar", 4),
      Maps.immutableEntry("bar", 5),
      Maps.immutableEntry("foo", 6));
  Multimap<String, Integer> multimap = LinkedHashMultimap.create();
  for (Entry<String, Integer> entry : expectedEntries) {
   multimap.put(entry.getKey(), entry.getValue());
  }
  List<Integer> actualValues = new ArrayList<>();
  multimap.values().spliterator().forEachRemaining(actualValues::add);
  assertThat(actualValues)
    .containsExactlyElementsIn(Lists.transform(expectedEntries, Entry::getValue))
    .inOrder();
 }
}

@CollectionFeature.Require(ALLOWS_NULL_VALUES)
@CollectionSize.Require(absent = ZERO)
public void testSpliteratorNullable() {
 initCollectionWithNullElement();
 synchronized (collection) { // for Collections.synchronized
  assertFalse(collection.spliterator().hasCharacteristics(Spliterator.NONNULL));
 }
}

@Override
Spliterator<Entry<K, V>> entrySpliterator() {
 return CollectSpliterators.flatMap(
   asMap().entrySet().spliterator(),
   keyToValueCollectionEntry -> {
    K key = keyToValueCollectionEntry.getKey();
    Collection<V> valueCollection = keyToValueCollectionEntry.getValue();
    return CollectSpliterators.map(
      valueCollection.spliterator(), (V value) -> Maps.immutableEntry(key, value));
   },
   Spliterator.SIZED | (this instanceof SetMultimap ? Spliterator.DISTINCT : 0),
   size());
}

@CacheSpec
@CheckNoWriter @CheckNoStats
@Test(dataProvider = "caches")
public void valueSpliterator_tryAdvance(Map<Integer, Integer> map, CacheContext context) {
 Spliterator<Integer> spliterator = map.values().spliterator();
 int[] count = new int[1];
 boolean advanced;
 do {
  advanced = spliterator.tryAdvance(value -> count[0]++);
 } while (advanced);
 assertThat(count[0], is(map.size()));
}