Same as {@link #empty()}.

Runs the {@link Callable} {@code code} and asserts that it throws an {@code Exception} of the type {@code expectedExceptionClass}. <p> {@code Callable

Creates a new list using the passed {@code elements} argument as the backing store. <p> !!! WARNING: This method uses the passed in array, so can be v

Locates an object in the pool which is equal to {@code key}. @param key the value to look for @return The object reference in the pool equal to key o

@since 6.0

Assert the size of the given array.

Puts {@code key} into the pool. If there is no existing object that is equal to key, key will be added to the pool and the return value will be the sa

{@inheritDoc} Implementations are expected to delegate to {@link MutableBiMap#put(Object, Object)}, {@link ImmutableBiMap#newWithKeyValue(Object, Obj

Two bags {@code b1} and {@code b2} are equal if {@code m1.toMapOfItemToCount().equals(m2.toMapOfItemToCount())}. @see Map#equals(Object)

Returns a string with the elements of this iterable separated by commas with spaces and enclosed in square brackets. <pre> Assert.assertEquals("[]",

Converts the collection to a MutableList implementation. @since 1.0

Returns an Interval starting from 1 to the specified count value with a step value of 1.

Uses the natural compareTo methods of the objects which will throw if there are any nulls.

Assert that the given object is an instanceof expectedClassType.

@throws UnsupportedOperationException the {@code remove} operation is not supported by this map.

Assert that the given {@link Iterable} is empty.

@throws UnsupportedOperationException the {@code putAll} operation is not supported by this map.

Modification operation similar to put, however, takes the key-value pair as the input. @param keyValuePair key value pair to add in the multimap @see

Returns an unmodifiable {@link SetIterable} of keys with O(1) complexity.

Converts the collection to a MutableSet implementation. @since 1.0

Returns true if all elements in source are contained in this collection. @see Collection#containsAll(Collection) @since 1.0

Assert that the given {@code stringToFind} is contained within the {@code stringToSearch}.

Converts the collection to the default MutableBag implementation. @since 1.0

Returns the comparator used to order the elements in this bag, or null if this bag uses the natural ordering of its elements.

Returns true if the iterable has an element which responds true to element.equals(object). @since 1.0

@since 9.0

Assert that {@code objectA} and {@code objectB} are equal via the {@link Object#equals(Object)} method, and that they both return the same {@link Obje

@throws UnsupportedOperationException the {@code addAll} operation is not supported by this collection.

Returns a reversed view of this ReversibleIterable.

Returns true if this iterable has zero items. @since 1.0

Returns the hash code for this Bag, defined as <em>this.{@link #toMapOfItemToCount()}.hashCode()</em>. @see Map#hashCode()

This method must be wrapped in a try block.

Returns a lazy (deferred) iterable, most likely implemented by calling LazyIterate.adapt(this). @since 1.0.

Returns an Interval starting from the value from to the specified value to with a step value of 1.

Same as {@link #empty()}. but takes in initial capacity. @since 11.1.

@since 9.0

Add number of {@code occurrences} for an {@code item}. If the {@code item} does not exist, then the {@code item} is added to the bag. <p> For Example

Returns the last element of an iterable. In the case of a List it is the element at the last index. In the case of any other Collection, it is the las

Prints a string representation of this collection onto the given {@code Appendable}. Prints the string returned by {@link #makeString()}. @since 1.0

Same as {@link #withAll(Iterable)}.

Returns {@code true} if any values are mapped to the specified key. @param key the key to search for

Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure. <p> Example using

Returns the final result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected