Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2008 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.collect;
 
 import static com.google.common.base.Preconditions.checkArgument;
 
 
 import java.util.Map;
 
 import  javax.annotation.Nullable;

Implementation of Table using hash tables.

The views returned by column, 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.

See the Guava User Guide article on Table.

Author(s):
Jared Levy
Since:
7.0
 
 @GwtCompatible(serializable = true)
 public class HashBasedTable<R, C, V> extends StandardTable<R, C, V> {
   private static class Factory<C, V>
       implements Supplier<Map<C, V>>, Serializable {
     final int expectedSize;
     Factory(int expectedSize) {
       this. = expectedSize;
     }
     @Override
     public Map<C, V> get() {
       return Maps.newHashMapWithExpectedSize();
     }
     private static final long serialVersionUID = 0;
   }

  
Creates an empty HashBasedTable.
 
   public static <R, C, V> HashBasedTable<R, C, V> create() {
     return new HashBasedTable<R, C, V>(
         new HashMap<R, Map<C, V>>(), new Factory<C, V>(0));
   }

  
Creates an empty HashBasedTable with the specified map sizes.

Parameters:
expectedRows the expected number of distinct row keys
expectedCellsPerRow the expected number of column key / value mappings in each row
Throws:
IllegalArgumentException if expectedRows or expectedCellsPerRow is negative
 
   public static <R, C, V> HashBasedTable<R, C, V> create(
       int expectedRowsint expectedCellsPerRow) {
     checkArgument(expectedCellsPerRow >= 0);
     Map<R, Map<C, V>> backingMap =
         Maps.newHashMapWithExpectedSize(expectedRows);
     return new HashBasedTable<R, C, V>(
         backingMapnew Factory<C, V>(expectedCellsPerRow));
   }

  
Creates a HashBasedTable with the same mappings as the specified table.

Parameters:
table the table to copy
Throws:
NullPointerException if any of the row keys, column keys, or values in table is null
  public static <R, C, V> HashBasedTable<R, C, V> create(
      Table<? extends R, ? extends C, ? extends V> table) {
    HashBasedTable<R, C, V> result = create();
    result.putAll(table);
    return result;
  }
  HashBasedTable(Map<R, Map<C, V>> backingMapFactory<C, V> factory) {
    super(backingMapfactory);
  }
  // Overriding so NullPointerTester test passes.
  @Override public boolean contains(
      @Nullable Object rowKey, @Nullable Object columnKey) {
    return super.contains(rowKeycolumnKey);
  }
  @Override public boolean containsColumn(@Nullable Object columnKey) {
    return super.containsColumn(columnKey);
  }
  @Override public boolean containsRow(@Nullable Object rowKey) {
    return super.containsRow(rowKey);
  }
  @Override public boolean containsValue(@Nullable Object value) {
    return super.containsValue(value);
  }
  @Override public V get(@Nullable Object rowKey, @Nullable Object columnKey) {
    return super.get(rowKeycolumnKey);
  }
  @Override public boolean equals(@Nullable Object obj) {
    return super.equals(obj);
  }
  @Override public V remove(
      @Nullable Object rowKey, @Nullable Object columnKey) {
    return super.remove(rowKeycolumnKey);
  }
  private static final long serialVersionUID = 0;
New to GrepCode? Check out our FAQ X