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.
|
(package private) java.util.Spliterator<Table.Cell<R,C,V>> |
cellSpliterator() |
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, valuesSpliterator
@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(java.lang.Object rowKey, java.lang.Object columnKey)
Table
true
if the table contains a mapping with the specified row and column keys.public boolean containsColumn(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(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(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(java.lang.Object rowKey, 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(java.lang.Object rowKey, 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>
java.util.Spliterator<Table.Cell<R,C,V>> cellSpliterator()
cellSpliterator
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()
.