## com.google.common.collect
Class ImmutableTable<R,C,V>

    java.lang.Object
      com.google.common.collect.ImmutableTable<R,C,V>

All Implemented Interfaces:
  Table<R,C,V>

    @GwtCompatible
    public abstract class ImmutableTable<R,C,V>

extends Object
implements Table<R,C,V>

An immutable `Table` with reliable user-specified iteration order. Does not permit null keys or values.

Note: Although this class is not final, it cannot be subclassed as it has no public or protected constructors. Thus, instances of this class are guaranteed to be immutable.

See the Guava User Guide article on immutable collections.

Since:
  11.0
Author:
  Gregory Kick

Nested Class Summary
`static class` `ImmutableTable.Builder<R,C,V>` A builder for creating immutable table instances, especially `public static final` tables ("constant tables").

Nested classes/interfaces inherited from interface com.google.common.collect.Table
`Table.Cell<R,C,V>`

Method Summary

`static

`<R,C,V> ImmutableTable.Builder<R,C,V>`

`

`builder()`
Returns a new builder.

`abstract ImmutableSet<Table.Cell<R,C,V>>` `cellSet()` Returns a set of all row key / column key / value triplets.
`void` `clear()` Guaranteed to throw an exception and leave the table unmodified.
`abstract ImmutableMap<R,V>` `column(C columnKey)` Returns a view of all mappings that have the given column key.
`abstract ImmutableSet<C>` `columnKeySet()` Returns a set of column keys that have one or more values in the table.
`abstract ImmutableMap<C,Map<R,V>>` `columnMap()` Returns a view that associates each column key with the corresponding map from row keys to values.

`static

`<R,C,V> ImmutableTable<R,C,V>`

`

`copyOf(Table<? extends R,? extends C,? extends V> table)`
Returns an immutable copy of the provided table.

`boolean` `equals(Object obj)` Compares the specified object with this table for equality.
`int` `hashCode()` Returns the hash code for this table.

`static

`<R,C,V> ImmutableTable<R,C,V>`

`

`of()`
Returns an empty immutable table.

`static

`<R,C,V> ImmutableTable<R,C,V>`

`

`of(R rowKey, C columnKey, V value)`
Returns an immutable table containing a single cell.

`V` `put(R rowKey, C columnKey, V value)` Guaranteed to throw an exception and leave the table unmodified.
`void` `putAll(Table<? extends R,? extends C,? extends V> table)` Guaranteed to throw an exception and leave the table unmodified.
`V` `remove(Object rowKey, Object columnKey)` Guaranteed to throw an exception and leave the table unmodified.
`abstract ImmutableMap<C,V>` `row(R rowKey)` Returns a view of all mappings that have the given row key.
`abstract ImmutableSet<R>` `rowKeySet()` Returns a set of row keys that have one or more values in the table.
`abstract ImmutableMap<R,Map<C,V>>` `rowMap()` Returns a view that associates each row key with the corresponding map from column keys to values.
`String` `toString()`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface com.google.common.collect.Table
`contains, containsColumn, containsRow, containsValue, get, isEmpty, size, values`

Method Detail

### of

    public static final <R,C,V> ImmutableTable<R,C,V> of()

  Returns an empty immutable table.

### of

    public static final <R,C,V> ImmutableTable<R,C,V> of(R rowKey,
                                                         C columnKey,
                                                         V value)

  Returns an immutable table containing a single cell.

### copyOf

    public static final <R,C,V> ImmutableTable<R,C,V> copyOf(Table<? extends R,? extends C,? extends V> table)

  Returns an immutable copy of the provided table.

  The `Table.cellSet()` iteration order of the provided table determines the iteration ordering of all views in the returned table. Note that some views of the original table and the copied table may have different iteration orders. For more control over the ordering, create a `ImmutableTable.Builder` and call `ImmutableTable.Builder.orderRowsBy(java.util.Comparator<? super R>)`, `ImmutableTable.Builder.orderColumnsBy(java.util.Comparator<? super C>)`, and `ImmutableTable.Builder.putAll(com.google.common.collect.Table<? extends R, ? extends C, ? extends V>)`

  Despite the method name, this method attempts to avoid actually copying the data when it is safe to do so. The exact circumstances under which a copy will or will not be performed are undocumented and subject to change.

### builder

    public static final <R,C,V> ImmutableTable.Builder<R,C,V> builder()

  Returns a new builder. The generated builder is equivalent to the builder created by the `ImmutableTable.Builder.ImmutableTable.Builder()` constructor.

### cellSet

    public abstract ImmutableSet<Table.Cell<R,C,V>> cellSet()

  Description copied from interface: `Table`
  Returns a set of all row key / column key / value triplets. Changes to the returned set will update the underlying table, and vice versa. The cell set does not support the `add` or `addAll` methods.

  Specified by:
    `cellSet` in interface `Table<R,C,V>`
  Returns:
    set of table cells consisting of row key / column key / value triplets

### column

    public abstract ImmutableMap<R,V> column(C columnKey)

  Returns a view of all mappings that have the given column key. For each row key / column key / value mapping in the table with that column key, the returned map associates the row key with the value. If no mappings in the table have the provided column key, an empty map is returned.

  Changes to the returned map will update the underlying table, and vice versa.

  Specified by:
    `column` in interface `Table<R,C,V>`
  Parameters:
    `columnKey` - key of column to search for in the table
  Returns:
    the corresponding map from row keys to values
  Throws:
    `NullPointerException` - if `columnKey` is `null`

### columnKeySet

    public abstract ImmutableSet<C> columnKeySet()

  Description copied from interface: `Table`
  Returns a set of column keys that have one or more values in the table. Changes to the set will update the underlying table, and vice versa.

  Specified by:
    `columnKeySet` in interface `Table<R,C,V>`
  Returns:
    set of column keys

### columnMap

    public abstract ImmutableMap<C,Map<R,V>> columnMap()

  Returns a view that associates each column key with the corresponding map from row keys to values. Changes to the returned map will update this table. The returned map does not support `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()`.

  The value `Map<R, V>`s in the returned map are `ImmutableMap`s as well.

  Specified by:
    `columnMap` in interface `Table<R,C,V>`
  Returns:
    a map view from each column key to a secondary map from row keys to values

### row

    public abstract ImmutableMap<C,V> row(R rowKey)

  Returns a view of all mappings that have the given row key. For each row key / column key / value mapping in the table with that row key, the returned map associates the column key with the value. If no mappings in the table have the provided row key, an empty map is returned.

  Changes to the returned map will update the underlying table, and vice versa.

  Specified by:
    `row` in interface `Table<R,C,V>`
  Parameters:
    `rowKey` - key of row to search for in the table
  Returns:
    the corresponding map from column keys to values
  Throws:
    `NullPointerException` - if `rowKey` is `null`

### rowKeySet

    public abstract ImmutableSet<R> rowKeySet()

  Description copied from interface: `Table`
  Returns a set of row keys that have one or more values in the table. Changes to the set will update the underlying table, and vice versa.

  Specified by:
    `rowKeySet` in interface `Table<R,C,V>`
  Returns:
    set of row keys

### rowMap

    public abstract ImmutableMap<R,Map<C,V>> rowMap()

  Returns a view that associates each row key with the corresponding map from column keys to values. Changes to the returned map will update this table. The returned map does not support `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()`.

  The value `Map<C, V>`s in the returned map are `ImmutableMap`s as well.

  Specified by:
    `rowMap` in interface `Table<R,C,V>`
  Returns:
    a map view from each row key to a secondary map from column keys to values

### clear

    public final void clear()

  Guaranteed to throw an exception and leave the table unmodified.

  Specified by:
    `clear` in interface `Table<R,C,V>`
  Throws:
    `UnsupportedOperationException` - always

### put

    public final V put(R rowKey,
                       C columnKey,
                       V value)

  Guaranteed to throw an exception and leave the table unmodified.

  Specified by:
    `put` in interface `Table<R,C,V>`
  Parameters:
    `rowKey` - row key that the value should be associated with
    `columnKey` - column key that the value should be associated with
    `value` - value to be associated with the specified keys
  Returns:
    the value previously associated with the keys, or `null` if no mapping existed for the keys
  Throws:
    `UnsupportedOperationException` - always

### putAll

    public final void putAll(Table<? extends R,? extends C,? extends V> table)

  Guaranteed to throw an exception and leave the table unmodified.

  Specified by:
    `putAll` in interface `Table<R,C,V>`
  Parameters:
    `table` - the table to add to this table
  Throws:
    `UnsupportedOperationException` - always

### remove

    public final V remove(Object rowKey,
                          Object columnKey)

  Guaranteed to throw an exception and leave the table unmodified.

  Specified by:
    `remove` in interface `Table<R,C,V>`
  Parameters:
    `rowKey` - row key of mapping to be removed
    `columnKey` - column key of mapping to be removed
  Returns:
    the value previously associated with the keys, or `null` if no such value existed
  Throws:
    `UnsupportedOperationException` - always

### equals

    public boolean equals(@Nullable
                          Object obj)

  Description copied from interface: `Table`
  Compares the specified object with this table for equality. Two tables are equal when their cell views, as returned by `Table.cellSet()`, are equal.

  Specified by:
    `equals` in interface `Table<R,C,V>`
  Overrides:
    `equals` in class `Object`

### hashCode

    public int hashCode()

  Description copied from interface: `Table`
  Returns the hash code for this table. The hash code of a table is defined as the hash code of its cell view, as returned by `Table.cellSet()`.

  Specified by:
    `hashCode` in interface `Table<R,C,V>`
  Overrides:
    `hashCode` in class `Object`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

Copyright © 2010-2012. All Rights Reserved.