Table

Object
- Table

```
public class Table
extends Object
```
Generic class for handling tabular data, typically from a CSV, TSV, or other sort of spreadsheet file.

CSV files are comma separated values, often with the data in quotes. TSV files use tabs as separators, and usually don't bother with the quotes.

File names should end with .csv if they're comma separated.

A rough "spec" for CSV can be found here.

See Also:

PApplet.loadTable(String), PApplet.saveTable(Table, String), TableRow

Field Summary

Fields
Modifier and Type Field and Description

static int CATEGORY

static int DOUBLE

static int FLOAT

static int INT

static int LONG

static int STRING

Fields
Modifier and Type	Field and Description
`static int`	`CATEGORY`
`static int`	`DOUBLE`
`static int`	`FLOAT`
`static int`	`INT`
`static int`	`LONG`
`static int`	`STRING`

Constructor Summary

Constructors
Constructor and Description
`Table()` Creates a new, empty table.
`Table(File file)`
`Table(File file, String options)` version that uses a File object; future releases (or data types) may include additional optimizations here
`Table(InputStream input)`
`Table(InputStream input, String options)` Read the table from a stream.
`Table(Iterable<TableRow> rows)`
`Table(ResultSet rs)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addColumn()`
`void`	`addColumn(String title)`
`void`	`addColumn(String title, int type)`
`TableRow`	`addRow()`
`TableRow`	`addRow(Object[] columnData)`
`TableRow`	`addRow(TableRow source)`
`void`	`addRows(Table source)`
`int`	`checkColumnIndex(String title)` Same as getColumnIndex(), but creates the column if it doesn't exist.
`void`	`clearRows()`
`Table`	`copy()` Make a copy of the current table
`static String`	`extensionOptions(boolean loading, String filename, String options)`
`TableRow`	`findRow(String value, int column)`
`TableRow`	`findRow(String value, String columnName)`
`int`	`findRowIndex(String value, int column)` Return the row that contains the first String that matches.
`int`	`findRowIndex(String value, String columnName)` Return the row that contains the first String that matches.
`int[]`	`findRowIndices(String value, int column)` Return a list of rows that contain the String passed in.
`int[]`	`findRowIndices(String value, String columnName)` Return a list of rows that contain the String passed in.
`Iterator<TableRow>`	`findRowIterator(String value, int column)`
`Iterator<TableRow>`	`findRowIterator(String value, String columnName)`
`Iterable<TableRow>`	`findRows(String value, int column)`
`Iterable<TableRow>`	`findRows(String value, String columnName)`
`int`	`getColumnCount()`
`int`	`getColumnIndex(String columnName)`
`String`	`getColumnTitle(int col)`
`String[]`	`getColumnTitles()`
`int`	`getColumnType(int column)` Returns one of Table.STRING, Table.INT, etc...
`int`	`getColumnType(String columnName)`
`int[]`	`getColumnTypes()`
`double`	`getDouble(int row, int column)`
`double`	`getDouble(int row, String columnName)`
`double[]`	`getDoubleColumn(int col)`
`double[]`	`getDoubleColumn(String name)`
`double[]`	`getDoubleRow(int row)`
`float`	`getFloat(int row, int column)` Get a float value from the specified row and column.
`float`	`getFloat(int row, String columnName)`
`float[]`	`getFloatColumn(int col)`
`float[]`	`getFloatColumn(String name)`
`FloatDict`	`getFloatDict(int keyColumn, int valueColumn)`
`FloatDict`	`getFloatDict(String keyColumnName, String valueColumnName)`
`FloatList`	`getFloatList(int column)`
`FloatList`	`getFloatList(String columnName)`
`float[]`	`getFloatRow(int row)`
`int`	`getInt(int row, int column)`
`int`	`getInt(int row, String columnName)`
`int[]`	`getIntColumn(int col)`
`int[]`	`getIntColumn(String name)`
`IntDict`	`getIntDict(int keyColumn, int valueColumn)`
`IntDict`	`getIntDict(String keyColumnName, String valueColumnName)`
`IntList`	`getIntList(int column)`
`IntList`	`getIntList(String columnName)`
`int[]`	`getIntRow(int row)`
`long`	`getLong(int row, int column)`
`long`	`getLong(int row, String columnName)`
`long[]`	`getLongColumn(int col)`
`long[]`	`getLongColumn(String name)`
`long[]`	`getLongRow(int row)`
`IntDict`	`getOrder(int column)`
`IntDict`	`getOrder(String columnName)`
`TableRow`	`getRow(int row)`
`int`	`getRowCount()`
`Map<String,TableRow>`	`getRowMap(int column)` Return a mapping that connects the entry from a column back to the row from which it came.
`Map<String,TableRow>`	`getRowMap(String columnName)`
`String`	`getString(int row, int column)` Get a String value from the table.
`String`	`getString(int row, String columnName)`
`String[]`	`getStringColumn(int column)`
`String[]`	`getStringColumn(String columnName)`
`StringDict`	`getStringDict(int keyColumn, int valueColumn)`
`StringDict`	`getStringDict(String keyColumnName, String valueColumnName)`
`StringList`	`getStringList(int column)`
`StringList`	`getStringList(String columnName)`
`String[]`	`getStringRow(int row)`
`IntDict`	`getTally(int column)`
`IntDict`	`getTally(String columnName)`
`String[]`	`getUnique(int column)`
`String[]`	`getUnique(String columnName)`
`boolean`	`hasColumnTitles()`
`void`	`insertColumn(int index)`
`void`	`insertColumn(int index, String title)`
`void`	`insertColumn(int index, String title, int type)`
`void`	`insertRow(int insert, Object[] columnData)`
`int`	`lastRowIndex()`
`TableRow`	`matchRow(String regexp, int column)`
`TableRow`	`matchRow(String regexp, String columnName)`
`int`	`matchRowIndex(String regexp, int column)` Return the row that contains the first String that matches.
`int`	`matchRowIndex(String what, String columnName)` Return the row that contains the first String that matches.
`int[]`	`matchRowIndices(String regexp, int column)` Return a list of rows that contain the String passed in.
`int[]`	`matchRowIndices(String what, String columnName)` Return a list of rows that match the regex passed in.
`Iterator<TableRow>`	`matchRowIterator(String value, int column)`
`Iterator<TableRow>`	`matchRowIterator(String value, String columnName)`
`Iterable<TableRow>`	`matchRows(String regexp, int column)`
`Iterable<TableRow>`	`matchRows(String regexp, String columnName)`
`void`	`parseInto(Object enclosingObject, String fieldName)` incomplete, do not use
`void`	`print()`
`void`	`removeColumn(int column)`
`void`	`removeColumn(String columnName)`
`void`	`removeRow(int row)`
`String[]`	`removeTitleRow()` Deprecated.
`void`	`removeTokens(String tokens)` Remove any of the specified characters from the entire table.
`void`	`removeTokens(String tokens, int column)` Removed any of the specified characters from a column.
`void`	`removeTokens(String tokens, String columnName)`
`void`	`replace(String orig, String replacement)` Replace a String with another.
`void`	`replace(String orig, String replacement, int col)`
`void`	`replace(String orig, String replacement, String colName)`
`void`	`replaceAll(String regex, String replacement)`
`void`	`replaceAll(String regex, String replacement, int column)`
`void`	`replaceAll(String regex, String replacement, String columnName)` Run String.replaceAll() on all entries in a column.
`Iterable<TableRow>`	`rows()` Note that this one iterator instance is shared by any calls to iterate the rows of this table.
`Iterable<TableRow>`	`rows(int[] indices)`
`boolean`	`save(File file, String options)`
`boolean`	`save(OutputStream output, String options)`
`void`	`setColumnCount(int newCount)` Change the number of columns in this table.
`void`	`setColumnTitle(int column, String title)`
`void`	`setColumnTitles(String[] titles)`
`void`	`setColumnType(int column, int newType)` Sets the column type.
`void`	`setColumnType(int column, String columnType)` Set the data type for a column so that using it is more efficient.
`void`	`setColumnType(String columnName, int newType)`
`void`	`setColumnType(String columnName, String columnType)`
`void`	`setColumnTypes(int[] types)`
`void`	`setColumnTypes(Table dictionary)` Set the titles (and if a second column is present) the data types for this table based on a file loaded separately.
`void`	`setDouble(int row, int column, double value)`
`void`	`setDouble(int row, String columnName, double value)`
`void`	`setFloat(int row, int column, float value)`
`void`	`setFloat(int row, String columnName, float value)`
`void`	`setInt(int row, int column, int value)`
`void`	`setInt(int row, String columnName, int value)`
`void`	`setLong(int row, int column, long value)`
`void`	`setLong(int row, String columnName, long value)`
`void`	`setMissingDouble(double value)`
`void`	`setMissingFloat(float value)`
`void`	`setMissingInt(int value)`
`void`	`setMissingLong(long value)`
`void`	`setMissingString(String value)` Treat entries with this string as "missing".
`void`	`setRow(int row, Object[] pieces)`
`TableRow`	`setRow(int row, TableRow source)`
`void`	`setRowCount(int newCount)`
`void`	`setString(int row, int column, String value)`
`void`	`setString(int row, String columnName, String value)`
`void`	`setTableType(String type)` Set the entire table to a specific data type.
`void`	`sort(int column)`
`void`	`sort(String columnName)` Sorts (orders) a table based on the values in a column.
`void`	`sortReverse(int column)`
`void`	`sortReverse(String columnName)`
`void`	`trim()`
`void`	`trim(int column)`
`void`	`trim(String columnName)`
`Table`	`typedParse(InputStream input, String options)`
`void`	`write(PrintWriter writer)`

Methods inherited from class Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - STRING
```
public static final int STRING
```
    See Also:
    
    Constant Field Values
  - INT
```
public static final int INT
```
    See Also:
    
    Constant Field Values
  - LONG
```
public static final int LONG
```
    See Also:
    
    Constant Field Values
  - FLOAT
```
public static final int FLOAT
```
    See Also:
    
    Constant Field Values
  - DOUBLE
```
public static final int DOUBLE
```
    See Also:
    
    Constant Field Values
  - CATEGORY
```
public static final int CATEGORY
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Table
```
public Table()
```
    Creates a new, empty table. Use addRow() to add additional rows.
  - Table
```
public Table(File file)
      throws IOException
```
    Throws:
    
    IOException
  - Table
```
public Table(File file,
             String options)
      throws IOException
```
    version that uses a File object; future releases (or data types) may include additional optimizations here
    
    Throws:
    
    IOException
  - Table
```
public Table(InputStream input)
      throws IOException
```
    Throws:
    
    IOException
  - Table
```
public Table(InputStream input,
             String options)
      throws IOException
```
    Read the table from a stream. Possible options include:
    - csv - parse the table as comma-separated values
    - tsv - parse the table as tab-separated values
    - newlines - this CSV file contains newlines inside individual cells
    - header - this table has a header (title) row
    Parameters:
    
    input -
    
    options -
    
    Throws:
    
    IOException
  - Table
```
public Table(Iterable<TableRow> rows)
```
  - Table
```
public Table(ResultSet rs)
```
- Method Detail
  - typedParse
```
public Table typedParse(InputStream input,
                        String options)
                 throws IOException
```
    Throws:
    
    IOException
  - extensionOptions
```
public static String extensionOptions(boolean loading,
                                      String filename,
                                      String options)
```
  - parseInto
```
public void parseInto(Object enclosingObject,
                      String fieldName)
```
    incomplete, do not use
  - save
```
public boolean save(File file,
                    String options)
             throws IOException
```
    Throws:
    
    IOException
  - save
```
public boolean save(OutputStream output,
                    String options)
```
  - addColumn
```
public void addColumn()
```
    See Also:
    
    removeColumn(String)
    
    In brief:
    
    Adds a new column to a table
  - addColumn
```
public void addColumn(String title)
```
    Parameters:
    
    title - the title to be used for the new column
  - addColumn
```
public void addColumn(String title,
                      int type)
```
    Parameters:
    
    type - the type to be used for the new column: INT, LONG, FLOAT, DOUBLE, or STRING
  - insertColumn
```
public void insertColumn(int index)
```
  - insertColumn
```
public void insertColumn(int index,
                         String title)
```
  - insertColumn
```
public void insertColumn(int index,
                         String title,
                         int type)
```
  - removeColumn
```
public void removeColumn(String columnName)
```
    Parameters:
    
    columnName - the title of the column to be removed
    
    See Also:
    
    addColumn()
    
    In brief:
    
    Removes a column from a table
  - removeColumn
```
public void removeColumn(int column)
```
    Parameters:
    
    column - the index number of the column to be removed
  - getColumnCount
```
public int getColumnCount()
```
    See Also:
    
    getRowCount()
    
    In brief:
    
    Gets the number of columns in a table
  - setColumnCount
```
public void setColumnCount(int newCount)
```
    Change the number of columns in this table. Resizes all rows to ensure the same number of columns in each row. Entries in the additional (empty) columns will be set to null.
    
    Parameters:
    
    newCount -
  - setColumnType
```
public void setColumnType(String columnName,
                          String columnType)
```
  - setColumnType
```
public void setColumnType(int column,
                          String columnType)
```
    Set the data type for a column so that using it is more efficient.
    
    Parameters:
    
    column - the column to change
    
    columnType - One of int, long, float, double, string, or category.
  - setColumnType
```
public void setColumnType(String columnName,
                          int newType)
```
  - setColumnType
```
public void setColumnType(int column,
                          int newType)
```
    Sets the column type. If data already exists, then it'll be converted to the new type.
    
    Parameters:
    
    column - the column whose type should be changed
    
    newType - something fresh, maybe try an int or a float for size?
  - setTableType
```
public void setTableType(String type)
```
    Set the entire table to a specific data type.
  - setColumnTypes
```
public void setColumnTypes(int[] types)
```
  - setColumnTypes
```
public void setColumnTypes(Table dictionary)
```
    Set the titles (and if a second column is present) the data types for this table based on a file loaded separately. This will look for the title in column 0, and the type in column 1. Better yet, specify a column named "title" and another named "type" in the dictionary table to future-proof the code.
    
    Parameters:
    
    dictionary -
  - getColumnType
```
public int getColumnType(String columnName)
```
  - getColumnType
```
public int getColumnType(int column)
```
    Returns one of Table.STRING, Table.INT, etc...
  - getColumnTypes
```
public int[] getColumnTypes()
```
  - removeTitleRow
```
@Deprecated
public String[] removeTitleRow()
```
    Deprecated.
    
    Remove the first row from the data set, and use it as the column titles. Use loadTable("table.csv", "header") instead.
  - setColumnTitles
```
public void setColumnTitles(String[] titles)
```
  - setColumnTitle
```
public void setColumnTitle(int column,
                           String title)
```
  - hasColumnTitles
```
public boolean hasColumnTitles()
```
  - getColumnTitles
```
public String[] getColumnTitles()
```
  - getColumnTitle
```
public String getColumnTitle(int col)
```
  - getColumnIndex
```
public int getColumnIndex(String columnName)
```
  - checkColumnIndex
```
public int checkColumnIndex(String title)
```
    Same as getColumnIndex(), but creates the column if it doesn't exist. Named this way to not conflict with checkColumn(), an internal function used to ensure that a columns exists, and also to denote that it returns an int for the column index.
    
    Parameters:
    
    title - column title
    
    Returns:
    
    index of a new or previously existing column
  - getRowCount
```
public int getRowCount()
```
    See Also:
    
    getColumnCount()
    
    In brief:
    
    Gets the number of rows in a table
  - lastRowIndex
```
public int lastRowIndex()
```
  - clearRows
```
public void clearRows()
```
    See Also:
    
    addRow(), removeRow(int)
    
    In brief:
    
    Removes all rows from a table
  - setRowCount
```
public void setRowCount(int newCount)
```
  - addRow
```
public TableRow addRow()
```
    See Also:
    
    removeRow(int), clearRows()
    
    In brief:
    
    Adds a row to a table
  - addRow
```
public TableRow addRow(TableRow source)
```
    Parameters:
    
    source - a reference to the original row to be duplicated
  - setRow
```
public TableRow setRow(int row,
                       TableRow source)
```
  - addRow
```
public TableRow addRow(Object[] columnData)
```
  - addRows
```
public void addRows(Table source)
```
  - insertRow
```
public void insertRow(int insert,
                      Object[] columnData)
```
  - removeRow
```
public void removeRow(int row)
```
    Parameters:
    
    row - ID number of the row to remove
    
    See Also:
    
    addRow(), clearRows()
    
    In brief:
    
    Removes a row from a table
  - setRow
```
public void setRow(int row,
                   Object[] pieces)
```
  - getRow
```
public TableRow getRow(int row)
```
    Parameters:
    
    row - ID number of the row to get
    
    See Also:
    
    rows(), findRow(String, int), findRows(String, int), matchRow(String, int), matchRows(String, int)
    
    In brief:
    
    Gets a row from a table
  - rows
```
public Iterable<TableRow> rows()
```
    Note that this one iterator instance is shared by any calls to iterate the rows of this table. This is very efficient, but not thread-safe. If you want to iterate in a multi-threaded manner, don't use the iterator.
    
    See Also:
    
    getRow(int), findRow(String, int), findRows(String, int), matchRow(String, int), matchRows(String, int)
    
    In brief:
    
    Gets multiple rows from a table
  - rows
```
public Iterable<TableRow> rows(int[] indices)
```
  - getInt
```
public int getInt(int row,
                  int column)
```
    Parameters:
    
    row - ID number of the row to reference
    
    column - ID number of the column to reference
    
    See Also:
    
    getFloat(int, int), getString(int, int), getStringColumn(String), setInt(int, int, int), setFloat(int, int, float), setString(int, int, String)
    
    In brief:
    
    Get an integer value from the specified row and column
  - getInt
```
public int getInt(int row,
                  String columnName)
```
    Parameters:
    
    columnName - title of the column to reference
  - setMissingInt
```
public void setMissingInt(int value)
```
  - setInt
```
public void setInt(int row,
                   int column,
                   int value)
```
    Parameters:
    
    row - ID number of the target row
    
    column - ID number of the target column
    
    value - value to assign
    
    See Also:
    
    setFloat(int, int, float), setString(int, int, String), getInt(int, int), getFloat(int, int), getString(int, int), getStringColumn(String)
    
    In brief:
    
    Store an integer value in the specified row and column
  - setInt
```
public void setInt(int row,
                   String columnName,
                   int value)
```
    Parameters:
    
    columnName - title of the target column
  - getIntColumn
```
public int[] getIntColumn(String name)
```
  - getIntColumn
```
public int[] getIntColumn(int col)
```
  - getIntRow
```
public int[] getIntRow(int row)
```
  - getLong
```
public long getLong(int row,
                    int column)
```
  - getLong
```
public long getLong(int row,
                    String columnName)
```
  - setMissingLong
```
public void setMissingLong(long value)
```
  - setLong
```
public void setLong(int row,
                    int column,
                    long value)
```
  - setLong
```
public void setLong(int row,
                    String columnName,
                    long value)
```
  - getLongColumn
```
public long[] getLongColumn(String name)
```
  - getLongColumn
```
public long[] getLongColumn(int col)
```
  - getLongRow
```
public long[] getLongRow(int row)
```
  - getFloat
```
public float getFloat(int row,
                      int column)
```
    Get a float value from the specified row and column. If the value is null or not parseable as a float, the "missing" value is returned. By default, this is Float.NaN, but can be controlled with setMissingFloat().
    
    Parameters:
    
    row - ID number of the row to reference
    
    column - ID number of the column to reference
    
    See Also:
    
    getInt(int, int), getString(int, int), getStringColumn(String), setInt(int, int, int), setFloat(int, int, float), setString(int, int, String)
    
    In brief:
    
    Get a float value from the specified row and column
  - getFloat
```
public float getFloat(int row,
                      String columnName)
```
    Parameters:
    
    columnName - title of the column to reference
  - setMissingFloat
```
public void setMissingFloat(float value)
```
  - setFloat
```
public void setFloat(int row,
                     int column,
                     float value)
```
    Parameters:
    
    row - ID number of the target row
    
    column - ID number of the target column
    
    value - value to assign
    
    See Also:
    
    setInt(int, int, int), setString(int, int, String), getInt(int, int), getFloat(int, int), getString(int, int), getStringColumn(String)
    
    In brief:
    
    Store a float value in the specified row and column
  - setFloat
```
public void setFloat(int row,
                     String columnName,
                     float value)
```
    Parameters:
    
    columnName - title of the target column
  - getFloatColumn
```
public float[] getFloatColumn(String name)
```
  - getFloatColumn
```
public float[] getFloatColumn(int col)
```
  - getFloatRow
```
public float[] getFloatRow(int row)
```
  - getDouble
```
public double getDouble(int row,
                        int column)
```
  - getDouble
```
public double getDouble(int row,
                        String columnName)
```
  - setMissingDouble
```
public void setMissingDouble(double value)
```
  - setDouble
```
public void setDouble(int row,
                      int column,
                      double value)
```
  - setDouble
```
public void setDouble(int row,
                      String columnName,
                      double value)
```
  - getDoubleColumn
```
public double[] getDoubleColumn(String name)
```
  - getDoubleColumn
```
public double[] getDoubleColumn(int col)
```
  - getDoubleRow
```
public double[] getDoubleRow(int row)
```
  - getString
```
public String getString(int row,
                        int column)
```
    Get a String value from the table. If the row is longer than the table
    
    Parameters:
    
    row - ID number of the row to reference
    
    column - ID number of the column to reference
    
    See Also:
    
    getInt(int, int), getFloat(int, int), getStringColumn(String), setInt(int, int, int), setFloat(int, int, float), setString(int, int, String)
    
    In brief:
    
    Get an String value from the specified row and column
  - getString
```
public String getString(int row,
                        String columnName)
```
    Parameters:
    
    columnName - title of the column to reference
  - setMissingString
```
public void setMissingString(String value)
```
    Treat entries with this string as "missing". Also used for categorial.
  - setString
```
public void setString(int row,
                      int column,
                      String value)
```
    Parameters:
    
    row - ID number of the target row
    
    column - ID number of the target column
    
    value - value to assign
    
    See Also:
    
    setInt(int, int, int), setFloat(int, int, float), getInt(int, int), getFloat(int, int), getString(int, int), getStringColumn(String)
    
    In brief:
    
    Store a String value in the specified row and column
  - setString
```
public void setString(int row,
                      String columnName,
                      String value)
```
    Parameters:
    
    columnName - title of the target column
  - getStringColumn
```
public String[] getStringColumn(String columnName)
```
    Parameters:
    
    columnName - title of the column to search
    
    See Also:
    
    getInt(int, int), getFloat(int, int), getString(int, int), setInt(int, int, int), setFloat(int, int, float), setString(int, int, String)
    
    In brief:
    
    Gets all values in the specified column
  - getStringColumn
```
public String[] getStringColumn(int column)
```
    Parameters:
    
    column - ID number of the column to search
  - getStringRow
```
public String[] getStringRow(int row)
```
  - findRowIndex
```
public int findRowIndex(String value,
                        int column)
```
    Return the row that contains the first String that matches.
    
    Parameters:
    
    value - the String to match
    
    column - ID number of the column to search
  - findRowIndex
```
public int findRowIndex(String value,
                        String columnName)
```
    Return the row that contains the first String that matches.
    
    Parameters:
    
    value - the String to match
    
    columnName - title of the column to search
  - findRowIndices
```
public int[] findRowIndices(String value,
                            int column)
```
    Return a list of rows that contain the String passed in. If there are no matches, a zero length array will be returned (not a null array).
    
    Parameters:
    
    value - the String to match
    
    column - ID number of the column to search
  - findRowIndices
```
public int[] findRowIndices(String value,
                            String columnName)
```
    Return a list of rows that contain the String passed in. If there are no matches, a zero length array will be returned (not a null array).
    
    Parameters:
    
    value - the String to match
    
    columnName - title of the column to search
  - findRow
```
public TableRow findRow(String value,
                        int column)
```
    Parameters:
    
    value - the value to match
    
    column - ID number of the column to search
    
    See Also:
    
    getRow(int), rows(), findRows(String, int), matchRow(String, int), matchRows(String, int)
    
    In brief:
    
    Finds a row that contains the given value
  - findRow
```
public TableRow findRow(String value,
                        String columnName)
```
    Parameters:
    
    columnName - title of the column to search
  - findRows
```
public Iterable<TableRow> findRows(String value,
                                   int column)
```
    Parameters:
    
    value - the value to match
    
    column - ID number of the column to search
    
    See Also:
    
    getRow(int), rows(), findRow(String, int), matchRow(String, int), matchRows(String, int)
    
    In brief:
    
    Finds multiple rows that contain the given value
  - findRows
```
public Iterable<TableRow> findRows(String value,
                                   String columnName)
```
    Parameters:
    
    columnName - title of the column to search
  - findRowIterator
```
public Iterator<TableRow> findRowIterator(String value,
                                          int column)
```
    Parameters:
    
    value - the value to match
    
    column - ID number of the column to search
    
    In brief:
    
    Finds multiple rows that contain the given value
  - findRowIterator
```
public Iterator<TableRow> findRowIterator(String value,
                                          String columnName)
```
    Parameters:
    
    columnName - title of the column to search
  - matchRowIndex
```
public int matchRowIndex(String regexp,
                         int column)
```
    Return the row that contains the first String that matches.
    
    Parameters:
    
    regexp - the String to match
    
    column - ID number of the column to search
  - matchRowIndex
```
public int matchRowIndex(String what,
                         String columnName)
```
    Return the row that contains the first String that matches.
    
    Parameters:
    
    what - the String to match
    
    columnName - title of the column to search
  - matchRowIndices
```
public int[] matchRowIndices(String regexp,
                             int column)
```
    Return a list of rows that contain the String passed in. If there are no matches, a zero length array will be returned (not a null array).
    
    Parameters:
    
    regexp - the String to match
    
    column - ID number of the column to search
  - matchRowIndices
```
public int[] matchRowIndices(String what,
                             String columnName)
```
    Return a list of rows that match the regex passed in. If there are no matches, a zero length array will be returned (not a null array).
    
    Parameters:
    
    what - the String to match
    
    columnName - title of the column to search
  - matchRow
```
public TableRow matchRow(String regexp,
                         int column)
```
    Parameters:
    
    regexp - the regular expression to match
    
    column - ID number of the column to search
    
    See Also:
    
    getRow(int), rows(), findRow(String, int), findRows(String, int), matchRows(String, int)
    
    In brief:
    
    Finds a row that matches the given expression
  - matchRow
```
public TableRow matchRow(String regexp,
                         String columnName)
```
    Parameters:
    
    columnName - title of the column to search
  - matchRows
```
public Iterable<TableRow> matchRows(String regexp,
                                    int column)
```
    Parameters:
    
    regexp - the regular expression to match
    
    column - ID number of the column to search
    
    See Also:
    
    getRow(int), rows(), findRow(String, int), findRows(String, int), matchRow(String, int)
    
    In brief:
    
    Finds multiple rows that match the given expression
  - matchRows
```
public Iterable<TableRow> matchRows(String regexp,
                                    String columnName)
```
    Parameters:
    
    columnName - title of the column to search
  - matchRowIterator
```
public Iterator<TableRow> matchRowIterator(String value,
                                           int column)
```
    Parameters:
    
    value - the regular expression to match
    
    column - ID number of the column to search
    
    In brief:
    
    Finds multiple rows that match the given expression
  - matchRowIterator
```
public Iterator<TableRow> matchRowIterator(String value,
                                           String columnName)
```
    Parameters:
    
    columnName - title of the column to search
  - replace
```
public void replace(String orig,
                    String replacement)
```
    Replace a String with another. Set empty entries null by using replace("", null) or use replace(null, "") to go the other direction. If this is a typed table, only String columns will be modified.
    
    Parameters:
    
    orig -
    
    replacement -
  - replace
```
public void replace(String orig,
                    String replacement,
                    int col)
```
  - replace
```
public void replace(String orig,
                    String replacement,
                    String colName)
```
  - replaceAll
```
public void replaceAll(String regex,
                       String replacement)
```
  - replaceAll
```
public void replaceAll(String regex,
                       String replacement,
                       int column)
```
  - replaceAll
```
public void replaceAll(String regex,
                       String replacement,
                       String columnName)
```
    Run String.replaceAll() on all entries in a column. Only works with columns that are already String values.
    
    Parameters:
    
    regex - the String to match
    
    columnName - title of the column to search
  - removeTokens
```
public void removeTokens(String tokens)
```
    Remove any of the specified characters from the entire table.
    
    Parameters:
    
    tokens - a list of individual characters to be removed
    
    See Also:
    
    trim()
    
    In brief:
    
    Removes characters from the table
  - removeTokens
```
public void removeTokens(String tokens,
                         int column)
```
    Removed any of the specified characters from a column. For instance, the following code removes dollar signs and commas from column 2:
```
 table.removeTokens(",$", 2);
 
```
    Parameters:
    
    column - ID number of the column to process
  - removeTokens
```
public void removeTokens(String tokens,
                         String columnName)
```
    Parameters:
    
    columnName - title of the column to process
  - trim
```
public void trim()
```
    See Also:
    
    removeTokens(String)
    
    In brief:
    
    Trims whitespace from values
  - trim
```
public void trim(int column)
```
    Parameters:
    
    column - ID number of the column to trim
  - trim
```
public void trim(String columnName)
```
    Parameters:
    
    columnName - title of the column to trim
  - sort
```
public void sort(String columnName)
```
    Sorts (orders) a table based on the values in a column.
    
    Parameters:
    
    columnName - the name of the column to sort
    
    See Also:
    
    trim()
    
    In brief:
    
    Orders a table based on the values in a column
  - sort
```
public void sort(int column)
```
    Parameters:
    
    column - the column ID, e.g. 0, 1, 2
  - sortReverse
```
public void sortReverse(String columnName)
```
  - sortReverse
```
public void sortReverse(int column)
```
  - getUnique
```
public String[] getUnique(String columnName)
```
  - getUnique
```
public String[] getUnique(int column)
```
  - getTally
```
public IntDict getTally(String columnName)
```
  - getTally
```
public IntDict getTally(int column)
```
  - getOrder
```
public IntDict getOrder(String columnName)
```
  - getOrder
```
public IntDict getOrder(int column)
```
  - getIntList
```
public IntList getIntList(String columnName)
```
  - getIntList
```
public IntList getIntList(int column)
```
  - getFloatList
```
public FloatList getFloatList(String columnName)
```
  - getFloatList
```
public FloatList getFloatList(int column)
```
  - getStringList
```
public StringList getStringList(String columnName)
```
  - getStringList
```
public StringList getStringList(int column)
```
  - getIntDict
```
public IntDict getIntDict(String keyColumnName,
                          String valueColumnName)
```
  - getIntDict
```
public IntDict getIntDict(int keyColumn,
                          int valueColumn)
```
  - getFloatDict
```
public FloatDict getFloatDict(String keyColumnName,
                              String valueColumnName)
```
  - getFloatDict
```
public FloatDict getFloatDict(int keyColumn,
                              int valueColumn)
```
  - getStringDict
```
public StringDict getStringDict(String keyColumnName,
                                String valueColumnName)
```
  - getStringDict
```
public StringDict getStringDict(int keyColumn,
                                int valueColumn)
```
  - getRowMap
```
public Map<String,TableRow> getRowMap(String columnName)
```
  - getRowMap
```
public Map<String,TableRow> getRowMap(int column)
```
    Return a mapping that connects the entry from a column back to the row from which it came. For instance:
```
 Table t = loadTable("country-data.tsv", "header");
 // use the contents of the 'country' column to index the table
 Map lookup = t.getRowMap("country");
 // get the row that has "us" in the "country" column:
 TableRow usRow = lookup.get("us");
 // get an entry from the 'population' column
 int population = usRow.getInt("population");
 
```
  - copy
```
public Table copy()
```
    Make a copy of the current table
  - write
```
public void write(PrintWriter writer)
```
  - print
```
public void print()
```

Class Table

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Field Detail

STRING

INT

LONG

FLOAT

DOUBLE

CATEGORY

Constructor Detail

Table

Table

Table

Table

Table

Table

Table

Method Detail

typedParse

extensionOptions

parseInto

save

save

addColumn

addColumn

addColumn

insertColumn

insertColumn

insertColumn

removeColumn

removeColumn

getColumnCount

setColumnCount

setColumnType

setColumnType

setColumnType

setColumnType

setTableType

setColumnTypes

setColumnTypes

getColumnType

getColumnType

getColumnTypes

removeTitleRow

setColumnTitles

setColumnTitle

hasColumnTitles

getColumnTitles

getColumnTitle

getColumnIndex

checkColumnIndex

getRowCount

lastRowIndex

clearRows

setRowCount

addRow

addRow

setRow

addRow

addRows

insertRow

removeRow

setRow

getRow

rows

rows

getInt

getInt

setMissingInt

setInt

setInt

getIntColumn

getIntColumn

getIntRow

getLong

getLong

setMissingLong