boolean |
AbstractMapBasedMultimap.WrappedCollection.add(V value) |
|
void |
AbstractMapBasedMultimap.WrappedList.add(int index,
V element) |
|
void |
AbstractMapBasedMultimap.WrappedList.WrappedListIterator.add(V value) |
|
int |
AbstractMapBasedMultiset.add(E element,
int occurrences) |
Adds a number of occurrences of an element to this multiset.
|
boolean |
AbstractMultiset.add(E element) |
|
int |
AbstractMultiset.add(E element,
int occurrences) |
|
boolean |
Collections2.FilteredCollection.add(E element) |
|
boolean |
CompactHashSet.add(E object) |
|
void |
FilteredKeyMultimap.AddRejectingList.add(int index,
V element) |
|
boolean |
FilteredKeyMultimap.AddRejectingList.add(V v) |
|
boolean |
FilteredKeyMultimap.AddRejectingSet.add(V element) |
|
boolean |
ForwardingCollection.add(E element) |
|
void |
ForwardingList.add(int index,
E element) |
|
void |
ForwardingListIterator.add(E element) |
|
int |
ForwardingMultiset.add(E element,
int occurrences) |
|
boolean |
LinkedHashMultimap.ValueSet.add(V value) |
|
void |
LinkedListMultimap.ValueForKeyIterator.add(V value) |
|
void |
Lists.AbstractListWrapper.add(int index,
E element) |
|
void |
Lists.ReverseList.add(int index,
T element) |
|
boolean |
Multiset.add(E element) |
Adds a single occurrence of the specified element to this multiset.
|
int |
Multiset.add(E element,
int occurrences) |
Adds a number of occurrences of an element to this multiset.
|
int |
Multisets.FilteredMultiset.add(E element,
int occurrences) |
|
boolean |
Multisets.UnmodifiableMultiset.add(E element) |
|
int |
Multisets.UnmodifiableMultiset.add(E element,
int occurrences) |
|
boolean |
Sets.SetView.add(E e) |
Deprecated.
|
void |
TransformedListIterator.add(T element) |
|
int |
TreeMultiset.add(E element,
int occurrences) |
|
(package private) TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.add(java.util.Comparator<? super E> comparator,
E e,
int count,
int[] result) |
|
void |
UnmodifiableListIterator.add(E e) |
Deprecated.
|
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) |
|
boolean |
FilteredEntryMultimap.ValuePredicate.apply(V value) |
|
(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.
|
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) |
|
int |
Ordering.binarySearch(java.util.List<? extends T> sortedList,
T key) |
Deprecated.
|
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.
|
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.
|
K |
AbstractMapBasedMultimap.NavigableKeySet.ceiling(K k) |
|
V |
AbstractMapBasedMultimap.WrappedNavigableSet.ceiling(V v) |
|
E |
ForwardingNavigableSet.ceiling(E e) |
|
K |
Maps.NavigableKeySet.ceiling(K e) |
|
E |
Sets.DescendingSet.ceiling(E e) |
|
E |
Sets.FilteredNavigableSet.ceiling(E e) |
|
E |
Sets.UnmodifiableNavigableSet.ceiling(E e) |
|
E |
SortedMultisets.NavigableElementSet.ceiling(E e) |
|
private TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.ceiling(java.util.Comparator<? super E> comparator,
E e) |
|
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,V> |
Maps.DescendingMap.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) |
|
K |
AbstractMapBasedMultimap.NavigableAsMap.ceilingKey(K key) |
|
K |
AbstractNavigableMap.ceilingKey(K key) |
|
K |
ForwardingNavigableMap.ceilingKey(K key) |
|
K |
Maps.DescendingMap.ceilingKey(K key) |
|
K |
Maps.TransformedEntriesNavigableMap.ceilingKey(K key) |
|
K |
Maps.UnmodifiableNavigableMap.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<C,V> |
Tables.TransposeTable.column(R columnKey) |
|
java.util.Map<R,V> |
Tables.UnmodifiableTable.column(C 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) |
|
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) |
|
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) |
|
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.
|
K |
AbstractMapBasedMultimap.NavigableKeySet.floor(K k) |
|
V |
AbstractMapBasedMultimap.WrappedNavigableSet.floor(V v) |
|
E |
ForwardingNavigableSet.floor(E e) |
|
K |
Maps.NavigableKeySet.floor(K e) |
|
E |
Sets.DescendingSet.floor(E e) |
|
E |
Sets.FilteredNavigableSet.floor(E e) |
|
E |
Sets.UnmodifiableNavigableSet.floor(E e) |
|
E |
SortedMultisets.NavigableElementSet.floor(E e) |
|
private TreeMultiset.AvlNode<E> |
TreeMultiset.AvlNode.floor(java.util.Comparator<? super E> comparator,
E e) |
|
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,V> |
Maps.DescendingMap.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) |
|
K |
AbstractMapBasedMultimap.NavigableAsMap.floorKey(K key) |
|
K |
AbstractNavigableMap.floorKey(K key) |
|
K |
ForwardingNavigableMap.floorKey(K key) |
|
K |
Maps.DescendingMap.floorKey(K key) |
|
K |
Maps.TransformedEntriesNavigableMap.floorKey(K key) |
|
K |
Maps.UnmodifiableNavigableMap.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) |
|
K |
HashBiMap.Inverse.forcePut(V value,
K key) |
|
K |
HashBiMap.Inverse.forcePut(V value,
K key) |
|
V |
Maps.FilteredEntryBiMap.forcePut(K key,
V value) |
|
V |
Maps.FilteredEntryBiMap.forcePut(K key,
V value) |
|
V |
Maps.UnmodifiableBiMap.forcePut(K key,
V value) |
|
V |
Maps.UnmodifiableBiMap.forcePut(K key,
V value) |
|
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) |
|
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> |
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.Set<V> |
Multimaps.MapMultimap.get(K key) |
|
java.util.List<V2> |
Multimaps.TransformedEntriesListMultimap.get(K key) |
|
java.util.Collection<V2> |
Multimaps.TransformedEntriesMultimap.get(K key) |
|
java.util.List<V> |
Multimaps.UnmodifiableListMultimap.get(K key) |
|
java.util.Collection<V> |
Multimaps.UnmodifiableMultimap.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> |
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.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.headMap(K toKey) |
|
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.headMap(K toKey,
boolean inclusive) |
|
java.util.SortedMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.SortedAsMap.headMap(K toKey) |
|
java.util.SortedMap<K,V> |
AbstractNavigableMap.headMap(K toKey) |
|
java.util.NavigableMap<K,V> |
ForwardingNavigableMap.headMap(K toKey,
boolean inclusive) |
|
java.util.SortedMap<K,V> |
ForwardingSortedMap.headMap(K toKey) |
|
java.util.SortedMap<K,V> |
Maps.DescendingMap.headMap(K toKey) |
|
java.util.NavigableMap<K,V> |
Maps.DescendingMap.headMap(K toKey,
boolean inclusive) |
|
java.util.NavigableMap<K,V> |
Maps.FilteredEntryNavigableMap.headMap(K toKey,
boolean inclusive) |
|
java.util.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.headMap(K toKey) |
|
java.util.NavigableMap<K,V> |
Maps.NavigableAsMapView.headMap(K toKey,
boolean inclusive) |
|
java.util.SortedMap<K,V> |
Maps.SortedAsMapView.headMap(K toKey) |
|
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.headMap(K toKey) |
|
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.headMap(K toKey,
boolean inclusive) |
|
java.util.SortedMap<K,V2> |
Maps.TransformedEntriesSortedMap.headMap(K toKey) |
|
java.util.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.headMap(K toKey) |
|
java.util.NavigableMap<K,V> |
Maps.UnmodifiableNavigableMap.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.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.headSet(K toElement) |
|
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.headSet(K toElement,
boolean inclusive) |
|
java.util.SortedSet<K> |
AbstractMapBasedMultimap.SortedKeySet.headSet(K toElement) |
|
java.util.NavigableSet<V> |
AbstractMapBasedMultimap.WrappedNavigableSet.headSet(V toElement,
boolean inclusive) |
|
java.util.SortedSet<V> |
AbstractMapBasedMultimap.WrappedSortedSet.headSet(V toElement) |
|
java.util.NavigableSet<E> |
ForwardingNavigableSet.headSet(E toElement,
boolean inclusive) |
|
java.util.SortedSet<E> |
ForwardingSortedSet.headSet(E toElement) |
|
java.util.SortedSet<K> |
Maps.FilteredEntrySortedMap.SortedKeySet.headSet(K toElement) |
|
java.util.SortedSet<K> |
Maps.NavigableKeySet.headSet(K toElement) |
|
java.util.NavigableSet<K> |
Maps.NavigableKeySet.headSet(K toElement,
boolean inclusive) |
|
java.util.SortedSet<K> |
Maps.SortedKeySet.headSet(K toElement) |
|
java.util.SortedSet<E> |
Sets.DescendingSet.headSet(E toElement) |
|
java.util.NavigableSet<E> |
Sets.DescendingSet.headSet(E toElement,
boolean inclusive) |
|
java.util.NavigableSet<E> |
Sets.FilteredNavigableSet.headSet(E toElement,
boolean inclusive) |
|
java.util.SortedSet<E> |
Sets.FilteredSortedSet.headSet(E toElement) |
|
java.util.NavigableSet<E> |
Sets.UnmodifiableNavigableSet.headSet(E toElement,
boolean inclusive) |
|
java.util.SortedSet<E> |
SortedMultisets.ElementSet.headSet(E toElement) |
|
java.util.NavigableSet<E> |
SortedMultisets.NavigableElementSet.headSet(E toElement,
boolean inclusive) |
|
K |
AbstractMapBasedMultimap.NavigableKeySet.higher(K k) |
|
V |
AbstractMapBasedMultimap.WrappedNavigableSet.higher(V v) |
|
E |
ForwardingNavigableSet.higher(E e) |
|
K |
Maps.NavigableKeySet.higher(K e) |
|
E |
Sets.DescendingSet.higher(E e) |
|
E |
Sets.FilteredNavigableSet.higher(E e) |
|
E |
Sets.UnmodifiableNavigableSet.higher(E e) |
|
E |
SortedMultisets.NavigableElementSet.higher(E e) |
|
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,V> |
Maps.DescendingMap.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) |
|
K |
AbstractMapBasedMultimap.NavigableAsMap.higherKey(K key) |
|
K |
AbstractNavigableMap.higherKey(K key) |
|
K |
ForwardingNavigableMap.higherKey(K key) |
|
K |
Maps.DescendingMap.higherKey(K key) |
|
K |
Maps.TransformedEntriesNavigableMap.higherKey(K key) |
|
K |
Maps.UnmodifiableNavigableMap.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 <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.
|
static <E> Multiset.Entry<E> |
Multisets.immutableEntry(E e,
int n) |
Returns an immutable multiset entry with the specified element and count.
|
(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 |
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 |
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) |
|
(package private) void |
CompactLinkedHashSet.insertEntry(int entryIndex,
E object,
int hash,
int mask) |
|
K |
AbstractMapBasedMultimap.NavigableKeySet.lower(K k) |
|
V |
AbstractMapBasedMultimap.WrappedNavigableSet.lower(V v) |
|
E |
ForwardingNavigableSet.lower(E e) |
|
K |
Maps.NavigableKeySet.lower(K e) |
|
E |
Sets.DescendingSet.lower(E e) |
|
E |
Sets.FilteredNavigableSet.lower(E e) |
|
E |
Sets.UnmodifiableNavigableSet.lower(E e) |
|
E |
SortedMultisets.NavigableElementSet.lower(E e) |
|
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,V> |
Maps.DescendingMap.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) |
|
K |
AbstractMapBasedMultimap.NavigableAsMap.lowerKey(K key) |
|
K |
AbstractNavigableMap.lowerKey(K key) |
|
K |
ForwardingNavigableMap.lowerKey(K key) |
|
K |
Maps.DescendingMap.lowerKey(K key) |
|
K |
Maps.TransformedEntriesNavigableMap.lowerKey(K key) |
|
K |
Maps.UnmodifiableNavigableMap.lowerKey(K key) |
|
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.
|
<E extends T> E |
Ordering.max(E a,
E b) |
Returns the greater of the two values according to this ordering.
|
<E extends T> E |
Ordering.max(E a,
E b) |
Returns the greater of the two values according to this ordering.
|
<E extends T> E |
Ordering.max(E a,
E b,
E c,
E... rest) |
Returns the greatest of the specified values according to this ordering.
|
<E extends T> E |
Ordering.max(E a,
E b,
E c,
E... rest) |
Returns the greatest of the specified values according to this ordering.
|
<E extends T> E |
Ordering.max(E a,
E b,
E c,
E... rest) |
Returns the greatest of the specified values according to this ordering.
|
<E extends T> E |
ReverseOrdering.max(E a,
E b) |
|
<E extends T> E |
ReverseOrdering.max(E a,
E b) |
|
<E extends T> E |
ReverseOrdering.max(E a,
E b,
E c,
E... rest) |
|
<E extends T> E |
ReverseOrdering.max(E a,
E b,
E c,
E... rest) |
|
<E extends T> E |
ReverseOrdering.max(E a,
E b,
E c,
E... rest) |
|
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) |
|
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.
|
<E extends T> E |
Ordering.min(E a,
E b) |
Returns the lesser of the two values according to this ordering.
|
<E extends T> E |
Ordering.min(E a,
E b) |
Returns the lesser of the two values according to this ordering.
|
<E extends T> E |
Ordering.min(E a,
E b,
E c,
E... rest) |
Returns the least of the specified values according to this ordering.
|
<E extends T> E |
Ordering.min(E a,
E b,
E c,
E... rest) |
Returns the least of the specified values according to this ordering.
|
<E extends T> E |
Ordering.min(E a,
E b,
E c,
E... rest) |
Returns the least of the specified values according to this ordering.
|
<E extends T> E |
ReverseOrdering.min(E a,
E b) |
|
<E extends T> E |
ReverseOrdering.min(E a,
E b) |
|
<E extends T> E |
ReverseOrdering.min(E a,
E b,
E c,
E... rest) |
|
<E extends T> E |
ReverseOrdering.min(E a,
E b,
E c,
E... rest) |
|
<E extends T> E |
ReverseOrdering.min(E a,
E b,
E c,
E... rest) |
|
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 |
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 |
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 |
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 |
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) |
|
K |
HashBiMap.Inverse.put(V value,
K key) |
|
K |
HashBiMap.Inverse.put(V value,
K key) |
|
V |
HashBiMap.put(K key,
V value) |
|
V |
HashBiMap.put(K key,
V value) |
|
private V |
HashBiMap.put(K key,
V value,
boolean force) |
|
private V |
HashBiMap.put(K key,
V value,
boolean force) |
|
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.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) |
|
boolean |
Multimaps.UnmodifiableMultimap.put(K key,
V value) |
|
boolean |
Multimaps.UnmodifiableMultimap.put(K key,
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.
|
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) |
|
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 |
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) |
|
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.MapMultimap.putAll(K key,
java.lang.Iterable<? extends V> values) |
|
boolean |
Multimaps.TransformedEntriesMultimap.putAll(K key,
java.lang.Iterable<? extends V2> values) |
|
boolean |
Multimaps.UnmodifiableMultimap.putAll(K key,
java.lang.Iterable<? extends V> 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.Set<V> |
Multimaps.MapMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
|
java.util.List<V2> |
Multimaps.TransformedEntriesListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V2> values) |
|
java.util.Collection<V2> |
Multimaps.TransformedEntriesMultimap.replaceValues(K key,
java.lang.Iterable<? extends V2> values) |
|
java.util.List<V> |
Multimaps.UnmodifiableListMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
|
java.util.Collection<V> |
Multimaps.UnmodifiableMultimap.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> |
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.
|
(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<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<R,V> |
Tables.TransposeTable.row(C 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) |
|
V |
AbstractMapBasedMultimap.WrappedList.set(int index,
V element) |
|
void |
AbstractMapBasedMultimap.WrappedList.WrappedListIterator.set(V value) |
|
E |
ForwardingList.set(int index,
E element) |
|
void |
ForwardingListIterator.set(E element) |
|
void |
LinkedListMultimap.ValueForKeyIterator.set(V value) |
|
E |
Lists.AbstractListWrapper.set(int index,
E element) |
|
T |
Lists.ReverseList.set(int index,
T element) |
|
void |
TransformedListIterator.set(T element) |
|
void |
UnmodifiableListIterator.set(E e) |
Deprecated.
|
int |
AbstractMapBasedMultiset.setCount(E element,
int count) |
|
int |
AbstractMultiset.setCount(E element,
int count) |
|
boolean |
AbstractMultiset.setCount(E element,
int oldCount,
int newCount) |
|
int |
ForwardingMultiset.setCount(E element,
int count) |
|
boolean |
ForwardingMultiset.setCount(E element,
int oldCount,
int newCount) |
|
int |
Multiset.setCount(E element,
int count) |
Adds or removes the necessary occurrences of an element such that the element attains the
desired count.
|
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.
|
int |
Multisets.UnmodifiableMultiset.setCount(E element,
int count) |
|
boolean |
Multisets.UnmodifiableMultiset.setCount(E element,
int oldCount,
int newCount) |
|
(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 |
TreeMultiset.setCount(E element,
int count) |
|
boolean |
TreeMultiset.setCount(E element,
int oldCount,
int newCount) |
|
(package private) static <E> int |
Multisets.setCountImpl(Multiset<E> self,
E element,
int count) |
|
(package private) static <E> boolean |
Multisets.setCountImpl(Multiset<E> self,
E element,
int oldCount,
int newCount) |
|
V |
AbstractMapEntry.setValue(V value) |
|
(package private) abstract V |
ArrayTable.ArrayMap.setValue(int index,
V newValue) |
|
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) |
|
protected boolean |
ForwardingMultiset.standardAdd(E element) |
|
protected E |
ForwardingNavigableSet.standardCeiling(E e) |
|
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardCeilingEntry(K key) |
|
protected K |
ForwardingNavigableMap.standardCeilingKey(K key) |
|
protected E |
ForwardingNavigableSet.standardFloor(E e) |
|
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardFloorEntry(K key) |
|
protected K |
ForwardingNavigableMap.standardFloorKey(K key) |
|
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardHeadMap(K toKey) |
|
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardHeadSet(E toElement) |
|
protected E |
ForwardingNavigableSet.standardHigher(E e) |
|
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardHigherEntry(K key) |
|
protected K |
ForwardingNavigableMap.standardHigherKey(K key) |
|
protected E |
ForwardingNavigableSet.standardLower(E e) |
|
protected java.util.Map.Entry<K,V> |
ForwardingNavigableMap.standardLowerEntry(K key) |
|
protected K |
ForwardingNavigableMap.standardLowerKey(K key) |
|
protected boolean |
ForwardingQueue.standardOffer(E e) |
|
protected int |
ForwardingMultiset.standardSetCount(E element,
int count) |
|
protected boolean |
ForwardingMultiset.standardSetCount(E element,
int oldCount,
int newCount) |
|
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardSubMap(K fromKey,
K toKey) |
|
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardSubMap(K fromKey,
K toKey) |
|
protected SortedMultiset<E> |
ForwardingSortedMultiset.standardSubMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType) |
|
protected SortedMultiset<E> |
ForwardingSortedMultiset.standardSubMultiset(E lowerBound,
BoundType lowerBoundType,
E upperBound,
BoundType upperBoundType) |
|
protected java.util.NavigableSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
|
protected java.util.NavigableSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
boolean fromInclusive,
E toElement,
boolean toInclusive) |
|
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
E toElement) |
|
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardSubSet(E fromElement,
E toElement) |
|
protected java.util.SortedSet<E> |
ForwardingSortedSet.standardSubSet(E fromElement,
E toElement) |
|
protected java.util.SortedSet<E> |
ForwardingSortedSet.standardSubSet(E fromElement,
E toElement) |
|
protected java.util.SortedMap<K,V> |
ForwardingNavigableMap.standardTailMap(K fromKey) |
|
protected java.util.SortedSet<E> |
ForwardingNavigableSet.standardTailSet(E fromElement) |
|
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,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,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.SortedMap<K,V> |
AbstractNavigableMap.subMap(K fromKey,
K toKey) |
|
java.util.SortedMap<K,V> |
AbstractNavigableMap.subMap(K fromKey,
K toKey) |
|
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.SortedMap<K,V> |
ForwardingSortedMap.subMap(K fromKey,
K toKey) |
|
java.util.SortedMap<K,V> |
ForwardingSortedMap.subMap(K fromKey,
K toKey) |
|
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,V> |
Maps.DescendingMap.subMap(K fromKey,
K toKey) |
|
java.util.SortedMap<K,V> |
Maps.DescendingMap.subMap(K fromKey,
K toKey) |
|
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.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.subMap(K fromKey,
K toKey) |
|
java.util.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.subMap(K fromKey,
K toKey) |
|
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.SortedMap<K,V> |
Maps.SortedAsMapView.subMap(K fromKey,
K toKey) |
|
java.util.SortedMap<K,V> |
Maps.SortedAsMapView.subMap(K fromKey,
K toKey) |
|
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,V2> |
Maps.TransformedEntriesNavigableMap.subMap(K fromKey,
K toKey) |
|
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.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,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.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.subMap(K fromKey,
K toKey) |
|
java.util.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.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<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> |
AbstractMapBasedMultimap.NavigableKeySet.subSet(K fromElement,
K toElement) |
|
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.subSet(K fromElement,
K toElement) |
|
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<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.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.SortedSet<E> |
ForwardingSortedSet.subSet(E fromElement,
E toElement) |
|
java.util.SortedSet<E> |
ForwardingSortedSet.subSet(E fromElement,
E 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.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> |
Maps.NavigableKeySet.subSet(K fromElement,
K toElement) |
|
java.util.SortedSet<K> |
Maps.NavigableKeySet.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.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.SortedSet<E> |
Sets.DescendingSet.subSet(E fromElement,
E toElement) |
|
java.util.SortedSet<E> |
Sets.DescendingSet.subSet(E fromElement,
E toElement) |
|
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.SortedSet<E> |
Sets.FilteredSortedSet.subSet(E fromElement,
E toElement) |
|
java.util.SortedSet<E> |
Sets.FilteredSortedSet.subSet(E fromElement,
E toElement) |
|
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.SortedSet<E> |
SortedMultisets.ElementSet.subSet(E fromElement,
E toElement) |
|
java.util.SortedSet<E> |
SortedMultisets.ElementSet.subSet(E fromElement,
E toElement) |
|
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.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.tailMap(K fromKey) |
|
java.util.NavigableMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.NavigableAsMap.tailMap(K fromKey,
boolean inclusive) |
|
java.util.SortedMap<K,java.util.Collection<V>> |
AbstractMapBasedMultimap.SortedAsMap.tailMap(K fromKey) |
|
java.util.SortedMap<K,V> |
AbstractNavigableMap.tailMap(K fromKey) |
|
java.util.NavigableMap<K,V> |
ForwardingNavigableMap.tailMap(K fromKey,
boolean inclusive) |
|
java.util.SortedMap<K,V> |
ForwardingSortedMap.tailMap(K fromKey) |
|
java.util.SortedMap<K,V> |
Maps.DescendingMap.tailMap(K fromKey) |
|
java.util.NavigableMap<K,V> |
Maps.DescendingMap.tailMap(K fromKey,
boolean inclusive) |
|
java.util.NavigableMap<K,V> |
Maps.FilteredEntryNavigableMap.tailMap(K fromKey,
boolean inclusive) |
|
java.util.SortedMap<K,V> |
Maps.FilteredEntrySortedMap.tailMap(K fromKey) |
|
java.util.NavigableMap<K,V> |
Maps.NavigableAsMapView.tailMap(K fromKey,
boolean inclusive) |
|
java.util.SortedMap<K,V> |
Maps.SortedAsMapView.tailMap(K fromKey) |
|
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.tailMap(K fromKey) |
|
java.util.NavigableMap<K,V2> |
Maps.TransformedEntriesNavigableMap.tailMap(K fromKey,
boolean inclusive) |
|
java.util.SortedMap<K,V2> |
Maps.TransformedEntriesSortedMap.tailMap(K fromKey) |
|
java.util.SortedMap<K,V> |
Maps.UnmodifiableNavigableMap.tailMap(K fromKey) |
|
java.util.NavigableMap<K,V> |
Maps.UnmodifiableNavigableMap.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.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.tailSet(K fromElement) |
|
java.util.NavigableSet<K> |
AbstractMapBasedMultimap.NavigableKeySet.tailSet(K fromElement,
boolean inclusive) |
|
java.util.SortedSet<K> |
AbstractMapBasedMultimap.SortedKeySet.tailSet(K fromElement) |
|
java.util.NavigableSet<V> |
AbstractMapBasedMultimap.WrappedNavigableSet.tailSet(V fromElement,
boolean inclusive) |
|
java.util.SortedSet<V> |
AbstractMapBasedMultimap.WrappedSortedSet.tailSet(V fromElement) |
|
java.util.NavigableSet<E> |
ForwardingNavigableSet.tailSet(E fromElement,
boolean inclusive) |
|
java.util.SortedSet<E> |
ForwardingSortedSet.tailSet(E fromElement) |
|
java.util.SortedSet<K> |
Maps.FilteredEntrySortedMap.SortedKeySet.tailSet(K fromElement) |
|
java.util.SortedSet<K> |
Maps.NavigableKeySet.tailSet(K fromElement) |
|
java.util.NavigableSet<K> |
Maps.NavigableKeySet.tailSet(K fromElement,
boolean inclusive) |
|
java.util.SortedSet<K> |
Maps.SortedKeySet.tailSet(K fromElement) |
|
java.util.SortedSet<E> |
Sets.DescendingSet.tailSet(E fromElement) |
|
java.util.NavigableSet<E> |
Sets.DescendingSet.tailSet(E fromElement,
boolean inclusive) |
|
java.util.NavigableSet<E> |
Sets.FilteredNavigableSet.tailSet(E fromElement,
boolean inclusive) |
|
java.util.SortedSet<E> |
Sets.FilteredSortedSet.tailSet(E fromElement) |
|
java.util.NavigableSet<E> |
Sets.UnmodifiableNavigableSet.tailSet(E fromElement,
boolean inclusive) |
|
java.util.SortedSet<E> |
SortedMultisets.ElementSet.tailSet(E fromElement) |
|
java.util.NavigableSet<E> |
SortedMultisets.NavigableElementSet.tailSet(E fromElement,
boolean inclusive) |
|
(package private) boolean |
GeneralRange.tooHigh(T t) |
|
(package private) boolean |
GeneralRange.tooLow(T t) |
|
(package private) java.util.List<V2> |
Multimaps.TransformedEntriesListMultimap.transform(K key,
java.util.Collection<V1> values) |
|
(package private) java.util.Collection<V2> |
Multimaps.TransformedEntriesMultimap.transform(K key,
java.util.Collection<V1> values) |
|
(package private) abstract T |
TransformedIterator.transform(F from) |
|
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) |
|