@GwtCompatible class StandardTable<R,C,V> extends AbstractTable<R,C,V> implements java.io.Serializable
Table
implementation backed by a map that associates row keys with
column key / value secondary maps. This class provides rapid access to
records by the row key alone or by both keys, but not by just the column key.
The views returned by column(C)
, columnKeySet()
, and columnMap()
have iterators that don't support remove()
. Otherwise,
all optional operations are supported. Null row keys, columns keys, and
values are not supported.
Lookups by row key are often faster than lookups by column key, because
the data is stored in a Map<R, Map<C, V>>
. A method call like column(columnKey).get(rowKey)
still runs quickly, since the row key is
provided. However, column(columnKey).size()
takes longer, since an
iteration across all row keys occurs.
Note that this implementation is not synchronized. If multiple threads access this table concurrently and one of the threads modifies the table, it must be synchronized externally.
Modifier and Type | Class and Description |
---|---|
private class |
StandardTable.CellIterator |
private class |
StandardTable.Column |
private class |
StandardTable.ColumnKeyIterator |
private class |
StandardTable.ColumnKeySet |
private class |
StandardTable.ColumnMap |
(package private) class |
StandardTable.Row |
(package private) class |
StandardTable.RowMap |
private class |
StandardTable.TableSet<T>
Abstract set whose
isEmpty() returns whether the table is empty and
whose clear() clears all table mappings. |
AbstractTable.CellSet, AbstractTable.Values
Table.Cell<R,C,V>
Modifier and Type | Field and Description |
---|---|
(package private) java.util.Map<R,java.util.Map<C,V>> |
backingMap |
private java.util.Set<C> |
columnKeySet |
private StandardTable.ColumnMap |
columnMap |
(package private) Supplier<? extends java.util.Map<C,V>> |
factory |
private java.util.Map<R,java.util.Map<C,V>> |
rowMap |
private static long |
serialVersionUID |
Constructor and Description |
---|
StandardTable(java.util.Map<R,java.util.Map<C,V>> backingMap,
Supplier<? extends java.util.Map<C,V>> factory) |
Modifier and Type | Method and Description |
---|---|
(package private) java.util.Iterator<Table.Cell<R,C,V>> |
cellIterator() |
java.util.Set<Table.Cell<R,C,V>> |
cellSet()
Returns a set of all row key / column key / value triplets.
|
void |
clear()
Removes all mappings from the table.
|
java.util.Map<R,V> |
column(C columnKey)
Returns a view of all mappings that have the given column key.
|
java.util.Set<C> |
columnKeySet()
Returns a set of column keys that have one or more values in the table.
|
java.util.Map<C,java.util.Map<R,V>> |
columnMap()
Returns a view that associates each column key with the corresponding map
from row keys to values.
|
boolean |
contains(java.lang.Object rowKey,
java.lang.Object columnKey)
Returns
true if the table contains a mapping with the specified
row and column keys. |
boolean |
containsColumn(java.lang.Object columnKey)
Returns
true if the table contains a mapping with the specified
column. |
private boolean |
containsMapping(java.lang.Object rowKey,
java.lang.Object columnKey,
java.lang.Object value) |
boolean |
containsRow(java.lang.Object rowKey)
Returns
true if the table contains a mapping with the specified
row key. |
boolean |
containsValue(java.lang.Object value)
Returns
true if the table contains a mapping with the specified
value. |
(package private) java.util.Iterator<C> |
createColumnKeyIterator()
Creates an iterator that returns each column value with duplicates
omitted.
|
(package private) java.util.Map<R,java.util.Map<C,V>> |
createRowMap() |
V |
get(java.lang.Object rowKey,
java.lang.Object columnKey)
Returns the value corresponding to the given row and column keys, or
null if no such mapping exists. |
private java.util.Map<C,V> |
getOrCreate(R rowKey) |
boolean |
isEmpty()
Returns
true if the table contains no mappings. |
V |
put(R rowKey,
C columnKey,
V value)
Associates the specified value with the specified keys.
|
V |
remove(java.lang.Object rowKey,
java.lang.Object columnKey)
Removes the mapping, if any, associated with the given keys.
|
private java.util.Map<R,V> |
removeColumn(java.lang.Object column) |
private boolean |
removeMapping(java.lang.Object rowKey,
java.lang.Object columnKey,
java.lang.Object value)
Remove a row key / column key / value mapping, if present.
|
java.util.Map<C,V> |
row(R rowKey)
Returns a view of all mappings that have the given row key.
|
java.util.Set<R> |
rowKeySet()
Returns a set of row keys that have one or more values in the table.
|
java.util.Map<R,java.util.Map<C,V>> |
rowMap()
Returns a view that associates each row key with the corresponding map from
column keys to values.
|
int |
size()
Returns the number of row key / column key / value mappings in the table.
|
java.util.Collection<V> |
values()
Returns a collection of all values, which may contain duplicates.
|
createCellSet, createValues, equals, hashCode, putAll, toString, valuesIterator
@GwtTransient final java.util.Map<R,java.util.Map<C,V>> backingMap
@GwtTransient final Supplier<? extends java.util.Map<C,V>> factory
private transient java.util.Set<C> columnKeySet
private transient StandardTable.ColumnMap columnMap
private static final long serialVersionUID
public boolean contains(@Nullable java.lang.Object rowKey, @Nullable java.lang.Object columnKey)
Table
true
if the table contains a mapping with the specified
row and column keys.public boolean containsColumn(@Nullable java.lang.Object columnKey)
Table
true
if the table contains a mapping with the specified
column.containsColumn
in interface Table<R,C,V>
containsColumn
in class AbstractTable<R,C,V>
columnKey
- key of column to search forpublic boolean containsRow(@Nullable java.lang.Object rowKey)
Table
true
if the table contains a mapping with the specified
row key.containsRow
in interface Table<R,C,V>
containsRow
in class AbstractTable<R,C,V>
rowKey
- key of row to search forpublic boolean containsValue(@Nullable java.lang.Object value)
Table
true
if the table contains a mapping with the specified
value.containsValue
in interface Table<R,C,V>
containsValue
in class AbstractTable<R,C,V>
value
- value to search forpublic V get(@Nullable java.lang.Object rowKey, @Nullable java.lang.Object columnKey)
Table
null
if no such mapping exists.public boolean isEmpty()
Table
true
if the table contains no mappings.public int size()
Table
public void clear()
Table
public V put(R rowKey, C columnKey, V value)
Table
put
in interface Table<R,C,V>
put
in class AbstractTable<R,C,V>
rowKey
- row key that the value should be associated withcolumnKey
- column key that the value should be associated withvalue
- value to be associated with the specified keysnull
if
no mapping existed for the keyspublic V remove(@Nullable java.lang.Object rowKey, @Nullable java.lang.Object columnKey)
Table
private boolean containsMapping(java.lang.Object rowKey, java.lang.Object columnKey, java.lang.Object value)
private boolean removeMapping(java.lang.Object rowKey, java.lang.Object columnKey, java.lang.Object value)
public java.util.Set<Table.Cell<R,C,V>> cellSet()
add
or addAll
methods.
The set's iterator traverses the mappings for the first row, the mappings for the second row, and so on.
Each cell is an immutable snapshot of a row key / column key / value mapping, taken at the time the cell is returned by a method call to the set or its iterator.
java.util.Iterator<Table.Cell<R,C,V>> cellIterator()
cellIterator
in class AbstractTable<R,C,V>
public java.util.Map<C,V> row(R rowKey)
Table
Changes to the returned map will update the underlying table, and vice versa.
public java.util.Map<R,V> column(C columnKey)
Changes to the returned map will update the underlying table, and vice versa.
The returned map's views have iterators that don't support
remove()
.
public java.util.Set<R> rowKeySet()
Table
public java.util.Set<C> columnKeySet()
The returned set has an iterator that does not support remove()
.
The set's iterator traverses the columns of the first row, the columns of the second row, etc., skipping any columns that have appeared previously.
columnKeySet
in interface Table<R,C,V>
columnKeySet
in class AbstractTable<R,C,V>
java.util.Iterator<C> createColumnKeyIterator()
public java.util.Collection<V> values()
The collection's iterator traverses the values for the first row, the values for the second row, and so on.
public java.util.Map<R,java.util.Map<C,V>> rowMap()
Table
put()
or putAll()
, or
setValue()
on its entries.
In contrast, the maps returned by rowMap().get()
have the same
behavior as those returned by Table.row(R)
. Those maps may support setValue()
, put()
, and putAll()
.
public java.util.Map<C,java.util.Map<R,V>> columnMap()
Table
put()
or putAll()
,
or setValue()
on its entries.
In contrast, the maps returned by columnMap().get()
have the
same behavior as those returned by Table.column(C)
. Those maps may support
setValue()
, put()
, and putAll()
.