How to use

remove

method

in

com.google.common.collect.Multiset

@Override
public int remove(Object o, int n) {
 synchronized (mutex) {
  return delegate().remove(o, n);
 }
}

@Override
public N removeInEdge(E edge, boolean isSelfLoop) {
 N node = super.removeInEdge(edge, isSelfLoop);
 Multiset<N> predecessors = getReference(predecessorsReference);
 if (predecessors != null) {
  checkState(predecessors.remove(node));
 }
 return node;
}

@Override
public N removeOutEdge(E edge) {
 N node = super.removeOutEdge(edge);
 Multiset<N> adjacentNodes = getReference(adjacentNodesReference);
 if (adjacentNodes != null) {
  checkState(adjacentNodes.remove(node));
 }
 return node;
}

@Override
public N removeOutEdge(E edge) {
 N node = super.removeOutEdge(edge);
 Multiset<N> successors = getReference(successorsReference);
 if (successors != null) {
  checkState(successors.remove(node));
 }
 return node;
}

/** An implementation of {@link Multiset#setCount(Object, int)}. */
static <E> int setCountImpl(Multiset<E> self, E element, int count) {
 checkNonnegative(count, "count");
 int oldCount = self.count(element);
 int delta = count - oldCount;
 if (delta > 0) {
  self.add(element, delta);
 } else if (delta < 0) {
  self.remove(element, -delta);
 }
 return oldCount;
}

 @Override
 public void remove() {
  checkRemove(canRemove);
  if (totalCount == 1) {
   entryIterator.remove();
  } else {
   multiset.remove(currentEntry.getElement());
  }
  totalCount--;
  canRemove = false;
 }
}

@CanIgnoreReturnValue
@Override
public int remove(Object element, int occurrences) {
 return delegate().remove(element, occurrences);
}

@CollectionFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_QUERIES)
public void testRemove_nullForbidden() {
 try {
  getMultiset().remove(null, 2);
  fail("Expected NullPointerException");
 } catch (NullPointerException expected) {
 }
}

@MapFeature.Require(SUPPORTS_REMOVE)
public void testKeysRemove() {
 int original = multimap().keys().remove(k0(), 1);
 assertEquals(Math.max(original - 1, 0), multimap().get(k0()).size());
}

@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
public void testRemoveUnsupported() {
 try {
  getMultiset().remove(e0(), 2);
  fail("Expected UnsupportedOperationException");
 } catch (UnsupportedOperationException expected) {
 }
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemove_occurrences_negative() {
 try {
  getMultiset().remove(e0(), -1);
  fail("multiset.remove(E, -1) didn't throw an exception");
 } catch (IllegalArgumentException required) {
 }
}

@CollectionSize.Require(absent = ZERO)
public void testEquals_differentElements() {
 Multiset<E> other = HashMultiset.create(getSampleElements());
 other.remove(e0());
 other.add(e3());
 assertFalse("multiset equals a multiset with different elements", getMultiset().equals(other));
}

@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
public void testRemove_occurrences_unsupported_absent() {
 // notice: we don't care whether it succeeds, or fails with UOE
 try {
  assertEquals(
    "multiset.remove(absent, 2) didn't return 0 or throw an exception",
    0,
    getMultiset().remove(e3(), 2));
 } catch (UnsupportedOperationException ok) {
 }
}

 @Override
 public int remove(@Nullable Object element, int occurrences) {
  checkNonnegative(occurrences, "occurrences");
  if (occurrences == 0) {
   return count(element);
  } else {
   return contains(element) ? unfiltered.remove(element, occurrences) : 0;
  }
 }
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveNegative() {
 try {
  getMultiset().remove(e0(), -1);
  fail("Expected IllegalArgumentException");
 } catch (IllegalArgumentException expected) {
 }
 expectUnchanged();
}

public void testLinkedKeys() {
 Multimap<String, Integer> map = create();
 map.put("bar", 1);
 map.put("foo", 2);
 map.put("bar", 3);
 map.put("bar", 4);
 assertEquals("[bar=1, foo=2, bar=3, bar=4]", map.entries().toString());
 assertThat(map.keys()).containsExactly("bar", "foo", "bar", "bar").inOrder();
 map.keys().remove("bar"); // bar is no longer the first key!
 assertEquals("{foo=[2], bar=[3, 4]}", map.toString());
}

public void testRemoveUnsupported() {
 Multiset<String> multiset = new NoRemoveMultiset<>();
 multiset.add("a");
 try {
  multiset.remove("a");
  fail();
 } catch (UnsupportedOperationException expected) {
 }
 assertTrue(multiset.contains("a"));
}

@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemove_occurrences_0() {
 int oldCount = getMultiset().count(e0());
 assertEquals(
   "multiset.remove(E, 0) didn't return the old count",
   oldCount,
   getMultiset().remove(e0(), 0));
}

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

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