Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2007 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.collect;
 
 import static com.google.common.collect.Multisets.setCountImpl;
 
 
 import java.util.Set;
 
This class provides a skeletal implementation of the Multiset interface. A new multiset implementation can be created easily by extending this class and implementing the Multiset.entrySet() method, plus optionally overriding add(java.lang.Object,int) and remove(java.lang.Object,int) to enable modifications to the multiset.

The count(java.lang.Object) and size() implementations all iterate across the set returned by Multiset.entrySet(), as do many methods acting on the set returned by elementSet(). Override those methods for better performance.

Author(s):
Kevin Bourrillion
Louis Wasserman
 
 abstract class AbstractMultiset<E> extends AbstractCollection<E> implements Multiset<E> {
   // Query Operations
 
   @Override
   public int size() {
     return Multisets.sizeImpl(this);
   }
 
   @Override
   public boolean isEmpty() {
     return entrySet().isEmpty();
   }
 
   @Override
   public boolean contains(@Nullable Object element) {
     return count(element) > 0;
   }
 
   @Override
   public Iterator<E> iterator() {
     return Multisets.iteratorImpl(this);
   }
 
   @Override
   public int count(@Nullable Object element) {
     for (Entry<E> entry : entrySet()) {
       if (Objects.equal(entry.getElement(), element)) {
         return entry.getCount();
       }
     }
     return 0;
   }
 
   // Modification Operations
 
   @Override
   public boolean add(@Nullable E element) {
     add(element, 1);
     return true;
   }
 
   @Override
   public int add(@Nullable E elementint occurrences) {
     throw new UnsupportedOperationException();
   }
 
   @Override
   public boolean remove(@Nullable Object element) {
     return remove(element, 1) > 0;
   }
 
   @Override
  public int remove(@Nullable Object elementint occurrences) {
    throw new UnsupportedOperationException();
  }
  public int setCount(@Nullable E elementint count) {
    return setCountImpl(thiselementcount);
  }
  public boolean setCount(@Nullable E elementint oldCountint newCount) {
    return setCountImpl(thiselementoldCountnewCount);
  }
  // Bulk Operations

  

This implementation is highly efficient when elementsToAdd is itself a Multiset.

  public boolean addAll(Collection<? extends E> elementsToAdd) {
    return Multisets.addAllImpl(thiselementsToAdd);
  }
  public boolean removeAll(Collection<?> elementsToRemove) {
    return Multisets.removeAllImpl(thiselementsToRemove);
  }
  public boolean retainAll(Collection<?> elementsToRetain) {
    return Multisets.retainAllImpl(thiselementsToRetain);
  }
  public void clear() {
    Iterators.clear(entryIterator());
  }
  // Views
  private transient Set<E> elementSet;
  public Set<E> elementSet() {
    Set<E> result = ;
    if (result == null) {
       = result = createElementSet();
    }
    return result;
  }

  
Creates a new instance of this multiset's element set, which will be returned by elementSet().
    return new ElementSet();
  }
  class ElementSet extends Multisets.ElementSet<E> {
    @Override
    Multiset<E> multiset() {
      return AbstractMultiset.this;
    }
  }
  abstract Iterator<Entry<E>> entryIterator();
  abstract int distinctElements();
  private transient Set<Entry<E>> entrySet;
  public Set<Entry<E>> entrySet() {
    Set<Entry<E>> result = ;
    if (result == null) {
       = result = createEntrySet();
    }
    return result;
  }
  class EntrySet extends Multisets.EntrySet<E> {
    @Override
    Multiset<E> multiset() {
      return AbstractMultiset.this;
    }
    @Override
    public Iterator<Entry<E>> iterator() {
      return entryIterator();
    }
    @Override
    public int size() {
      return distinctElements();
    }
  }
    return new EntrySet();
  }
  // Object methods

  

This implementation returns true if object is a multiset of the same size and if, for each element, the two multisets have the same count.

  public boolean equals(@Nullable Object object) {
    return Multisets.equalsImpl(thisobject);
  }

  

This implementation returns the hash code of Multiset.entrySet().

  public int hashCode() {
    return entrySet().hashCode();
  }

  

This implementation returns the result of invoking toString on Multiset.entrySet().

  public String toString() {
    return entrySet().toString();
  }
New to GrepCode? Check out our FAQ X