How to use

elementSet

method

in

com.google.common.collect.Multiset

/** An implementation of {@link Multiset#removeAll}. */
static boolean removeAllImpl(Multiset<?> self, Collection<?> elementsToRemove) {
 Collection<?> collection =
   (elementsToRemove instanceof Multiset)
     ? ((Multiset<?>) elementsToRemove).elementSet()
     : elementsToRemove;
 return self.elementSet().removeAll(collection);
}

/** An implementation of {@link Multiset#retainAll}. */
static boolean retainAllImpl(Multiset<?> self, Collection<?> elementsToRetain) {
 checkNotNull(elementsToRetain);
 Collection<?> collection =
   (elementsToRetain instanceof Multiset)
     ? ((Multiset<?>) elementsToRetain).elementSet()
     : elementsToRetain;
 return self.elementSet().retainAll(collection);
}

/**
 * Returns the expected number of distinct elements given the specified elements. The number of
 * distinct elements is only computed if {@code elements} is an instance of {@code Multiset};
 * otherwise the default value of 11 is returned.
 */
static int inferDistinctElements(Iterable<?> elements) {
 if (elements instanceof Multiset) {
  return ((Multiset<?>) elements).elementSet().size();
 }
 return 11; // initial capacity will be rounded up to 16
}

@Override
public Set<E> create(Object... elements) {
 Object[] duplicated = new Object[elements.length * 2];
 for (int i = 0; i < elements.length; i++) {
  duplicated[i] = elements[i];
  duplicated[i + elements.length] = elements[i];
 }
 return ((Multiset<E>) gen.create(duplicated)).elementSet();
}

@Override
public Set<E> elementSet() {
 synchronized (mutex) {
  if (elementSet == null) {
   elementSet = typePreservingSet(delegate().elementSet(), mutex);
  }
  return elementSet;
 }
}

@Override
public Set<E> elementSet() {
 return delegate().elementSet();
}

@Override
public Set<N> successors() {
 return Collections.unmodifiableSet(successorsMultiset().elementSet());
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemove_occurrences_absent() {
 int distinct = getMultiset().elementSet().size();
 assertEquals("multiset.remove(absent, 0) didn't return 0", 0, getMultiset().remove(e3(), 2));
 assertEquals(distinct, getMultiset().elementSet().size());
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testElementSetClear() {
 getMultiset().elementSet().clear();
 assertEmpty(getMultiset());
}

@CollectionSize.Require(absent = ZERO)
public void testElementSet_contains() {
 assertTrue(
   "multiset.elementSet().contains(present) returned false",
   getMultiset().elementSet().contains(e0()));
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testElementSetRemoveAbsent() {
 Set<E> elementSet = getMultiset().elementSet();
 assertFalse(elementSet.remove(e3()));
 expectUnchanged();
}

@CollectionFeature.Require(SUPPORTS_ADD)
public void testElementSetReflectsAddAbsent() {
 Set<E> elementSet = getMultiset().elementSet();
 assertFalse(elementSet.contains(e3()));
 getMultiset().add(e3(), 4);
 assertTrue(elementSet.contains(e3()));
}

 @CollectionFeature.Require(SERIALIZABLE_INCLUDING_VIEWS)
 public void testElementSetSerialization() {
  Set<E> expected = getMultiset().elementSet();
  assertEquals(expected, SerializableTester.reserialize(expected));
 }
}

@CollectionSize.Require(absent = ZERO)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testElementSetReflectsRemove() {
 Set<E> elementSet = getMultiset().elementSet();
 assertTrue(elementSet.contains(e0()));
 getMultiset().removeAll(Collections.singleton(e0()));
 assertFalse(elementSet.contains(e0()));
}

 private static long worstCaseQueryOperations(Multiset<?> multiset, CallsCounter counter) {
  long worstCalls = 0;
  for (Object k : multiset.elementSet()) {
   counter.zero();
   int unused = multiset.count(k);
   worstCalls = Math.max(worstCalls, counter.total());
  }
  return worstCalls;
 }
}

public void testSerialization_elementSet() {
 Multiset<String> c = ImmutableSortedMultiset.of("a", "b", "a");
 Collection<String> copy = SerializableTester.reserializeAndAssert(c.elementSet());
 assertThat(copy).containsExactly("a", "b").inOrder();
}

@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
@MultisetFeature.Require(ENTRIES_ARE_VIEWS)
public void testEntryReflectsElementSetClear() {
 initThreeCopies();
 assertEquals(3, getMultiset().count(e0()));
 Multiset.Entry<E> entry = Iterables.getOnlyElement(getMultiset().entrySet());
 assertEquals(3, entry.getCount());
 getMultiset().elementSet().clear();
 assertEquals(0, entry.getCount());
}

@GwtIncompatible // SerializableTester
public void testSerialization_elementSet() {
 Multiset<String> c = ImmutableMultiset.of("a", "b", "a");
 Collection<String> copy = LenientSerializableTester.reserializeAndAssertLenient(c.elementSet());
 assertThat(copy).containsExactly("a", "b").inOrder();
}

@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testElementSetRemoveDuplicatePropagatesToMultiset() {
 initThreeCopies();
 int size = getNumElements();
 int expectedSize = size - getMultiset().count(e0());
 Set<E> elementSet = getMultiset().elementSet();
 assertTrue(elementSet.remove(e0()));
 assertEmpty(getMultiset());
 assertEquals(expectedSize, getMultiset().size());
}

@CollectionSize.Require(absent = ZERO)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testElementSetRemovePropagatesToMultiset() {
 Set<E> elementSet = getMultiset().elementSet();
 int size = getNumElements();
 int expectedSize = size - getMultiset().count(e0());
 assertTrue(elementSet.remove(e0()));
 assertFalse(getMultiset().contains(e0()));
 assertEquals(expectedSize, getMultiset().size());
}