HashBag (Goldman Sachs Collections

java.lang.Object
- com.gs.collections.impl.AbstractRichIterable<T>
- - com.gs.collections.impl.bag.AbstractBag<T>
  - - com.gs.collections.impl.bag.mutable.AbstractMutableBagIterable<T>
    - - com.gs.collections.impl.bag.mutable.AbstractMutableBag<T>
      - com.gs.collections.impl.bag.mutable.HashBag<T>

All Implemented Interfaces:

com.gs.collections.api.bag.Bag<T>, com.gs.collections.api.bag.MutableBag<T>, com.gs.collections.api.bag.MutableBagIterable<T>, com.gs.collections.api.bag.UnsortedBag<T>, com.gs.collections.api.collection.MutableCollection<T>, com.gs.collections.api.InternalIterable<T>, com.gs.collections.api.RichIterable<T>, java.io.Externalizable, java.io.Serializable, java.lang.Iterable<T>, java.util.Collection<T>
```
public class HashBag<T>
extends AbstractMutableBag<T>
implements java.io.Externalizable
```
A HashBag is a MutableBag which uses a Map as its underlying data store. Each key in the Map represents some item, and the value in the map represents the current number of occurrences of that item.

Since:

1.0

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description

HashBag()

HashBag(int size)

Constructors
Constructor and Description
`HashBag()`
`HashBag(int size)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(T item)`
`boolean`	`addAll(java.util.Collection<? extends T> source)`
`void`	`addOccurrences(T item, int occurrences)`
`void`	`clear()`
`boolean`	`contains(java.lang.Object o)` Returns true if the iterable has an element which responds true to element.equals(object).
`void`	`each(com.gs.collections.api.block.procedure.Procedure<? super T> procedure)` The procedure is executed for each element in the iterable.
`boolean`	`equals(java.lang.Object other)` Two bags`b1` and `b2` are equal if `m1.toMapOfItemToCount().equals(m2.toMapOfItemToCount())`.
`<P> void`	`forEachWith(com.gs.collections.api.block.procedure.Procedure2<? super T,? super P> procedure, P parameter)` The procedure2 is evaluated for each element in the iterable with the specified parameter provided as the second argument.
`void`	`forEachWithIndex(com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> objectIntProcedure)` Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.
`void`	`forEachWithOccurrences(com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> objectIntProcedure)` For each distinct item, with the number of occurrences, execute the specified procedure.
`protected com.gs.collections.api.RichIterable<T>`	`getKeysView()`
`<V> HashBagMultimap<V,T>`	`groupBy(com.gs.collections.api.block.function.Function<? super T,? extends V> function)` For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.
`<V> HashBagMultimap<V,T>`	`groupByEach(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function)` Similar to `RichIterable.groupBy(Function)`, except the result of evaluating function will return a collection of keys for each value.
`int`	`hashCode()` Returns the hash code for this Bag, defined as `this.Bag.toMapOfItemToCount().hashCode()`.
`boolean`	`isEmpty()` Returns true if this iterable has zero items.
`java.util.Iterator<T>`	`iterator()`
`static <E> HashBag<E>`	`newBag()`
`static <E> HashBag<E>`	`newBag(com.gs.collections.api.bag.Bag<? extends E> source)`
`static <E> HashBag<E>`	`newBag(int size)`
`static <E> HashBag<E>`	`newBag(java.lang.Iterable<? extends E> source)`
`static <E> HashBag<E>`	`newBagWith(E... elements)`
`com.gs.collections.api.bag.MutableBag<T>`	`newEmpty()` Creates a new empty mutable version of the same collection type.
`int`	`occurrencesOf(java.lang.Object item)` The occurrences of a distinct item in the bag.
`void`	`readExternal(java.io.ObjectInput in)`
`boolean`	`remove(java.lang.Object item)`
`boolean`	`removeAllIterable(java.lang.Iterable<?> iterable)`
`boolean`	`removeIf(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Removes all elements in the collection that evaluate to true for the specified predicate.
`<P> boolean`	`removeIfWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate, P parameter)` Removes all elements in the collection that evaluate to true for the specified predicate2 and parameter.
`boolean`	`removeOccurrences(java.lang.Object item, int occurrences)`
`com.gs.collections.api.bag.MutableBag<T>`	`selectByOccurrences(com.gs.collections.api.block.predicate.primitive.IntPredicate predicate)` Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
`boolean`	`setOccurrences(T item, int occurrences)`
`int`	`size()` Returns the number of items in this iterable.
`int`	`sizeDistinct()` The size of the Bag when counting only distinct elements.
`com.gs.collections.api.map.MutableMap<T,java.lang.Integer>`	`toMapOfItemToCount()` Converts the Bag to a Map of the Item type to its count as an Integer.
`HashBag<T>`	`with(T... elements)`
`HashBag<T>`	`with(T element)` This method allows mutable and fixed size collections the ability to add elements to their existing elements.
`HashBag<T>`	`with(T element1, T element2)`
`HashBag<T>`	`with(T element1, T element2, T element3)`
`HashBag<T>`	`withAll(java.lang.Iterable<? extends T> iterable)` This method allows mutable and fixed size collections the ability to add multiple elements to their existing elements.
`HashBag<T>`	`without(T element)` This method allows mutable and fixed size collections the ability to remove elements from their existing elements.
`HashBag<T>`	`withoutAll(java.lang.Iterable<? extends T> iterable)` This method allows mutable and fixed size collections the ability to remove multiple elements from their existing elements.
`void`	`writeExternal(java.io.ObjectOutput out)`

Methods inherited from class com.gs.collections.impl.bag.mutable.AbstractMutableBag
asParallel, asSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, flatCollect, partition, partitionWith, reject, rejectWith, select, selectInstancesOf, selectWith, tap, toImmutable, zip, zipWithIndex

Methods inherited from class com.gs.collections.impl.bag.mutable.AbstractMutableBagIterable
addAllIterable, aggregateBy, aggregateInPlaceBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, bottomOccurrences, chunk, detect, detectIfNone, detectWith, detectWithIfNone, getFirst, getLast, groupByUniqueKey, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, removeAll, retainAll, retainAllIterable, selectAndRejectWith, topOccurrences

Methods inherited from class com.gs.collections.impl.bag.AbstractBag
collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, count, flatCollect, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoWith, occurrencesSortingBy, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toList, toListWithOccurrences, toSet, toSortedBag, toSortedBag, toSortedList, toSortedSet, toSortedSet, toStringOfItemToCount

Methods inherited from class com.gs.collections.impl.AbstractRichIterable
appendString, appendString, appendString, asLazy, containsAll, containsAllArguments, containsAllIterable, countWith, forEach, groupByUniqueKey, makeString, makeString, makeString, notEmpty, sumByDouble, sumByFloat, sumByInt, sumByLong, toArray, toArray, toMap, toSortedBagBy, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSetBy, toString, zip, zipWithIndex

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.gs.collections.api.bag.MutableBagIterable
bottomOccurrences, topOccurrences

Methods inherited from interface com.gs.collections.api.bag.Bag
toStringOfItemToCount

Methods inherited from interface com.gs.collections.api.collection.MutableCollection
addAllIterable, aggregateBy, aggregateInPlaceBy, groupByUniqueKey, injectIntoWith, retainAllIterable, selectAndRejectWith

Methods inherited from interface java.util.Collection
containsAll, removeAll, retainAll, toArray, toArray

Methods inherited from interface com.gs.collections.api.RichIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, flatCollect, getFirst, getLast, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

Methods inherited from interface com.gs.collections.api.InternalIterable
forEach

- Constructor Detail
  - HashBag
```
public HashBag()
```
  - HashBag
```
public HashBag(int size)
```
- Method Detail
  - newBag
```
public static <E> HashBag<E> newBag()
```
  - newBag
```
public static <E> HashBag<E> newBag(int size)
```
  - newBag
```
public static <E> HashBag<E> newBag(com.gs.collections.api.bag.Bag<? extends E> source)
```
  - newBag
```
public static <E> HashBag<E> newBag(java.lang.Iterable<? extends E> source)
```
  - newBagWith
```
public static <E> HashBag<E> newBagWith(E... elements)
```
  - addAll
```
public boolean addAll(java.util.Collection<? extends T> source)
```
    Specified by:
    
    addAll in interface java.util.Collection<T>
    
    Overrides:
    
    addAll in class AbstractMutableBagIterable<T>
  - addOccurrences
```
public void addOccurrences(T item,
                  int occurrences)
```
    Specified by:
    
    addOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - equals
```
public boolean equals(java.lang.Object other)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Two bagsb1 and b2 are equal if m1.toMapOfItemToCount().equals(m2.toMapOfItemToCount()).
    
    Specified by:
    
    equals in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    equals in interface java.util.Collection<T>
    
    Overrides:
    
    equals in class java.lang.Object
    
    See Also:
    Map.equals(Object)
  - hashCode
```
public int hashCode()
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Returns the hash code for this Bag, defined as this.Bag.toMapOfItemToCount().hashCode().
    
    Specified by:
    
    hashCode in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    hashCode in interface java.util.Collection<T>
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    See Also:
    Map.hashCode()
  - getKeysView
```
protected com.gs.collections.api.RichIterable<T> getKeysView()
```
    Specified by:
    
    getKeysView in class AbstractMutableBagIterable<T>
  - sizeDistinct
```
public int sizeDistinct()
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    The size of the Bag when counting only distinct elements.
    
    Specified by:
    
    sizeDistinct in interface com.gs.collections.api.bag.Bag<T>
  - occurrencesOf
```
public int occurrencesOf(java.lang.Object item)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    The occurrences of a distinct item in the bag.
    
    Specified by:
    
    occurrencesOf in interface com.gs.collections.api.bag.Bag<T>
  - forEachWithOccurrences
```
public void forEachWithOccurrences(com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> objectIntProcedure)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    For each distinct item, with the number of occurrences, execute the specified procedure.
    
    Specified by:
    
    forEachWithOccurrences in interface com.gs.collections.api.bag.Bag<T>
  - selectByOccurrences
```
public com.gs.collections.api.bag.MutableBag<T> selectByOccurrences(com.gs.collections.api.block.predicate.primitive.IntPredicate predicate)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.UnsortedBag<T>
  - toMapOfItemToCount
```
public com.gs.collections.api.map.MutableMap<T,java.lang.Integer> toMapOfItemToCount()
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Converts the Bag to a Map of the Item type to its count as an Integer.
    
    Specified by:
    
    toMapOfItemToCount in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - remove
```
public boolean remove(java.lang.Object item)
```
    Specified by:
    
    remove in interface java.util.Collection<T>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Collection<T>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Returns true if this iterable has zero items.
    
    Specified by:
    
    isEmpty in interface com.gs.collections.api.RichIterable<T>
    
    Specified by:
    
    isEmpty in interface java.util.Collection<T>
    
    Overrides:
    
    isEmpty in class AbstractRichIterable<T>
  - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
    Specified by:
    
    writeExternal in interface java.io.Externalizable
    
    Throws:
    
    java.io.IOException
  - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
    Specified by:
    
    readExternal in interface java.io.Externalizable
    
    Throws:
    
    java.io.IOException
    
    java.lang.ClassNotFoundException
  - each
```
public void each(com.gs.collections.api.block.procedure.Procedure<? super T> procedure)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    The procedure is executed for each element in the iterable.
    Example using a Java 8 lambda expression:
```
 people.each(person -> LOGGER.info(person.getName()));
 
```
    Example using an anonymous inner class:
```
 people.each(new Procedure()
 {
     public void value(Person person)
     {
         LOGGER.info(person.getName());
     }
 });
 
```
    This method is a variant of InternalIterable.forEach(Procedure) that has a signature conflict with Iterable#forEach(java.util.function.Consumer).
    Specified by:
    
    each in interface com.gs.collections.api.RichIterable<T>
    
    See Also:
    InternalIterable.forEach(Procedure), Iterable#forEach(java.util.function.Consumer)
  - forEachWithIndex
```
public void forEachWithIndex(com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> objectIntProcedure)
```
    Description copied from interface: com.gs.collections.api.InternalIterable
    Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.
    Example using a Java 8 lambda:
```
 people.forEachWithIndex((Person person, int index) -> LOGGER.info("Index: " + index + " person: " + person.getName()));
 
```
    Example using an anonymous inner class:
```
 people.forEachWithIndex(new ObjectIntProcedure()
 {
     public void value(Person person, int index)
     {
         LOGGER.info("Index: " + index + " person: " + person.getName());
     }
 });
 
```
    Specified by:
    
    forEachWithIndex in interface com.gs.collections.api.InternalIterable<T>
    
    Overrides:
    
    forEachWithIndex in class AbstractRichIterable<T>
  - forEachWith
```
public <P> void forEachWith(com.gs.collections.api.block.procedure.Procedure2<? super T,? super P> procedure,
                   P parameter)
```
    Description copied from interface: com.gs.collections.api.InternalIterable
    The procedure2 is evaluated for each element in the iterable with the specified parameter provided as the second argument.
    Example using a Java 8 lambda:
```
 people.forEachWith((Person person, Person other) ->
     {
         if (person.isRelatedTo(other))
         {
              LOGGER.info(person.getName());
         }
     }, fred);
 
```
    Example using an anonymous inner class:
```
 people.forEachWith(new Procedure2()
 {
     public void value(Person person, Person other)
     {
         if (person.isRelatedTo(other))
         {
              LOGGER.info(person.getName());
         }
     }
 }, fred);
 
```
    Specified by:
    
    forEachWith in interface com.gs.collections.api.InternalIterable<T>
    
    Overrides:
    
    forEachWith in class AbstractRichIterable<T>
  - iterator
```
public java.util.Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<T>
    
    Specified by:
    
    iterator in interface java.util.Collection<T>
  - removeOccurrences
```
public boolean removeOccurrences(java.lang.Object item,
                        int occurrences)
```
    Specified by:
    
    removeOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - setOccurrences
```
public boolean setOccurrences(T item,
                     int occurrences)
```
    Specified by:
    
    setOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - without
```
public HashBag<T> without(T element)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to remove elements from their existing elements. In order to support fixed size a new instance of a collection would have to be returned contaning the elements that would be left from the original collection after calling remove. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.without("1");
 list = list.without("2");
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by without, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling remove on itself.
    Specified by:
    
    without in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    without in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    without in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.remove(Object)
  - newEmpty
```
public com.gs.collections.api.bag.MutableBag<T> newEmpty()
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    
    Creates a new empty mutable version of the same collection type. For example, if this instance is a FastList, this method will return a new empty FastList. If the class of this instance is immutable or fixed size (i.e. SingletonList) then a mutable alternative to the class will be provided.
    
    Specified by:
    
    newEmpty in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    newEmpty in interface com.gs.collections.api.collection.MutableCollection<T>
  - with
```
public HashBag<T> with(T element)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to add elements to their existing elements. In order to support fixed size a new instance of a collection would have to be returned taking the elements of the original collection and appending the new element to form the new collection. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.with("1");
 list = list.with("2");
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by with, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling add on itself.
    Specified by:
    
    with in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    with in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    with in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.add(Object)
  - withAll
```
public HashBag<T> withAll(java.lang.Iterable<? extends T> iterable)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to add multiple elements to their existing elements. In order to support fixed size a new instance of a collection would have to be returned taking the elements of the original collection and appending the new elements to form the new collection. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.withAll(FastList.newListWith("1", "2"));
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by withAll, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling addAll on itself.
    Specified by:
    
    withAll in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    withAll in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    withAll in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.addAll(Collection)
  - withoutAll
```
public HashBag<T> withoutAll(java.lang.Iterable<? extends T> iterable)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to remove multiple elements from their existing elements. In order to support fixed size a new instance of a collection would have to be returned contaning the elements that would be left from the original collection after calling removeAll. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.withoutAll(FastList.newListWith("1", "2"));
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by withoutAll, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling removeAll on itself.
    Specified by:
    
    withoutAll in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    withoutAll in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    withoutAll in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.removeAll(Collection)
  - removeIf
```
public boolean removeIf(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    Removes all elements in the collection that evaluate to true for the specified predicate.
```
e.g.
 return lastNames.removeIf(Predicates.isNull());
 
```
    Specified by:
    
    removeIf in interface com.gs.collections.api.collection.MutableCollection<T>
  - removeIfWith
```
public <P> boolean removeIfWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate,
                       P parameter)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    Removes all elements in the collection that evaluate to true for the specified predicate2 and parameter.
```
e.g.
 return lastNames.removeIfWith(PredicatesLite.isNull(), null);
 
```
    Specified by:
    
    removeIfWith in interface com.gs.collections.api.collection.MutableCollection<T>
  - removeAllIterable
```
public boolean removeAllIterable(java.lang.Iterable<?> iterable)
```
    Specified by:
    
    removeAllIterable in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.removeAll(Collection)
  - size
```
public int size()
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Returns the number of items in this iterable.
    
    Specified by:
    
    size in interface com.gs.collections.api.RichIterable<T>
    
    Specified by:
    
    size in interface java.util.Collection<T>
  - contains
```
public boolean contains(java.lang.Object o)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Returns true if the iterable has an element which responds true to element.equals(object).
    
    Specified by:
    
    contains in interface com.gs.collections.api.RichIterable<T>
    
    Specified by:
    
    contains in interface java.util.Collection<T>
    
    Overrides:
    
    contains in class AbstractRichIterable<T>
  - groupBy
```
public <V> HashBagMultimap<V,T> groupBy(com.gs.collections.api.block.function.Function<? super T,? extends V> function)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.
    Example using a Java 8 method reference:
```
 Multimap<String, Person> peopleByLastName =
     people.groupBy(Person::getLastName);
 
```
    Example using an anonymous inner class:
```
 Multimap<String, Person> peopleByLastName =
     people.groupBy(new Function<Person, String>()
     {
         public String value(Person person)
         {
             return person.getLastName();
         }
     });
 
```
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.UnsortedBag<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.RichIterable<T>
  - groupByEach
```
public <V> HashBagMultimap<V,T> groupByEach(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Similar to RichIterable.groupBy(Function), except the result of evaluating function will return a collection of keys for each value.
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.MutableBag<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.UnsortedBag<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.RichIterable<T>
  - with
```
public HashBag<T> with(T... elements)
```
  - with
```
public HashBag<T> with(T element1,
              T element2)
```
  - add
```
public boolean add(T item)
```
    Specified by:
    
    add in interface java.util.Collection<T>
  - with
```
public HashBag<T> with(T element1,
              T element2,
              T element3)
```

Class HashBag<T>

Constructor Summary

Method Summary

Methods inherited from class com.gs.collections.impl.bag.mutable.AbstractMutableBag

Methods inherited from class com.gs.collections.impl.bag.mutable.AbstractMutableBagIterable

Methods inherited from class com.gs.collections.impl.bag.AbstractBag

Methods inherited from class com.gs.collections.impl.AbstractRichIterable

Methods inherited from class java.lang.Object

Methods inherited from interface com.gs.collections.api.bag.MutableBagIterable

Methods inherited from interface com.gs.collections.api.bag.Bag

Methods inherited from interface com.gs.collections.api.collection.MutableCollection

Methods inherited from interface java.util.Collection

Methods inherited from interface com.gs.collections.api.RichIterable

Methods inherited from interface com.gs.collections.api.InternalIterable

Constructor Detail

HashBag

HashBag

Method Detail

newBag

newBag

newBag

newBag

newBagWith

addAll

addOccurrences

equals

hashCode

getKeysView

sizeDistinct

occurrencesOf

forEachWithOccurrences

selectByOccurrences

toMapOfItemToCount

remove

clear

isEmpty

writeExternal

readExternal

each

forEachWithIndex

forEachWith

iterator

removeOccurrences

setOccurrences

without

newEmpty

with

withAll

withoutAll

removeIf

removeIfWith

removeAllIterable

size

contains

groupBy

groupByEach

with

with

add

with