processing.data

## Class 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`

  - ### 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

    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()`
    `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` | `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)`
    `void` | `sortReverse(int column)`
    `void` | `sortReverse(String columnName)`
    `void` | `trim()`
    `void` | `trim(int column)`
    `void` | `trim(String columnName)`
    `Table` | `typedParse(InputStream input, String options)`

    - ### 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)`

    - #### 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, STRING, or CATEGORY

    - #### 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()`

    - #### removeColumn

          public void removeColumn(int column)

      Parameters:
        `column` - the index number of the column to be removed

    - #### getColumnCount

          public int getColumnCount()

      See Also:
        `getRowCount()`

    - #### 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()`

    - #### lastRowIndex

          public int lastRowIndex()

    - #### clearRows

          public void clearRows()

      See Also:
        `addRow()`, `removeRow(int)`

    - #### setRowCount

          public void setRowCount(int newCount)

    - #### addRow

          public TableRow addRow()

      See Also:
        `removeRow(int)`, `clearRows()`

    - #### 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()`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### 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

    - #### 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:
        `what` - 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)`

    - #### 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)`

    - #### 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

    - #### 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:
        `what` - 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()`

    - #### 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)`

    - #### 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)

    - #### sort

          public void sort(int column)

    - #### 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)

    - #### copy

          public Table copy()

      Make a copy of the current table