How to use

count

method

in

com.google.common.collect.Multiset

@Override
public int count(Object element) {
 int count1 = multiset1.count(element);
 return (count1 == 0) ? 0 : Math.min(count1, multiset2.count(element));
}

 @Override
 @GuardedBy("ServiceManagerState.this.monitor")
 public boolean isSatisfied() {
  return states.count(TERMINATED) + states.count(FAILED) == numberOfServices;
 }
}

@Override
public int count(@Nullable Object element) {
 int count1 = multiset1.count(element);
 return (count1 == 0) ? 0 : Math.max(0, count1 - multiset2.count(element));
}

@Override
public int count(@Nullable Object element) {
 int count = unfiltered.count(element);
 if (count > 0) {
  @SuppressWarnings("unchecked") // element is equal to an E
  E e = (E) element;
  return predicate.apply(e) ? count : 0;
 }
 return 0;
}

/** An implementation of {@link Multiset#setCount(Object, int, int)}. */
static <E> boolean setCountImpl(Multiset<E> self, E element, int oldCount, int newCount) {
 checkNonnegative(oldCount, "oldCount");
 checkNonnegative(newCount, "newCount");
 if (self.count(element) == oldCount) {
  self.setCount(element, newCount);
  return true;
 } else {
  return false;
 }
}

public void testCollectionCreate() {
 Multiset<Color> ms = EnumMultiset.create(asList(Color.RED, Color.YELLOW, Color.RED));
 assertEquals(0, ms.count(Color.BLUE));
 assertEquals(1, ms.count(Color.YELLOW));
 assertEquals(2, ms.count(Color.RED));
}

@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddOccurrences() {
 int originalCount = getMultiset().count(e0());
 assertEquals("old count", originalCount, getMultiset().add(e0(), 2));
 assertEquals("old count", originalCount + 2, getMultiset().count(e0()));
}

public void testCreateWithSize() {
 Multiset<String> multiset = HashMultiset.create(50);
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
}

@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddSeveralTimes() {
 int originalCount = getMultiset().count(e0());
 assertEquals(originalCount, getMultiset().add(e0(), 2));
 assertTrue(getMultiset().add(e0()));
 assertEquals(originalCount + 3, getMultiset().add(e0(), 1));
 assertEquals(originalCount + 4, getMultiset().count(e0()));
}

@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddOccurrencesZero() {
 int originalCount = getMultiset().count(e0());
 assertEquals("old count", originalCount, getMultiset().add(e0(), 0));
 expectUnchanged();
}

@CollectionSize.Require(SEVERAL)
public void testCount_3() {
 initThreeCopies();
 assertEquals("multiset.count(thriceContained) didn't return 3", 3, getMultiset().count(e0()));
}

@CollectionSize.Require(SEVERAL)
@CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
@MultisetFeature.Require(ENTRIES_ARE_VIEWS)
public void testEntryReflectsEntrySetIteratorRemove() {
 initThreeCopies();
 assertEquals(3, getMultiset().count(e0()));
 Iterator<Multiset.Entry<E>> entryItr = getMultiset().entrySet().iterator();
 Multiset.Entry<E> entry = entryItr.next();
 entryItr.remove();
 assertEquals(0, entry.getCount());
}

@CollectionFeature.Require(SUPPORTS_ADD)
public void testAddTooMany() {
 getMultiset().add(e3(), Integer.MAX_VALUE);
 try {
  getMultiset().add(e3());
  fail();
 } catch (IllegalArgumentException expected) {
 }
 assertEquals(Integer.MAX_VALUE, getMultiset().count(e3()));
 assertEquals(Integer.MAX_VALUE, getMultiset().size());
}

public void testCreateWithComparator() {
 Multiset<String> multiset = TreeMultiset.create(Collections.reverseOrder());
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[foo x 2, bar]", multiset.toString());
}

public void testCreateWithSize() {
 Multiset<String> multiset = LinkedHashMultiset.create(50);
 multiset.add("foo", 2);
 multiset.add("bar");
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[foo x 2, bar]", multiset.toString());
}

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

@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());
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveZeroNoOp() {
 int originalCount = getMultiset().count(e0());
 assertEquals("old count", originalCount, getMultiset().remove(e0(), 0));
 expectUnchanged();
}

public void testCreateFromIterable() {
 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("foo", "bar", "foo"));
 assertEquals(3, multiset.size());
 assertEquals(2, multiset.count("foo"));
 assertEquals("[bar, foo x 2]", multiset.toString());
}

@CollectionSize.Require(absent = ZERO)
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemove_occurrences_present() {
 assertEquals(
   "multiset.remove(present, 2) didn't return the old count",
   1,
   getMultiset().remove(e0(), 2));
 assertFalse(
   "multiset contains present after multiset.remove(present, 2)",
   getMultiset().contains(e0()));
 assertEquals(0, getMultiset().count(e0()));
}