Package | Description |
---|---|
com.google.common.collect |
This package contains generic collection interfaces and implementations, and other utilities for
working with collections.
|
Modifier and Type | Field and Description |
---|---|
(package private) A |
Streams.TemporaryPair.a |
(package private) B |
Streams.TemporaryPair.b |
private C |
Tables.ImmutableCell.columnKey |
private E |
Multisets.ImmutableEntry.element |
(package private) E |
Lists.OnePlusArrayList.first |
(package private) E |
Lists.TwoPlusArrayList.first |
(package private) K |
AbstractMapBasedMultimap.WrappedCollection.key |
private K |
CompactHashMap.MapEntry.key |
private K |
FilteredEntryMultimap.ValuePredicate.key |
(package private) K |
FilteredKeyMultimap.AddRejectingSet.key |
(package private) K |
FilteredKeyMultimap.AddRejectingList.key |
(package private) K |
ImmutableEntry.key |
private K |
LinkedHashMultimap.ValueSet.key |
(package private) K |
LinkedListMultimap.Node.key |
(package private) K |
LinkedListMultimap.ValueForKeyIterator.key |
private V |
Maps.ValueDifferenceImpl.left |
private V |
Maps.ValueDifferenceImpl.right |
private R |
Tables.ImmutableCell.rowKey |
(package private) E |
Lists.TwoPlusArrayList.second |
(package private) V |
ImmutableEntry.value |
(package private) V |
LinkedListMultimap.Node.value |
private V |
Tables.ImmutableCell.value |
Modifier and Type | Method and Description |
---|---|
R |
Streams.DoubleFunctionWithIndex.apply(double from,
long index)
Applies this function to the given argument and its index within a stream.
|
R |
Streams.IntFunctionWithIndex.apply(int from,
long index)
Applies this function to the given argument and its index within a stream.
|
R |
Streams.LongFunctionWithIndex.apply(long from,
long index)
Applies this function to the given argument and its index within a stream.
|
R |
Streams.FunctionWithIndex.apply(T from,
long index)
Applies this function to the given argument and its index within a stream.
|
(package private) K |
AbstractBiMap.checkKey(K key)
Returns its input, or throws an exception if this is not a valid key.
|
(package private) K |
AbstractBiMap.Inverse.checkKey(K key) |
(package private) V |
AbstractBiMap.checkValue(V value)
Returns its input, or throws an exception if this is not a valid value.
|
(package private) V |
AbstractBiMap.Inverse.checkValue(V value) |
E |
ForwardingQueue.element() |
static <T> T |
Iterables.find(java.lang.Iterable<T> iterable,
Predicate<? super T> predicate)
Returns the first element in
iterable that satisfies the given predicate; use this
method only when such an element is known to exist. |
static <T> T |
Iterators.find(java.util.Iterator<T> iterator,
Predicate<? super T> predicate)
Returns the first element in
iterator that satisfies the given predicate; use this
method only when such an element is known to exist. |
V |
AbstractMapBasedMultimap.WrappedSortedSet.first() |
K |
AbstractMapBasedMultimap.SortedKeySet.first() |
E |
ForwardingSortedSet.first() |
K |
Maps.FilteredEntrySortedMap.SortedKeySet.first() |
K |
Maps.SortedKeySet.first() |
E |
Sets.FilteredSortedSet.first() |
E |
Sets.DescendingSet.first() |
E |
SortedMultisets.ElementSet.first() |
K |
AbstractMapBasedMultimap.SortedAsMap.firstKey() |
K |
AbstractNavigableMap.firstKey() |
K |
ForwardingSortedMap.firstKey() |
K |
Maps.SortedAsMapView.firstKey() |
K |
Maps.TransformedEntriesSortedMap.firstKey() |
K |
Maps.FilteredEntrySortedMap.firstKey() |
K |
Maps.DescendingMap.firstKey() |
protected abstract E |
AbstractIndexedListIterator.get(int index)
Returns the element with the specified index.
|
V |
AbstractMapBasedMultimap.WrappedList.get(int index) |
E |
FluentIterable.get(int position)
Returns the element at the specified position in this fluent iterable.
|
E |
ForwardingList.get(int index) |
protected T |
Iterators.ArrayItr.get(int index) |
E |
Lists.OnePlusArrayList.get(int index) |
E |
Lists.TwoPlusArrayList.get(int index) |
T |
Lists.TransformingRandomAccessList.get(int index) |
T |
Lists.ReverseList.get(int index) |
E |
Lists.AbstractListWrapper.get(int index) |
static <T> T |
Iterables.get(java.lang.Iterable<? extends T> iterable,
int position,
T defaultValue)
Returns the element at the specified position in an iterable or a default value otherwise.
|
static <T> T |
Iterables.get(java.lang.Iterable<T> iterable,
int position)
Returns the element at the specified position in an iterable.
|
static <T> T |
Iterators.get(java.util.Iterator<? extends T> iterator,
int position,
T defaultValue)
Advances
iterator position + 1 times, returning the element at the position th position or defaultValue otherwise. |
static <T> T |
Iterators.get(java.util.Iterator<T> iterator,
int position)
Advances
iterator position + 1 times, returning the element at the position th position. |
C |
Table.Cell.getColumnKey()
Returns the column key of this cell.
|
C |
Tables.ImmutableCell.getColumnKey() |
E |
Multiset.Entry.getElement()
Returns the multiset element corresponding to this entry.
|
E |
Multisets.ImmutableEntry.getElement() |
(package private) E |
TreeMultiset.AvlNode.getElement() |
E |
ForwardingDeque.getFirst() |
static <T> T |
Iterables.getFirst(java.lang.Iterable<? extends T> iterable,
T defaultValue)
Returns the first element in
iterable or defaultValue if the iterable is empty. |
(package private) K |
AbstractMapBasedMultimap.WrappedCollection.getKey() |
abstract K |
AbstractMapEntry.getKey() |
K |
CompactHashMap.MapEntry.getKey() |
K |
ForwardingMapEntry.getKey() |
K |
ImmutableEntry.getKey() |
K |
LinkedListMultimap.Node.getKey() |
E |
ForwardingDeque.getLast() |
static <T> T |
Iterables.getLast(java.lang.Iterable<? extends T> iterable,
T defaultValue)
Returns the last element of
iterable or defaultValue if the iterable is empty. |
static <T> T |
Iterables.getLast(java.lang.Iterable<T> iterable)
Returns the last element of
iterable . |
static <T> T |
Iterators.getLast(java.util.Iterator<? extends T> iterator,
T defaultValue)
Advances
iterator to the end, returning the last element or defaultValue if the
iterator is empty. |
static <T> T |
Iterators.getLast(java.util.Iterator<T> iterator)
Advances
iterator to the end, returning the last element. |
private static <T> T |
Iterables.getLastInNonemptyList(java.util.List<T> list) |
static <T> T |
Iterators.getNext(java.util.Iterator<? extends T> iterator,
T defaultValue)
Returns the next element in
iterator or defaultValue if the iterator is empty. |
static <T> T |
Iterables.getOnlyElement(java.lang.Iterable<? extends T> iterable,
T defaultValue)
Returns the single element contained in
iterable , or defaultValue if the
iterable is empty. |
static <T> T |
Iterables.getOnlyElement(java.lang.Iterable<T> iterable)
Returns the single element contained in
iterable . |
static <T> T |
Iterators.getOnlyElement(java.util.Iterator<? extends T> iterator,
T defaultValue)
Returns the single element contained in
iterator , or defaultValue if the
iterator is empty. |
static <T> T |
Iterators.getOnlyElement(java.util.Iterator<T> iterator)
Returns the single element contained in
iterator . |
(package private) abstract T |
CompactHashMap.Itr.getOutput(int entry) |
R |
Table.Cell.getRowKey()
Returns the row key of this cell.
|
R |
Tables.ImmutableCell.getRowKey() |
abstract V |
AbstractMapEntry.getValue() |
V |
CompactHashMap.MapEntry.getValue() |
V |
ForwardingMapEntry.getValue() |
V |
ImmutableEntry.getValue() |
V |
LinkedListMultimap.Node.getValue() |
V |
Table.Cell.getValue()
Returns the value of this cell.
|
V |
Tables.ImmutableCell.getValue() |
(package private) abstract V |
ArrayTable.ArrayMap.getValue(int index) |
V |
AbstractMapBasedMultimap.WrappedSortedSet.last() |
K |
AbstractMapBasedMultimap.SortedKeySet.last() |
E |
ForwardingSortedSet.last() |
K |
Maps.FilteredEntrySortedMap.SortedKeySet.last() |
K |
Maps.SortedKeySet.last() |
E |
Sets.FilteredSortedSet.last() |
E |
Sets.FilteredNavigableSet.last() |
E |
Sets.DescendingSet.last() |
E |
SortedMultisets.ElementSet.last() |
K |
AbstractMapBasedMultimap.SortedAsMap.lastKey() |
K |
AbstractNavigableMap.lastKey() |
K |
ForwardingSortedMap.lastKey() |
K |
Maps.SortedAsMapView.lastKey() |
K |
Maps.TransformedEntriesSortedMap.lastKey() |
K |
Maps.FilteredEntrySortedMap.lastKey() |
K |
Maps.DescendingMap.lastKey() |
V |
MapDifference.ValueDifference.leftValue()
Returns the value from the left map (possibly null).
|
V |
Maps.ValueDifferenceImpl.leftValue() |
<E extends T> |
Ordering.max(E a,
E b)
Returns the greater of the two values according to this ordering.
|
<E extends T> |
Ordering.max(E a,
E b,
E c,
E... rest)
Returns the greatest of the specified values according to this ordering.
|
<E extends T> |
Ordering.max(java.lang.Iterable<E> iterable)
Returns the greatest of the specified values according to this ordering.
|
<E extends T> |
Ordering.max(java.util.Iterator<E> iterator)
Returns the greatest of the specified values according to this ordering.
|
static <T> T |
Comparators.max(T a,
T b,
java.util.Comparator<T> comparator)
Returns the maximum of the two values, according to the given comparator.
|
<E extends T> |
Ordering.min(E a,
E b)
Returns the lesser of the two values according to this ordering.
|
<E extends T> |
Ordering.min(E a,
E b,
E c,
E... rest)
Returns the least of the specified values according to this ordering.
|
<E extends T> |
Ordering.min(java.lang.Iterable<E> iterable)
Returns the least of the specified values according to this ordering.
|
<E extends T> |
Ordering.min(java.util.Iterator<E> iterator)
Returns the least of the specified values according to this ordering.
|
static <T> T |
Comparators.min(T a,
T b,
java.util.Comparator<T> comparator)
Returns the minimum of the two values, according to the given comparator.
|
E |
AbstractIndexedListIterator.next() |
T |
AbstractIterator.next() |
V |
AbstractMapBasedMultimap.WrappedCollection.WrappedIterator.next() |
E |
AbstractMapBasedMultiset.MapBasedMultisetIterator.next() |
T |
CompactHashMap.Itr.next() |
T |
ForwardingIterator.next() |
E |
Iterators.PeekingImpl.next() |
T |
Iterators.MergingIterator.next() |
T |
Iterators.ConcatenatedIterator.next() |
K |
LinkedListMultimap.DistinctKeyIterator.next() |
V |
LinkedListMultimap.ValueForKeyIterator.next() |
E |
Multisets.MultisetIteratorImpl.next() |
E |
PeekingIterator.next() |
T |
TransformedIterator.next() |
T |
AbstractIterator.peek()
Returns the next element in the iteration without advancing the iteration, according to the
contract of
PeekingIterator.peek() . |
E |
Iterators.PeekingImpl.peek() |
E |
PeekingIterator.peek()
Returns the next element in the iteration, without advancing the iteration.
|
E |
ForwardingDeque.pop() |
E |
AbstractIndexedListIterator.previous() |
V |
AbstractMapBasedMultimap.WrappedList.WrappedListIterator.previous() |
E |
ForwardingListIterator.previous() |
V |
LinkedListMultimap.ValueForKeyIterator.previous() |
T |
TransformedListIterator.previous() |
E |
ForwardingQueue.remove() |
V |
AbstractMapBasedMultimap.WrappedList.remove(int index) |
E |
ForwardingList.remove(int index) |
T |
Lists.TransformingRandomAccessList.remove(int index) |
T |
Lists.ReverseList.remove(int index) |
E |
Lists.AbstractListWrapper.remove(int index) |
E |
ForwardingDeque.removeFirst() |
private V |
AbstractBiMap.removeFromBothMaps(java.lang.Object key) |
E |
ForwardingDeque.removeLast() |
V |
MapDifference.ValueDifference.rightValue()
Returns the value from the right map (possibly null).
|
V |
Maps.ValueDifferenceImpl.rightValue() |
E |
ForwardingList.set(int index,
E element) |
E |
Lists.AbstractListWrapper.set(int index,
E element) |
T |
Lists.ReverseList.set(int index,
T element) |
V |
AbstractMapBasedMultimap.WrappedList.set(int index,
V element) |
(package private) abstract V |
ArrayTable.ArrayMap.setValue(int index,
V newValue) |
V |
AbstractMapEntry.setValue(V value) |
V |
CompactHashMap.MapEntry.setValue(V value) |
V |
ForwardingMapEntry.setValue(V value) |
V |
ImmutableEntry.setValue(V value) |
V |
LinkedListMultimap.Node.setValue(V newValue) |
protected E |
ForwardingNavigableSet.standardFirst() |
protected E |
ForwardingNavigableSet.standardLast() |
(package private) abstract T |
TransformedIterator.transform(F from) |
(package private) static <T> T |
NullnessCasts.uncheckedCastNullableTToT(T t)
Accepts a
@Nullable T and returns a plain T , without performing any check that
that conversion is safe. |
(package private) static <T> T |
NullnessCasts.unsafeNull()
Returns
null as any type, even one that does not include null . |
Modifier and Type | Method and Description |
---|---|
(package private) TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.add(java.util.Comparator<? super E> comparator,
E e,
int count,
int[] result) |
boolean |
AbstractMultiset.add(E element) |
boolean |
Collections2.FilteredCollection.add(E element) |
boolean |
CompactHashSet.add(E object) |
boolean |
ForwardingCollection.add(E element) |
void |
ForwardingListIterator.add(E element) |
boolean |
Multiset.add(E element)
Adds a single occurrence of the specified element to this multiset.
|
boolean |
Multisets.UnmodifiableMultiset.add(E element) |
boolean |
Sets.SetView.add(E e)
Deprecated.
Unsupported operation.
|
void |
UnmodifiableListIterator.add(E e)
Deprecated.
Unsupported operation.
|
int |
AbstractMapBasedMultiset.add(E element,
int occurrences)
Adds a number of occurrences of an element to this multiset.
|
int |
AbstractMultiset.add(E element,
int occurrences) |
int |
ForwardingMultiset.add(E element,
int occurrences) |
int |
Multiset.add(E element,
int occurrences)
Adds a number of occurrences of an element to this multiset.
|
int |
Multisets.UnmodifiableMultiset.add(E element,
int occurrences) |
int |
Multisets.FilteredMultiset.add(E element,
int occurrences) |
int |
TreeMultiset.add(E element,
int occurrences) |
void |
ForwardingList.add(int index,
E element) |
void |
Lists.AbstractListWrapper.add(int index,
E element) |
void |
Lists.ReverseList.add(int index,
T element) |
void |
AbstractMapBasedMultimap.WrappedList.add(int index,
V element) |
void |
FilteredKeyMultimap.AddRejectingList.add(int index,
V element) |
void |
TransformedListIterator.add(T element) |
boolean |
AbstractMapBasedMultimap.WrappedCollection.add(V value) |
void |
AbstractMapBasedMultimap.WrappedList.WrappedListIterator.add(V value) |
boolean |
FilteredKeyMultimap.AddRejectingSet.add(V element) |
boolean |
FilteredKeyMultimap.AddRejectingList.add(V v) |
boolean |
LinkedHashMultimap.ValueSet.add(V value) |
void |
LinkedListMultimap.ValueForKeyIterator.add(V value) |
void |
ForwardingDeque.addFirst(E e) |
void |
ForwardingDeque.addLast(E e) |
private TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.addLeftChild(E e,
int count) |
private LinkedListMultimap.Node<K,V> |
LinkedListMultimap.addNode(K key,
V value,
LinkedListMultimap.Node<K,V> nextSibling)
Adds a new node for the specified key-value pair before the specified
nextSibling
element, or at the end of the list if nextSibling is null. |
private LinkedListMultimap.Node<K,V> |
LinkedListMultimap.addNode(K key,
V value,
LinkedListMultimap.Node<K,V> nextSibling)
Adds a new node for the specified key-value pair before the specified
nextSibling
element, or at the end of the list if nextSibling is null. |
private TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.addRightChild(E e,
int count) |
(package private) boolean |
Maps.AbstractFilteredMap.apply(java.lang.Object key,
V value) |
R |
Streams.FunctionWithIndex.apply(T from,
long index)
Applies this function to the given argument and its index within a stream.
|
boolean |
FilteredEntryMultimap.ValuePredicate.apply(V value) |
static <E> java.util.List<E> |
Lists.asList(E first,
E[] rest)
Returns an unmodifiable list containing the specified first element and backed by the specified
array of additional elements.
|
static <E> java.util.List<E> |
Lists.asList(E first,
E second,
E[] rest)
Returns an unmodifiable list containing the specified first and second element, and backed by
the specified array of additional elements.
|
static <E> java.util.List<E> |
Lists.asList(E first,
E second,
E[] rest)
Returns an unmodifiable list containing the specified first and second element, and backed by
the specified array of additional elements.
|
(package private) static <K,V1,V2> Function<V1,V2> |
Maps.asValueToValueFunction(Maps.EntryTransformer<? super K,V1,V2> transformer,
K key) |
static <E> int |
SortedLists.binarySearch(java.util.List<? extends E> list,
E key,
java.util.Comparator<? super E> comparator,
SortedLists.KeyPresentBehavior presentBehavior,
SortedLists.KeyAbsentBehavior absentBehavior)
Searches the specified list for the specified object using the binary search algorithm.
|
int |
Ordering.binarySearch(java.util.List<? extends T> sortedList,
T key)
Deprecated.
Use
Collections.binarySearch(List, Object, Comparator) directly. |
static <E,K> int |
SortedLists.binarySearch(java.util.List<E> list,
Function<? super E,K> keyFunction,
K key,
java.util.Comparator<? super K> keyComparator,
SortedLists.KeyPresentBehavior presentBehavior,
SortedLists.KeyAbsentBehavior absentBehavior)
Binary searches the list for the specified key, using the specified key function.
|
private TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.ceiling(java.util.Comparator<? super E> comparator,
E e) |
E |
ForwardingNavigableSet.ceiling(E e) |
E |
Sets.FilteredNavigableSet.ceiling(E e) |
E |
Sets.UnmodifiableNavigableSet.ceiling(E e) |
E |
Sets.DescendingSet.ceiling(E e) |
E |
SortedMultisets.NavigableElementSet.ceiling(E e) |
K |
AbstractMapBasedMultimap.NavigableKeySet.ceiling(K k) |
K |
Maps.NavigableKeySet.ceiling(K e) |
V |
AbstractMapBasedMultimap.WrappedNavigableSet.ceiling(V v) |
java.util.Map.Entry<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.ceilingEntry(K key) |
java.util.Map.Entry<K,V> |
AbstractNavigableMap.ceilingEntry(K key) |
java.util.Map.Entry<K,V> |
ForwardingNavigableMap.ceilingEntry(K key) |
java.util.Map.Entry<K,V2> |
Maps.TransformedEntriesNavigableMap.ceilingEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.UnmodifiableNavigableMap.ceilingEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.DescendingMap.ceilingEntry(K key) |
K |
AbstractMapBasedMultimap.NavigableAsMap.ceilingKey(K key) |
K |
AbstractNavigableMap.ceilingKey(K key) |
K |
ForwardingNavigableMap.ceilingKey(K key) |
K |
Maps.TransformedEntriesNavigableMap.ceilingKey(K key) |
K |
Maps.UnmodifiableNavigableMap.ceilingKey(K key) |
K |
Maps.DescendingMap.ceilingKey(K key) |
(package private) K |
AbstractBiMap.checkKey(K key)
Returns its input, or throws an exception if this is not a valid key.
|
(package private) K |
AbstractBiMap.Inverse.checkKey(K key) |
(package private) V |
AbstractBiMap.checkValue(V value)
Returns its input, or throws an exception if this is not a valid value.
|
(package private) V |
AbstractBiMap.Inverse.checkValue(V value) |
java.util.Map<R,V> |
ForwardingTable.column(C columnKey) |
java.util.Map<R,V> |
Table.column(C columnKey)
Returns a view of all mappings that have the given column key.
|
java.util.Map<R,V2> |
Tables.TransformedTable.column(C columnKey) |
java.util.Map<R,V> |
Tables.UnmodifiableTable.column(C columnKey) |
java.util.Map<C,V> |
Tables.TransposeTable.column(R columnKey) |
int |
ByFunctionOrdering.compare(F left,
F right) |
int |
ByFunctionOrdering.compare(F left,
F right) |
int |
ComparatorOrdering.compare(T a,
T b) |
int |
ComparatorOrdering.compare(T a,
T b) |
int |
CompoundOrdering.compare(T left,
T right) |
int |
CompoundOrdering.compare(T left,
T right) |
abstract int |
Ordering.compare(T left,
T right) |
abstract int |
Ordering.compare(T left,
T right) |
int |
ReverseOrdering.compare(T a,
T b) |
int |
ReverseOrdering.compare(T a,
T b) |
abstract <T> ComparisonChain |
ComparisonChain.compare(T left,
T right,
java.util.Comparator<T> comparator)
Compares two objects using a comparator, if the result of this comparison chain has not
already been determined.
|
abstract <T> ComparisonChain |
ComparisonChain.compare(T left,
T right,
java.util.Comparator<T> comparator)
Compares two objects using a comparator, if the result of this comparison chain has not
already been determined.
|
<T> ComparisonChain |
ComparisonChain.InactiveComparisonChain.compare(T left,
T right,
java.util.Comparator<T> comparator) |
<T> ComparisonChain |
ComparisonChain.InactiveComparisonChain.compare(T left,
T right,
java.util.Comparator<T> comparator) |
static <T> T[] |
ObjectArrays.concat(T[] array,
T element)
Returns a new array that appends
element to array . |
static <T> T[] |
ObjectArrays.concat(T element,
T[] array)
Returns a new array that prepends
element to array . |
(package private) boolean |
GeneralRange.contains(T t) |
(package private) int |
TreeMultiset.AvlNode.count(java.util.Comparator<? super E> comparator,
E e) |
(package private) static <V> MapDifference.ValueDifference<V> |
Maps.ValueDifferenceImpl.create(V left,
V right) |
(package private) static <V> MapDifference.ValueDifference<V> |
Maps.ValueDifferenceImpl.create(V left,
V right) |
(package private) java.util.Collection<V> |
AbstractMapBasedMultimap.createCollection(K key)
Creates the collection of values for an explicitly provided key.
|
(package private) java.util.Collection<V> |
LinkedHashMultimap.createCollection(K key)
Creates the collection of values for an explicitly provided key.
|
(package private) java.util.Collection<V> |
TreeMultimap.createCollection(K key) |
(package private) static <T> GeneralRange<T> |
GeneralRange.downTo(java.util.Comparator<? super T> comparator,
T endpoint,
BoundType boundType)
Returns everything above the endpoint relative to the specified comparator, with the specified
endpoint behavior.
|
private TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.floor(java.util.Comparator<? super E> comparator,
E e) |
E |
ForwardingNavigableSet.floor(E e) |
E |
Sets.FilteredNavigableSet.floor(E e) |
E |
Sets.UnmodifiableNavigableSet.floor(E e) |
E |
Sets.DescendingSet.floor(E e) |
E |
SortedMultisets.NavigableElementSet.floor(E e) |
K |
AbstractMapBasedMultimap.NavigableKeySet.floor(K k) |
K |
Maps.NavigableKeySet.floor(K e) |
V |
AbstractMapBasedMultimap.WrappedNavigableSet.floor(V v) |
java.util.Map.Entry<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.floorEntry(K key) |
java.util.Map.Entry<K,V> |
AbstractNavigableMap.floorEntry(K key) |
java.util.Map.Entry<K,V> |
ForwardingNavigableMap.floorEntry(K key) |
java.util.Map.Entry<K,V2> |
Maps.TransformedEntriesNavigableMap.floorEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.UnmodifiableNavigableMap.floorEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.DescendingMap.floorEntry(K key) |
K |
AbstractMapBasedMultimap.NavigableAsMap.floorKey(K key) |
K |
AbstractNavigableMap.floorKey(K key) |
K |
ForwardingNavigableMap.floorKey(K key) |
K |
Maps.TransformedEntriesNavigableMap.floorKey(K key) |
K |
Maps.UnmodifiableNavigableMap.floorKey(K key) |
K |
Maps.DescendingMap.floorKey(K key) |
V |
AbstractBiMap.forcePut(K key,
V value) |
V |
AbstractBiMap.forcePut(K key,
V value) |
V |
BiMap.forcePut(K key,
V value)
An alternate form of
put that silently removes any existing entry with the value value before proceeding with the BiMap.put(K, V) operation. |
V |
BiMap.forcePut(K key,
V value)
An alternate form of
put that silently removes any existing entry with the value value before proceeding with the BiMap.put(K, V) operation. |
V |
EnumHashBiMap.forcePut(K key,
V value) |
V |
HashBiMap.forcePut(K key,
V value) |
V |
HashBiMap.forcePut(K key,
V value) |
V |
Maps.UnmodifiableBiMap.forcePut(K key,
V value) |
V |
Maps.UnmodifiableBiMap.forcePut(K key,
V value) |
V |
Maps.FilteredEntryBiMap.forcePut(K key,
V value) |
V |
Maps.FilteredEntryBiMap.forcePut(K key,
V value) |
K |
HashBiMap.Inverse.forcePut(V value,
K key) |
K |
HashBiMap.Inverse.forcePut(V value,
K key) |
static <T> T |
Iterables.get(java.lang.Iterable<? extends T> iterable,
int position,
T defaultValue)
Returns the element at the specified position in an iterable or a default value otherwise.
|
static <T> T |
Iterators.get(java.util.Iterator<? extends T> iterator,
int position,
T defaultValue)
Advances
iterator position + 1 times, returning the element at the position th position or defaultValue otherwise. |
java.util.List<V> |
AbstractListMultimap.get(K key)
Returns a view collection of the values associated with
key in this multimap, if any. |
java.util.Collection<V> |
AbstractMapBasedMultimap.get(K key)
Returns a view collection of the values associated with
key in this multimap, if any. |
java.util.Set<V> |
AbstractSetMultimap.get(K key)
Returns a view collection of the values associated with
key in this multimap, if any. |
java.util.SortedSet<V> |
AbstractSortedSetMultimap.get(K key)
Returns a collection view of all values associated with a key.
|
java.util.Collection<V> |
FilteredEntryMultimap.get(K key) |
java.util.Set<V> |
FilteredEntrySetMultimap.get(K key) |
java.util.List<V> |
FilteredKeyListMultimap.get(K key) |
java.util.Collection<V> |
FilteredKeyMultimap.get(K key) |
java.util.Set<V> |
FilteredKeySetMultimap.get(K key) |
java.util.List<V> |
ForwardingListMultimap.get(K key) |
java.util.Collection<V> |
ForwardingMultimap.get(K key) |
java.util.Set<V> |
ForwardingSetMultimap.get(K key) |
java.util.SortedSet<V> |
ForwardingSortedSetMultimap.get(K key) |
java.util.List<V> |
LinkedListMultimap.get(K key)
Returns a view collection of the values associated with
key in this multimap, if any. |
java.util.List<V> |
ListMultimap.get(K key)
Returns a view collection of the values associated with
key in this multimap, if any. |
java.util.Collection<V> |
Multimap.get(K key)
Returns a view collection of the values associated with
key in this multimap, if any. |
java.util.Collection<V> |
Multimaps.UnmodifiableMultimap.get(K key) |
java.util.List<V> |
Multimaps.UnmodifiableListMultimap.get(K key) |
java.util.Set<V> |
Multimaps.UnmodifiableSetMultimap.get(K key) |
java.util.SortedSet<V> |
Multimaps.UnmodifiableSortedSetMultimap.get(K key) |
java.util.Set<V> |
Multimaps.MapMultimap.get(K key) |
java.util.Collection<V2> |
Multimaps.TransformedEntriesMultimap.get(K key) |
java.util.List<V2> |
Multimaps.TransformedEntriesListMultimap.get(K key) |
java.util.Set<V> |
SetMultimap.get(K key)
Returns a view collection of the values associated with
key in this multimap, if any. |
java.util.SortedSet<V> |
SortedSetMultimap.get(K key)
Returns a collection view of all values associated with a key.
|
java.util.NavigableSet<V> |
TreeMultimap.get(K key) |
private java.util.List<V> |
LinkedListMultimap.getCopy(K key) |
static <T> T |
Iterables.getFirst(java.lang.Iterable<? extends T> iterable,
T defaultValue)
Returns the first element in
iterable or defaultValue if the iterable is empty. |
static <T> T |
Iterables.getLast(java.lang.Iterable<? extends T> iterable,
T defaultValue)
Returns the last element of
iterable or defaultValue if the iterable is empty. |
static <T> T |
Iterators.getLast(java.util.Iterator<? extends T> iterator,
T defaultValue)
Advances
iterator to the end, returning the last element or defaultValue if the
iterator is empty. |
static <T> T |
Iterators.getNext(java.util.Iterator<? extends T> iterator,
T defaultValue)
Returns the next element in
iterator or defaultValue if the iterator is empty. |
static <T> T |
Iterables.getOnlyElement(java.lang.Iterable<? extends T> iterable,
T defaultValue)
Returns the single element contained in
iterable , or defaultValue if the
iterable is empty. |
static <T> T |
Iterators.getOnlyElement(java.util.Iterator<? extends T> iterator,
T defaultValue)
Returns the single element contained in
iterator , or defaultValue if the
iterator is empty. |
private java.util.Collection<V> |
AbstractMapBasedMultimap.getOrCreateCollection(K key) |
java.util.SortedMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.SortedAsMap.headMap(K toKey) |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.headMap(K toKey) |
java.util.SortedMap<K,V> |
AbstractNavigableMap.headMap(K toKey) |
java.util.SortedMap<K,V> |
ForwardingSortedMap.headMap(K toKey) |
java.util.SortedMap<K,V> |
Maps.SortedAsMapView.headMap(K toKey) |
java.util.SortedMap<K,V2> |
Maps.TransformedEntriesSortedMap.headMap(K toKey) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.headMap(K toKey) |
java.util.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.headMap(K toKey) |
java.util.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.headMap(K toKey) |
java.util.SortedMap<K,V> |
Maps.DescendingMap.headMap(K toKey) |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.headMap(K toKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
ForwardingNavigableMap.headMap(K toKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.NavigableAsMapView.headMap(K toKey,
boolean inclusive) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.headMap(K toKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.FilteredEntryNavigableMap.headMap(K toKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.UnmodifiableNavigableMap.headMap(K toKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.DescendingMap.headMap(K toKey,
boolean inclusive) |
SortedMultiset<E> |
DescendingMultiset.headMultiset(E toElement,
BoundType boundType) |
SortedMultiset<E> |
ForwardingSortedMultiset.headMultiset(E upperBound,
BoundType boundType) |
SortedMultiset<E> |
SortedMultiset.headMultiset(E upperBound,
BoundType boundType)
Returns a view of this multiset restricted to the elements less than
upperBound ,
optionally including upperBound itself. |
SortedMultiset<E> |
TreeMultiset.headMultiset(E upperBound,
BoundType boundType) |
SortedMultiset<E> |
UnmodifiableSortedMultiset.headMultiset(E upperBound,
BoundType boundType) |
java.util.SortedSet<E> |
ForwardingSortedSet.headSet(E toElement) |
java.util.SortedSet<E> |
Sets.FilteredSortedSet.headSet(E toElement) |
java.util.SortedSet<E> |
Sets.DescendingSet.headSet(E toElement) |
java.util.SortedSet<E> |
SortedMultisets.ElementSet.headSet(E toElement) |
java.util.NavigableSet<E> |
ForwardingNavigableSet.headSet(E toElement,
boolean inclusive) |
java.util.NavigableSet<E> |
Sets.FilteredNavigableSet.headSet(E toElement,
boolean inclusive) |
java.util.NavigableSet<E> |
Sets.UnmodifiableNavigableSet.headSet(E toElement,
boolean inclusive) |
java.util.NavigableSet<E> |
Sets.DescendingSet.headSet(E toElement,
boolean inclusive) |
java.util.NavigableSet<E> |
SortedMultisets.NavigableElementSet.headSet(E toElement,
boolean inclusive) |
java.util.SortedSet<K> |
AbstractMapBasedMultimap.SortedKeySet.headSet(K toElement) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.headSet(K toElement) |
java.util.SortedSet<K> |
Maps.FilteredEntrySortedMap.SortedKeySet.headSet(K toElement) |
java.util.SortedSet<K> |
Maps.SortedKeySet.headSet(K toElement) |
java.util.SortedSet<K> |
Maps.NavigableKeySet.headSet(K toElement) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.headSet(K toElement,
boolean inclusive) |
java.util.NavigableSet<K> |
Maps.NavigableKeySet.headSet(K toElement,
boolean inclusive) |
java.util.SortedSet<V> |
AbstractMapBasedMultimap.WrappedSortedSet.headSet(V toElement) |
java.util.NavigableSet<V> |
AbstractMapBasedMultimap.WrappedNavigableSet.headSet(V toElement,
boolean inclusive) |
E |
ForwardingNavigableSet.higher(E e) |
E |
Sets.FilteredNavigableSet.higher(E e) |
E |
Sets.UnmodifiableNavigableSet.higher(E e) |
E |
Sets.DescendingSet.higher(E e) |
E |
SortedMultisets.NavigableElementSet.higher(E e) |
K |
AbstractMapBasedMultimap.NavigableKeySet.higher(K k) |
K |
Maps.NavigableKeySet.higher(K e) |
V |
AbstractMapBasedMultimap.WrappedNavigableSet.higher(V v) |
java.util.Map.Entry<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.higherEntry(K key) |
java.util.Map.Entry<K,V> |
AbstractNavigableMap.higherEntry(K key) |
java.util.Map.Entry<K,V> |
ForwardingNavigableMap.higherEntry(K key) |
java.util.Map.Entry<K,V2> |
Maps.TransformedEntriesNavigableMap.higherEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.UnmodifiableNavigableMap.higherEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.DescendingMap.higherEntry(K key) |
K |
AbstractMapBasedMultimap.NavigableAsMap.higherKey(K key) |
K |
AbstractNavigableMap.higherKey(K key) |
K |
ForwardingNavigableMap.higherKey(K key) |
K |
Maps.TransformedEntriesNavigableMap.higherKey(K key) |
K |
Maps.UnmodifiableNavigableMap.higherKey(K key) |
K |
Maps.DescendingMap.higherKey(K key) |
static <R,C,V> Table.Cell<R,C,V> |
Tables.immutableCell(R rowKey,
C columnKey,
V value)
Returns an immutable cell with the specified row key, column key, and value.
|
static <R,C,V> Table.Cell<R,C,V> |
Tables.immutableCell(R rowKey,
C columnKey,
V value)
Returns an immutable cell with the specified row key, column key, and value.
|
static <R,C,V> Table.Cell<R,C,V> |
Tables.immutableCell(R rowKey,
C columnKey,
V value)
Returns an immutable cell with the specified row key, column key, and value.
|
static <E> Multiset.Entry<E> |
Multisets.immutableEntry(E e,
int n)
Returns an immutable multiset entry with the specified element and count.
|
static <K,V> java.util.Map.Entry<K,V> |
Maps.immutableEntry(K key,
V value)
Returns an immutable map entry with the specified key and value.
|
static <K,V> java.util.Map.Entry<K,V> |
Maps.immutableEntry(K key,
V value)
Returns an immutable map entry with the specified key and value.
|
(package private) void |
CompactHashSet.insertEntry(int entryIndex,
E object,
int hash,
int mask)
Creates a fresh entry with the specified object at the specified position in the entry arrays.
|
(package private) void |
CompactLinkedHashSet.insertEntry(int entryIndex,
E object,
int hash,
int mask) |
(package private) void |
CompactHashMap.insertEntry(int entryIndex,
K key,
V value,
int hash,
int mask)
Creates a fresh entry with the specified object at the specified position in the entry arrays.
|
(package private) void |
CompactHashMap.insertEntry(int entryIndex,
K key,
V value,
int hash,
int mask)
Creates a fresh entry with the specified object at the specified position in the entry arrays.
|
(package private) void |
CompactLinkedHashMap.insertEntry(int entryIndex,
K key,
V value,
int hash,
int mask) |
(package private) void |
CompactLinkedHashMap.insertEntry(int entryIndex,
K key,
V value,
int hash,
int mask) |
E |
ForwardingNavigableSet.lower(E e) |
E |
Sets.FilteredNavigableSet.lower(E e) |
E |
Sets.UnmodifiableNavigableSet.lower(E e) |
E |
Sets.DescendingSet.lower(E e) |
E |
SortedMultisets.NavigableElementSet.lower(E e) |
K |
AbstractMapBasedMultimap.NavigableKeySet.lower(K k) |
K |
Maps.NavigableKeySet.lower(K e) |
V |
AbstractMapBasedMultimap.WrappedNavigableSet.lower(V v) |
java.util.Map.Entry<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.lowerEntry(K key) |
java.util.Map.Entry<K,V> |
AbstractNavigableMap.lowerEntry(K key) |
java.util.Map.Entry<K,V> |
ForwardingNavigableMap.lowerEntry(K key) |
java.util.Map.Entry<K,V2> |
Maps.TransformedEntriesNavigableMap.lowerEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.UnmodifiableNavigableMap.lowerEntry(K key) |
java.util.Map.Entry<K,V> |
Maps.DescendingMap.lowerEntry(K key) |
K |
AbstractMapBasedMultimap.NavigableAsMap.lowerKey(K key) |
K |
AbstractNavigableMap.lowerKey(K key) |
K |
ForwardingNavigableMap.lowerKey(K key) |
K |
Maps.TransformedEntriesNavigableMap.lowerKey(K key) |
K |
Maps.UnmodifiableNavigableMap.lowerKey(K key) |
K |
Maps.DescendingMap.lowerKey(K key) |
<E extends T> |
Ordering.max(E a,
E b)
Returns the greater of the two values according to this ordering.
|
<E extends T> |
Ordering.max(E a,
E b)
Returns the greater of the two values according to this ordering.
|
<E extends T> |
ReverseOrdering.max(E a,
E b) |
<E extends T> |
ReverseOrdering.max(E a,
E b) |
<E extends T> |
Ordering.max(E a,
E b,
E c,
E... rest)
Returns the greatest of the specified values according to this ordering.
|
<E extends T> |
Ordering.max(E a,
E b,
E c,
E... rest)
Returns the greatest of the specified values according to this ordering.
|
<E extends T> |
Ordering.max(E a,
E b,
E c,
E... rest)
Returns the greatest of the specified values according to this ordering.
|
<E extends T> |
ReverseOrdering.max(E a,
E b,
E c,
E... rest) |
<E extends T> |
ReverseOrdering.max(E a,
E b,
E c,
E... rest) |
<E extends T> |
ReverseOrdering.max(E a,
E b,
E c,
E... rest) |
static <T> T |
Comparators.max(T a,
T b,
java.util.Comparator<T> comparator)
Returns the maximum of the two values, according to the given comparator.
|
static <T> T |
Comparators.max(T a,
T b,
java.util.Comparator<T> comparator)
Returns the maximum of the two values, according to the given comparator.
|
private static <R,C,V> void |
TableCollectors.mergeTables(Table<R,C,V> table,
R row,
C column,
V value,
java.util.function.BinaryOperator<V> mergeFunction) |
private static <R,C,V> void |
TableCollectors.mergeTables(Table<R,C,V> table,
R row,
C column,
V value,
java.util.function.BinaryOperator<V> mergeFunction) |
private static <R,C,V> void |
TableCollectors.mergeTables(Table<R,C,V> table,
R row,
C column,
V value,
java.util.function.BinaryOperator<V> mergeFunction) |
<E extends T> |
Ordering.min(E a,
E b)
Returns the lesser of the two values according to this ordering.
|
<E extends T> |
Ordering.min(E a,
E b)
Returns the lesser of the two values according to this ordering.
|
<E extends T> |
ReverseOrdering.min(E a,
E b) |
<E extends T> |
ReverseOrdering.min(E a,
E b) |
<E extends T> |
Ordering.min(E a,
E b,
E c,
E... rest)
Returns the least of the specified values according to this ordering.
|
<E extends T> |
Ordering.min(E a,
E b,
E c,
E... rest)
Returns the least of the specified values according to this ordering.
|
<E extends T> |
Ordering.min(E a,
E b,
E c,
E... rest)
Returns the least of the specified values according to this ordering.
|
<E extends T> |
ReverseOrdering.min(E a,
E b,
E c,
E... rest) |
<E extends T> |
ReverseOrdering.min(E a,
E b,
E c,
E... rest) |
<E extends T> |
ReverseOrdering.min(E a,
E b,
E c,
E... rest) |
static <T> T |
Comparators.min(T a,
T b,
java.util.Comparator<T> comparator)
Returns the minimum of the two values, according to the given comparator.
|
static <T> T |
Comparators.min(T a,
T b,
java.util.Comparator<T> comparator)
Returns the minimum of the two values, according to the given comparator.
|
static <E> FluentIterable<E> |
FluentIterable.of(E element,
E... elements)
Returns a fluent iterable containing the specified elements in order.
|
boolean |
ForwardingQueue.offer(E o) |
void |
TopKSelector.offer(T elem)
Adds
elem as a candidate for the top k elements. |
boolean |
ForwardingDeque.offerFirst(E e) |
boolean |
ForwardingDeque.offerLast(E e) |
(package private) abstract T |
AbstractMapBasedMultimap.Itr.output(K key,
V value) |
(package private) abstract T |
AbstractMapBasedMultimap.Itr.output(K key,
V value) |
void |
ForwardingDeque.push(E e) |
V |
Tables.TransposeTable.put(C rowKey,
R columnKey,
V value) |
V |
Tables.TransposeTable.put(C rowKey,
R columnKey,
V value) |
V |
Tables.TransposeTable.put(C rowKey,
R columnKey,
V value) |
V |
AbstractBiMap.put(K key,
V value) |
V |
AbstractBiMap.put(K key,
V value) |
boolean |
AbstractListMultimap.put(K key,
V value)
Stores a key-value pair in the multimap.
|
boolean |
AbstractListMultimap.put(K key,
V value)
Stores a key-value pair in the multimap.
|
boolean |
AbstractMapBasedMultimap.put(K key,
V value) |
boolean |
AbstractMapBasedMultimap.put(K key,
V value) |
boolean |
AbstractMultimap.put(K key,
V value) |
boolean |
AbstractMultimap.put(K key,
V value) |
boolean |
AbstractSetMultimap.put(K key,
V value)
Stores a key-value pair in the multimap.
|
boolean |
AbstractSetMultimap.put(K key,
V value)
Stores a key-value pair in the multimap.
|
V |
ArrayTable.ArrayMap.put(K key,
V value) |
V |
BiMap.put(K key,
V value) |
V |
BiMap.put(K key,
V value) |
V |
CompactHashMap.put(K key,
V value) |
V |
CompactHashMap.put(K key,
V value) |
V |
EnumHashBiMap.put(K key,
V value) |
V |
ForwardingMap.put(K key,
V value) |
V |
ForwardingMap.put(K key,
V value) |
boolean |
ForwardingMultimap.put(K key,
V value) |
boolean |
ForwardingMultimap.put(K key,
V value) |
V |
HashBiMap.put(K key,
V value) |
V |
HashBiMap.put(K key,
V value) |
boolean |
LinkedListMultimap.put(K key,
V value)
Stores a key-value pair in the multimap.
|
boolean |
LinkedListMultimap.put(K key,
V value)
Stores a key-value pair in the multimap.
|
V |
Maps.AbstractFilteredMap.put(K key,
V value) |
V |
Maps.AbstractFilteredMap.put(K key,
V value) |
V |
Maps.FilteredEntryNavigableMap.put(K key,
V value) |
V |
Maps.FilteredEntryNavigableMap.put(K key,
V value) |
boolean |
Multimap.put(K key,
V value)
Stores a key-value pair in this multimap.
|
boolean |
Multimap.put(K key,
V value)
Stores a key-value pair in this multimap.
|
boolean |
Multimaps.UnmodifiableMultimap.put(K key,
V value) |
boolean |
Multimaps.UnmodifiableMultimap.put(K key,
V value) |
boolean |
Multimaps.MapMultimap.put(K key,
V value) |
boolean |
Multimaps.MapMultimap.put(K key,
V value) |
boolean |
Multimaps.TransformedEntriesMultimap.put(K key,
V2 value) |
boolean |
Multimaps.TransformedEntriesMultimap.put(K key,
V2 value) |
private V |
HashBiMap.put(K key,
V value,
boolean force) |
private V |
HashBiMap.put(K key,
V value,
boolean force) |
V |
AbstractTable.put(R rowKey,
C columnKey,
V value) |
V |
AbstractTable.put(R rowKey,
C columnKey,
V value) |
V |
AbstractTable.put(R rowKey,
C columnKey,
V value) |
V |
ForwardingTable.put(R rowKey,
C columnKey,
V value) |
V |
ForwardingTable.put(R rowKey,
C columnKey,
V value) |
V |
ForwardingTable.put(R rowKey,
C columnKey,
V value) |
V |
Table.put(R rowKey,
C columnKey,
V value)
Associates the specified value with the specified keys.
|
V |
Table.put(R rowKey,
C columnKey,
V value)
Associates the specified value with the specified keys.
|
V |
Table.put(R rowKey,
C columnKey,
V value)
Associates the specified value with the specified keys.
|
V |
Tables.UnmodifiableTable.put(R rowKey,
C columnKey,
V value) |
V |
Tables.UnmodifiableTable.put(R rowKey,
C columnKey,
V value) |
V |
Tables.UnmodifiableTable.put(R rowKey,
C columnKey,
V value) |
V2 |
Tables.TransformedTable.put(R rowKey,
C columnKey,
V2 value) |
V2 |
Tables.TransformedTable.put(R rowKey,
C columnKey,
V2 value) |
V2 |
Tables.TransformedTable.put(R rowKey,
C columnKey,
V2 value) |
K |
HashBiMap.Inverse.put(V value,
K key) |
K |
HashBiMap.Inverse.put(V value,
K key) |
boolean |
AbstractMultimap.putAll(K key,
java.lang.Iterable<? extends V> values) |
boolean |
ForwardingMultimap.putAll(K key,
java.lang.Iterable<? extends V> values) |
boolean |
Multimap.putAll(K key,
java.lang.Iterable<? extends V> values)
Stores a key-value pair in this multimap for each of
values , all using the same key,
key . |
boolean |
Multimaps.UnmodifiableMultimap.putAll(K key,
java.lang.Iterable<? extends V> values) |
boolean |
Multimaps.MapMultimap.putAll(K key,
java.lang.Iterable<? extends V> values) |
boolean |
Multimaps.TransformedEntriesMultimap.putAll(K key,
java.lang.Iterable<? extends V2> values) |
private V |
AbstractBiMap.putInBothMaps(K key,
V value,
boolean force) |
private V |
AbstractBiMap.putInBothMaps(K key,
V value,
boolean force) |
private K |
HashBiMap.putInverse(V value,
K key,
boolean force) |
private K |
HashBiMap.putInverse(V value,
K key,
boolean force) |
(package private) static <T> GeneralRange<T> |
GeneralRange.range(java.util.Comparator<? super T> comparator,
T lower,
BoundType lowerType,
T upper,
BoundType upperType)
Returns everything between the endpoints relative to the specified comparator, with the
specified endpoint behavior.
|
(package private) static <T> GeneralRange<T> |
GeneralRange.range(java.util.Comparator<? super T> comparator,
T lower,
BoundType lowerType,
T upper,
BoundType upperType)
Returns everything between the endpoints relative to the specified comparator, with the
specified endpoint behavior.
|
(package private) TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.remove(java.util.Comparator<? super E> comparator,
E e,
int count,
int[] result) |
private void |
LinkedListMultimap.removeAllNodes(K key)
Removes all nodes for the specified key.
|
private void |
AbstractBiMap.removeFromInverseMap(V oldValue) |
java.util.List<V> |
AbstractListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.Collection<V> |
AbstractMapBasedMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.Collection<V> |
AbstractMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Set<V> |
AbstractSetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.SortedSet<V> |
AbstractSortedSetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.Set<V> |
FilteredEntrySetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.List<V> |
FilteredKeyListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Set<V> |
FilteredKeySetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.List<V> |
ForwardingListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Collection<V> |
ForwardingMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Set<V> |
ForwardingSetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.SortedSet<V> |
ForwardingSortedSetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Set<V> |
LinkedHashMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.List<V> |
LinkedListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.List<V> |
ListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.Collection<V> |
Multimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.Collection<V> |
Multimaps.UnmodifiableMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.List<V> |
Multimaps.UnmodifiableListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Set<V> |
Multimaps.UnmodifiableSetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.SortedSet<V> |
Multimaps.UnmodifiableSortedSetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Set<V> |
Multimaps.MapMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
java.util.Set<V> |
SetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.SortedSet<V> |
SortedSetMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values)
Stores a collection of values with the same key, replacing any existing values for that key.
|
java.util.Collection<V2> |
Multimaps.TransformedEntriesMultimap.replaceValues(K key,
java.lang.Iterable<? extends V2> values) |
java.util.List<V2> |
Multimaps.TransformedEntriesListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V2> values) |
(package private) abstract <E> int |
SortedLists.KeyPresentBehavior.resultIndex(java.util.Comparator<? super E> comparator,
E key,
java.util.List<? extends E> list,
int foundIndex) |
java.util.Map<R,V> |
Tables.TransposeTable.row(C rowKey) |
java.util.Map<C,V> |
ForwardingTable.row(R rowKey) |
java.util.Map<C,V> |
Table.row(R rowKey)
Returns a view of all mappings that have the given row key.
|
java.util.Map<C,V2> |
Tables.TransformedTable.row(R rowKey) |
java.util.Map<C,V> |
Tables.UnmodifiableTable.row(R rowKey) |
private boolean |
FilteredEntryMultimap.satisfies(K key,
V value) |
private boolean |
FilteredEntryMultimap.satisfies(K key,
V value) |
void |
ForwardingListIterator.set(E element) |
void |
UnmodifiableListIterator.set(E e)
Deprecated.
Unsupported operation.
|
E |
ForwardingList.set(int index,
E element) |
E |
Lists.AbstractListWrapper.set(int index,
E element) |
T |
Lists.ReverseList.set(int index,
T element) |
V |
AbstractMapBasedMultimap.WrappedList.set(int index,
V element) |
void |
TransformedListIterator.set(T element) |
void |
AbstractMapBasedMultimap.WrappedList.WrappedListIterator.set(V value) |
void |
LinkedListMultimap.ValueForKeyIterator.set(V value) |
(package private) TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.setCount(java.util.Comparator<? super E> comparator,
E e,
int count,
int[] result) |
(package private) TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.setCount(java.util.Comparator<? super E> comparator,
E e,
int expectedCount,
int newCount,
int[] result) |
int |
AbstractMapBasedMultiset.setCount(E element,
int count) |
int |
AbstractMultiset.setCount(E element,
int count) |
int |
ForwardingMultiset.setCount(E element,
int count) |
int |
Multiset.setCount(E element,
int count)
Adds or removes the necessary occurrences of an element such that the element attains the
desired count.
|
int |
Multisets.UnmodifiableMultiset.setCount(E element,
int count) |
int |
TreeMultiset.setCount(E element,
int count) |
boolean |
AbstractMultiset.setCount(E element,
int oldCount,
int newCount) |
boolean |
ForwardingMultiset.setCount(E element,
int oldCount,
int newCount) |
boolean |
Multiset.setCount(E element,
int oldCount,
int newCount)
Conditionally sets the count of an element to a new value, as described in
Multiset.setCount(Object, int) , provided that the element has the expected current count. |
boolean |
Multisets.UnmodifiableMultiset.setCount(E element,
int oldCount,
int newCount) |
boolean |
TreeMultiset.setCount(E element,
int oldCount,
int newCount) |
(package private) static <E> int |
Multisets.setCountImpl(Multiset<E> self,
E element,
int count)
An implementation of
Multiset.setCount(Object, int) . |
(package private) static <E> boolean |
Multisets.setCountImpl(Multiset<E> self,
E element,
int oldCount,
int newCount)
An implementation of
Multiset.setCount(Object, int, int) . |
(package private) abstract V |
ArrayTable.ArrayMap.setValue(int index,
V newValue) |
V |
AbstractMapEntry.setValue(V value) |
V |
CompactHashMap.MapEntry.setValue(V value) |
V |
ForwardingMapEntry.setValue(V value) |
V |
ImmutableEntry.setValue(V value) |
V |
LinkedListMultimap.Node.setValue(V newValue) |
(package private) void |
LinkedListMultimap.NodeIterator.setValue(V value) |
static <T> UnmodifiableIterator<T> |
Iterators.singletonIterator(T value)
Returns an iterator containing only
value . |
protected boolean |
ForwardingList.standardAdd(E element)
A sensible default implementation of
ForwardingCollection.add(Object) , in terms of ForwardingList.add(int,
Object) . |
protected boolean |
ForwardingMultiset.standardAdd(E element)
A sensible definition of
ForwardingCollection.add(Object) in terms of ForwardingMultiset.add(Object, int) . |
protected E |
ForwardingNavigableSet.standardCeiling(E e)
A sensible definition of
ForwardingNavigableSet.ceiling(E) in terms of the iterator method of ForwardingNavigableSet.tailSet(Object, boolean) . |
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardCeilingEntry(K key)
A sensible definition of
ForwardingNavigableMap.ceilingEntry(K) in terms of the firstEntry() of ForwardingNavigableMap.tailMap(Object, boolean) . |
protected K |
ForwardingNavigableMap.standardCeilingKey(K key)
A sensible definition of
ForwardingNavigableMap.ceilingKey(K) in terms of ceilingEntry . |
protected E |
ForwardingNavigableSet.standardFloor(E e)
A sensible definition of
ForwardingNavigableSet.floor(E) in terms of the descendingIterator method of
ForwardingNavigableSet.headSet(Object, boolean) . |
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardFloorEntry(K key)
A sensible definition of
ForwardingNavigableMap.floorEntry(K) in terms of the lastEntry() of ForwardingNavigableMap.headMap(Object, boolean) . |
protected K |
ForwardingNavigableMap.standardFloorKey(K key)
A sensible definition of
ForwardingNavigableMap.floorKey(K) in terms of floorEntry . |
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardHeadMap(K toKey)
A sensible definition of
ForwardingSortedMap.headMap(Object) in terms of ForwardingNavigableMap.headMap(Object,
boolean) . |
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardHeadSet(E toElement)
A sensible definition of
ForwardingSortedSet.headSet(Object) in terms of the ForwardingNavigableSet.headSet(Object,
boolean) method. |
protected E |
ForwardingNavigableSet.standardHigher(E e)
A sensible definition of
ForwardingNavigableSet.higher(E) in terms of the iterator method of ForwardingNavigableSet.tailSet(Object, boolean) . |
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardHigherEntry(K key)
A sensible definition of
ForwardingNavigableMap.higherEntry(K) in terms of the firstEntry() of ForwardingNavigableMap.tailMap(Object, boolean) . |
protected K |
ForwardingNavigableMap.standardHigherKey(K key)
A sensible definition of
ForwardingNavigableMap.higherKey(K) in terms of higherEntry . |
protected E |
ForwardingNavigableSet.standardLower(E e)
A sensible definition of
ForwardingNavigableSet.lower(E) in terms of the descendingIterator method of
ForwardingNavigableSet.headSet(Object, boolean) . |
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardLowerEntry(K key)
A sensible definition of
ForwardingNavigableMap.lowerEntry(K) in terms of the lastEntry() of ForwardingNavigableMap.headMap(Object, boolean) . |
protected K |
ForwardingNavigableMap.standardLowerKey(K key)
A sensible definition of
ForwardingNavigableMap.lowerKey(K) in terms of lowerEntry . |
protected boolean |
ForwardingQueue.standardOffer(E e)
A sensible definition of
ForwardingQueue.offer(E) in terms of ForwardingCollection.add(E) . |
protected int |
ForwardingMultiset.standardSetCount(E element,
int count)
A sensible definition of
ForwardingMultiset.setCount(Object, int) in terms of ForwardingMultiset.count(Object) ,
ForwardingMultiset.add(Object, int) , and ForwardingMultiset.remove(Object, int) . |
protected boolean |
ForwardingMultiset.standardSetCount(E element,
int oldCount,
int newCount)
A sensible definition of
ForwardingMultiset.setCount(Object, int, int) in terms of ForwardingMultiset.count(Object)
and ForwardingMultiset.setCount(Object, int) . |
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardSubMap(K fromKey,
K toKey)
A sensible definition of
ForwardingSortedMap.subMap(Object, Object) in terms of ForwardingNavigableMap.subMap(Object,
boolean, Object, boolean) . |
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardSubMap(K fromKey,
K toKey)
A sensible definition of
ForwardingSortedMap.subMap(Object, Object) in terms of ForwardingNavigableMap.subMap(Object,
boolean, Object, boolean) . |
protected SortedMultiset<E> |
ForwardingSortedMultiset.standardSubMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType)
A sensible definition of
ForwardingSortedMultiset.subMultiset(Object, BoundType, Object, BoundType) in terms of
headMultiset and tailMultiset . |
protected SortedMultiset<E> |
ForwardingSortedMultiset.standardSubMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType)
A sensible definition of
ForwardingSortedMultiset.subMultiset(Object, BoundType, Object, BoundType) in terms of
headMultiset and tailMultiset . |
protected java.util.NavigableSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive)
A sensible definition of
ForwardingNavigableSet.subSet(Object, boolean, Object, boolean) in terms of the
headSet and tailSet methods. |
protected java.util.NavigableSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive)
A sensible definition of
ForwardingNavigableSet.subSet(Object, boolean, Object, boolean) in terms of the
headSet and tailSet methods. |
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
E toElement)
A sensible definition of
ForwardingSortedSet.subSet(Object, Object) in terms of the ForwardingNavigableSet.subSet(Object,
boolean, Object, boolean) method. |
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
E toElement)
A sensible definition of
ForwardingSortedSet.subSet(Object, Object) in terms of the ForwardingNavigableSet.subSet(Object,
boolean, Object, boolean) method. |
protected java.util.SortedSet<E> |
ForwardingSortedSet.standardSubSet(E fromElement,
E toElement)
A sensible default implementation of
ForwardingSortedSet.subSet(Object, Object) in terms of ForwardingSortedSet.headSet(Object) and ForwardingSortedSet.tailSet(Object) . |
protected java.util.SortedSet<E> |
ForwardingSortedSet.standardSubSet(E fromElement,
E toElement)
A sensible default implementation of
ForwardingSortedSet.subSet(Object, Object) in terms of ForwardingSortedSet.headSet(Object) and ForwardingSortedSet.tailSet(Object) . |
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardTailMap(K fromKey)
A sensible definition of
ForwardingSortedMap.tailMap(Object) in terms of ForwardingNavigableMap.tailMap(Object,
boolean) . |
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardTailSet(E fromElement)
A sensible definition of
ForwardingSortedSet.tailSet(Object) in terms of the ForwardingNavigableSet.tailSet(Object,
boolean) method. |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
ForwardingNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
ForwardingNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.NavigableAsMapView.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.NavigableAsMapView.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.FilteredEntryNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.FilteredEntryNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.UnmodifiableNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.UnmodifiableNavigableMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.DescendingMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.NavigableMap<K,V> |
Maps.DescendingMap.subMap(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive) |
java.util.SortedMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.SortedAsMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.SortedAsMap.subMap(K fromKey,
K toKey) |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.subMap(K fromKey,
K toKey) |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
AbstractNavigableMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
AbstractNavigableMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
ForwardingSortedMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
ForwardingSortedMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.SortedAsMapView.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.SortedAsMapView.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V2> |
Maps.TransformedEntriesSortedMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V2> |
Maps.TransformedEntriesSortedMap.subMap(K fromKey,
K toKey) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.subMap(K fromKey,
K toKey) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.DescendingMap.subMap(K fromKey,
K toKey) |
java.util.SortedMap<K,V> |
Maps.DescendingMap.subMap(K fromKey,
K toKey) |
SortedMultiset<E> |
AbstractSortedMultiset.subMultiset(E fromElement,
BoundType fromBoundType,
E toElement,
BoundType toBoundType) |
SortedMultiset<E> |
AbstractSortedMultiset.subMultiset(E fromElement,
BoundType fromBoundType,
E toElement,
BoundType toBoundType) |
SortedMultiset<E> |
DescendingMultiset.subMultiset(E fromElement,
BoundType fromBoundType,
E toElement,
BoundType toBoundType) |
SortedMultiset<E> |
DescendingMultiset.subMultiset(E fromElement,
BoundType fromBoundType,
E toElement,
BoundType toBoundType) |
SortedMultiset<E> |
ForwardingSortedMultiset.subMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType) |
SortedMultiset<E> |
ForwardingSortedMultiset.subMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType) |
SortedMultiset<E> |
SortedMultiset.subMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType)
Returns a view of this multiset restricted to the range between
lowerBound and upperBound . |
SortedMultiset<E> |
SortedMultiset.subMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType)
Returns a view of this multiset restricted to the range between
lowerBound and upperBound . |
SortedMultiset<E> |
UnmodifiableSortedMultiset.subMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType) |
SortedMultiset<E> |
UnmodifiableSortedMultiset.subMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType) |
java.util.NavigableSet<E> |
ForwardingNavigableSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
ForwardingNavigableSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
Sets.FilteredNavigableSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
Sets.FilteredNavigableSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
Sets.UnmodifiableNavigableSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
Sets.UnmodifiableNavigableSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
Sets.DescendingSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
Sets.DescendingSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
SortedMultisets.NavigableElementSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.NavigableSet<E> |
SortedMultisets.NavigableElementSet.subSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
java.util.SortedSet<E> |
ForwardingSortedSet.subSet(E fromElement,
E toElement) |
java.util.SortedSet<E> |
ForwardingSortedSet.subSet(E fromElement,
E toElement) |
java.util.SortedSet<E> |
Sets.FilteredSortedSet.subSet(E fromElement,
E toElement) |
java.util.SortedSet<E> |
Sets.FilteredSortedSet.subSet(E fromElement,
E toElement) |
java.util.SortedSet<E> |
Sets.DescendingSet.subSet(E fromElement,
E toElement) |
java.util.SortedSet<E> |
Sets.DescendingSet.subSet(E fromElement,
E toElement) |
java.util.SortedSet<E> |
SortedMultisets.ElementSet.subSet(E fromElement,
E toElement) |
java.util.SortedSet<E> |
SortedMultisets.ElementSet.subSet(E fromElement,
E toElement) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.subSet(K fromElement,
boolean fromInclusive,
K toElement,
boolean toInclusive) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.subSet(K fromElement,
boolean fromInclusive,
K toElement,
boolean toInclusive) |
java.util.NavigableSet<K> |
Maps.NavigableKeySet.subSet(K fromElement,
boolean fromInclusive,
K toElement,
boolean toInclusive) |
java.util.NavigableSet<K> |
Maps.NavigableKeySet.subSet(K fromElement,
boolean fromInclusive,
K toElement,
boolean toInclusive) |
java.util.SortedSet<K> |
AbstractMapBasedMultimap.SortedKeySet.subSet(K fromElement,
K toElement) |
java.util.SortedSet<K> |
AbstractMapBasedMultimap.SortedKeySet.subSet(K fromElement,
K toElement) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.subSet(K fromElement,
K toElement) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.subSet(K fromElement,
K toElement) |
java.util.SortedSet<K> |
Maps.FilteredEntrySortedMap.SortedKeySet.subSet(K fromElement,
K toElement) |
java.util.SortedSet<K> |
Maps.FilteredEntrySortedMap.SortedKeySet.subSet(K fromElement,
K toElement) |
java.util.SortedSet<K> |
Maps.SortedKeySet.subSet(K fromElement,
K toElement) |
java.util.SortedSet<K> |
Maps.SortedKeySet.subSet(K fromElement,
K toElement) |
java.util.SortedSet<K> |
Maps.NavigableKeySet.subSet(K fromElement,
K toElement) |
java.util.SortedSet<K> |
Maps.NavigableKeySet.subSet(K fromElement,
K toElement) |
java.util.NavigableSet<V> |
AbstractMapBasedMultimap.WrappedNavigableSet.subSet(V fromElement,
boolean fromInclusive,
V toElement,
boolean toInclusive) |
java.util.NavigableSet<V> |
AbstractMapBasedMultimap.WrappedNavigableSet.subSet(V fromElement,
boolean fromInclusive,
V toElement,
boolean toInclusive) |
java.util.SortedSet<V> |
AbstractMapBasedMultimap.WrappedSortedSet.subSet(V fromElement,
V toElement) |
java.util.SortedSet<V> |
AbstractMapBasedMultimap.WrappedSortedSet.subSet(V fromElement,
V toElement) |
java.util.SortedMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.SortedAsMap.tailMap(K fromKey) |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.tailMap(K fromKey) |
java.util.SortedMap<K,V> |
AbstractNavigableMap.tailMap(K fromKey) |
java.util.SortedMap<K,V> |
ForwardingSortedMap.tailMap(K fromKey) |
java.util.SortedMap<K,V> |
Maps.SortedAsMapView.tailMap(K fromKey) |
java.util.SortedMap<K,V2> |
Maps.TransformedEntriesSortedMap.tailMap(K fromKey) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.tailMap(K fromKey) |
java.util.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.tailMap(K fromKey) |
java.util.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.tailMap(K fromKey) |
java.util.SortedMap<K,V> |
Maps.DescendingMap.tailMap(K fromKey) |
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.tailMap(K fromKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
ForwardingNavigableMap.tailMap(K fromKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.NavigableAsMapView.tailMap(K fromKey,
boolean inclusive) |
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.tailMap(K fromKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.FilteredEntryNavigableMap.tailMap(K fromKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.UnmodifiableNavigableMap.tailMap(K fromKey,
boolean inclusive) |
java.util.NavigableMap<K,V> |
Maps.DescendingMap.tailMap(K fromKey,
boolean inclusive) |
SortedMultiset<E> |
DescendingMultiset.tailMultiset(E fromElement,
BoundType boundType) |
SortedMultiset<E> |
ForwardingSortedMultiset.tailMultiset(E lowerBound,
BoundType boundType) |
SortedMultiset<E> |
SortedMultiset.tailMultiset(E lowerBound,
BoundType boundType)
Returns a view of this multiset restricted to the elements greater than
lowerBound ,
optionally including lowerBound itself. |
SortedMultiset<E> |
TreeMultiset.tailMultiset(E lowerBound,
BoundType boundType) |
SortedMultiset<E> |
UnmodifiableSortedMultiset.tailMultiset(E lowerBound,
BoundType boundType) |
java.util.SortedSet<E> |
ForwardingSortedSet.tailSet(E fromElement) |
java.util.SortedSet<E> |
Sets.FilteredSortedSet.tailSet(E fromElement) |
java.util.SortedSet<E> |
Sets.DescendingSet.tailSet(E fromElement) |
java.util.SortedSet<E> |
SortedMultisets.ElementSet.tailSet(E fromElement) |
java.util.NavigableSet<E> |
ForwardingNavigableSet.tailSet(E fromElement,
boolean inclusive) |
java.util.NavigableSet<E> |
Sets.FilteredNavigableSet.tailSet(E fromElement,
boolean inclusive) |
java.util.NavigableSet<E> |
Sets.UnmodifiableNavigableSet.tailSet(E fromElement,
boolean inclusive) |
java.util.NavigableSet<E> |
Sets.DescendingSet.tailSet(E fromElement,
boolean inclusive) |
java.util.NavigableSet<E> |
SortedMultisets.NavigableElementSet.tailSet(E fromElement,
boolean inclusive) |
java.util.SortedSet<K> |
AbstractMapBasedMultimap.SortedKeySet.tailSet(K fromElement) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.tailSet(K fromElement) |
java.util.SortedSet<K> |
Maps.FilteredEntrySortedMap.SortedKeySet.tailSet(K fromElement) |
java.util.SortedSet<K> |
Maps.SortedKeySet.tailSet(K fromElement) |
java.util.SortedSet<K> |
Maps.NavigableKeySet.tailSet(K fromElement) |
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.tailSet(K fromElement,
boolean inclusive) |
java.util.NavigableSet<K> |
Maps.NavigableKeySet.tailSet(K fromElement,
boolean inclusive) |
java.util.SortedSet<V> |
AbstractMapBasedMultimap.WrappedSortedSet.tailSet(V fromElement) |
java.util.NavigableSet<V> |
AbstractMapBasedMultimap.WrappedNavigableSet.tailSet(V fromElement,
boolean inclusive) |
(package private) boolean |
GeneralRange.tooHigh(T t) |
(package private) boolean |
GeneralRange.tooLow(T t) |
(package private) abstract T |
TransformedIterator.transform(F from) |
(package private) java.util.Collection<V2> |
Multimaps.TransformedEntriesMultimap.transform(K key,
java.util.Collection<V1> values) |
(package private) java.util.List<V2> |
Multimaps.TransformedEntriesListMultimap.transform(K key,
java.util.Collection<V1> values) |
V2 |
Maps.EntryTransformer.transformEntry(K key,
V1 value)
Determines an output value based on a key-value pair.
|
V2 |
Maps.EntryTransformer.transformEntry(K key,
V1 value)
Determines an output value based on a key-value pair.
|
private void |
AbstractBiMap.updateInverseMap(K key,
boolean containedKey,
V oldValue,
V newValue) |
private void |
AbstractBiMap.updateInverseMap(K key,
boolean containedKey,
V oldValue,
V newValue) |
(package private) static <T> GeneralRange<T> |
GeneralRange.upTo(java.util.Comparator<? super T> comparator,
T endpoint,
BoundType boundType)
Returns everything below the endpoint relative to the specified comparator, with the specified
endpoint behavior.
|
(package private) java.util.Collection<V> |
AbstractListMultimap.wrapCollection(K key,
java.util.Collection<V> collection) |
(package private) java.util.Collection<V> |
AbstractMapBasedMultimap.wrapCollection(K key,
java.util.Collection<V> collection)
Generates a decorated collection that remains consistent with the values in the multimap for
the provided key.
|
(package private) java.util.Collection<V> |
AbstractSetMultimap.wrapCollection(K key,
java.util.Collection<V> collection) |
(package private) java.util.Collection<V> |
AbstractSortedSetMultimap.wrapCollection(K key,
java.util.Collection<V> collection) |
(package private) java.util.Collection<V> |
Multimaps.CustomMultimap.wrapCollection(K key,
java.util.Collection<V> collection) |
(package private) java.util.Collection<V> |
Multimaps.CustomSetMultimap.wrapCollection(K key,
java.util.Collection<V> collection) |
(package private) java.util.List<V> |
AbstractMapBasedMultimap.wrapList(K key,
java.util.List<V> list,
AbstractMapBasedMultimap.WrappedCollection ancestor) |
Constructor and Description |
---|
AddRejectingList(K key) |
AddRejectingSet(K key) |
AvlNode(E elem,
int elemCount) |
BiEntry(K key,
int keyHash,
V value,
int valueHash) |
BiEntry(K key,
int keyHash,
V value,
int valueHash) |
ImmutableCell(R rowKey,
C columnKey,
V value) |
ImmutableCell(R rowKey,
C columnKey,
V value) |
ImmutableCell(R rowKey,
C columnKey,
V value) |
ImmutableEntry(E element,
int count) |
ImmutableEntry(K key,
V value) |
ImmutableEntry(K key,
V value) |
Node(K key,
V value) |
Node(K key,
V value) |
OnePlusArrayList(E first,
E[] rest) |
RandomAccessWrappedList(K key,
java.util.List<V> delegate,
AbstractMapBasedMultimap.WrappedCollection ancestor) |
TemporaryPair(A a,
B b) |
TemporaryPair(A a,
B b) |
TwoPlusArrayList(E first,
E second,
E[] rest) |
TwoPlusArrayList(E first,
E second,
E[] rest) |
ValueDifferenceImpl(V left,
V right) |
ValueDifferenceImpl(V left,
V right) |
ValueEntry(K key,
V value,
int smearedValueHash,
LinkedHashMultimap.ValueEntry<K,V> nextInValueBucket) |
ValueEntry(K key,
V value,
int smearedValueHash,
LinkedHashMultimap.ValueEntry<K,V> nextInValueBucket) |
ValueForKeyIterator(K key)
Constructs a new iterator over all values for the specified key.
|
ValueForKeyIterator(K key,
int index)
Constructs a new iterator over all values for the specified key starting at the specified
index.
|
ValuePredicate(K key) |
ValueSet(K key,
int expectedValues) |
WrappedCollection(K key,
java.util.Collection<V> delegate,
AbstractMapBasedMultimap.WrappedCollection ancestor) |
WrappedList(K key,
java.util.List<V> delegate,
AbstractMapBasedMultimap.WrappedCollection ancestor) |
WrappedNavigableSet(K key,
java.util.NavigableSet<V> delegate,
AbstractMapBasedMultimap.WrappedCollection ancestor) |
WrappedSet(K key,
java.util.Set<V> delegate) |
WrappedSortedSet(K key,
java.util.SortedSet<V> delegate,
AbstractMapBasedMultimap.WrappedCollection ancestor) |