Table (tablesaw-core 0.37.0 API)

java.lang.Object
- tech.tablesaw.table.Relation
- - tech.tablesaw.api.Table

All Implemented Interfaces:

Iterable<Row>
```
public class Table
extends Relation
implements Iterable<Row>
```
A table of data, consisting of some number of columns, each of which has the same number of rows. All the data in a column has the same type: integer, float, category, etc., but a table may contain an arbitrary number of columns of any type.
Tables are the main data-type and primary focus of Tablesaw.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Table.RowPair
Deprecated.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Table.RowPair` Deprecated.

Field Summary

Fields
Modifier and Type Field and Description

static ReaderRegistry defaultReaderRegistry

static WriterRegistry defaultWriterRegistry

Fields
Modifier and Type	Field and Description
`static ReaderRegistry`	`defaultReaderRegistry`
`static WriterRegistry`	`defaultWriterRegistry`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Table(Column<?>... columns)` Returns a new Table initialized with the given columns
`protected`	`Table(String name, Column<?>... columns)` Returns a new Table initialized with the given names and columns

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Table`	`addColumns(Column<?>... cols)` Adds the given column to this table
`void`	`addRow(int rowIndex, Table sourceTable)` Adds a single row to this table from sourceTable, copying every column in sourceTable
`void`	`addRow(Row row)`
`Table`	`append(Table tableToAppend)`
`Row`	`appendRow()` Appends an empty row and returns a Row object indexed to the newly added row so values can be set.
`List<CategoricalColumn<?>>`	`categoricalColumns(String... columnNames)` Returns only the columns whose names are given in the input array
`void`	`clear()` Clears all the data from this table
`Column<?>`	`column(int columnIndex)` Returns the column at the given index in the column list
`Column<?>[]`	`columnArray()`
`int`	`columnCount()` Returns the number of columns in the table
`int`	`columnIndex(Column<?> column)` Returns the index of the given column (its position in the list of columns)
`int`	`columnIndex(String columnName)` Returns the index of the column with the given name
`List<String>`	`columnNames()` Returns a List of the names of all the columns in this table
`List<Column<?>>`	`columns()` Returns the list of columns
`Table`	`concat(Table tableToConcatenate)` Add all the columns of tableToConcatenate to this table Note: The columns in the result must have unique names, when compared case insensitive Note: Both tables must have the same number of rows
`Table`	`copy()` Returns a table with the same columns as this table
`Table`	`countBy(CategoricalColumn<?> groupingColumn)` Returns a table containing two columns, the grouping column, and a column named "Count" that contains the counts for each grouping column value
`Table`	`countBy(String categoricalColumnName)` Returns a table containing two columns, the grouping column, and a column named "Count" that contains the counts for each grouping column value
`static Table`	`create()` Returns a new, empty table (without rows or columns)
`static Table`	`create(Column<?>... columns)` Returns a new table with the given columns
`static Table`	`create(String tableName)` Returns a new, empty table (without rows or columns) with the given name
`static Table`	`create(String name, Column<?>... columns)` Returns a new table with the given columns and given name
`boolean`	`detect(Predicate<Row> predicate)` Deprecated. use `stream().anyMatch`
`void`	`doWithRowPairs(Consumer<Table.RowPair> pairConsumer)` Deprecated. use stream(2).forEach(rowConsumer)
`void`	`doWithRows(Consumer<Row> doable)` Deprecated. use `stream().forEach`
`void`	`doWithRows(tech.tablesaw.api.Table.Pairs pairs)` Deprecated. use stream(2).forEach(rowConsumer)
`Table`	`dropDuplicateRows()` Returns the unique records in this table Note: Uses a lot of memory for a sort
`Table`	`dropRange(int rowCount)` Drops the first rowCount rows if rowCount positive.
`Table`	`dropRange(int rowStart, int rowEnd)`
`Table`	`dropRows(int... rowNumbers)`
`Table`	`dropRowsWithMissingValues()` Returns only those records in this table that have no columns with missing values
`Table`	`dropWhere(Function<Table,Selection> selection)`
`Table`	`dropWhere(Selection selection)`
`Table`	`emptyCopy()` Returns a table with the same columns as this table, but no data
`Table`	`emptyCopy(int rowSize)` Returns a table with the same columns as this table, but no data, initialized to the given row size
`Table`	`first(int nRows)` Returns a new table containing the first `nrows` of data in this table
`Table`	`inRange(int rowCount)` Retains the first rowCount rows if rowCount positive.
`Table`	`inRange(int rowStart, int rowEnd)`
`Table`	`insertColumn(int index, Column<?> column)` Adds the given column to this table at the given position in the column list
`Iterator<Row>`	`iterator()`
`DataFrameJoiner`	`joinOn(String... columnNames)` Returns a new DataFrameJoiner initialized with multiple `columnNames`
`Table`	`last(int nRows)` Returns a new table containing the last `nrows` of data in this table
`Table`	`missingValueCounts()`
`String`	`name()` Returns the name of the table
`Table`	`pivot(CategoricalColumn<?> column1, CategoricalColumn<?> column2, NumericColumn<?> column3, AggregateFunction<?,?> aggregateFunction)` Returns a pivot on this table, where: The first column contains unique values from the index column1 There are n additional columns, one for each unique value in column2 The values in each of the cells in these new columns are the result of applying the given AggregateFunction to the data in column3, grouped by the values of column1 and column2
`Table`	`pivot(String column1Name, String column2Name, String column3Name, AggregateFunction<?,?> aggregateFunction)` Returns a pivot on this table, where: The first column contains unique values from the index column1 There are n additional columns, one for each unique value in column2 The values in each of the cells in these new columns are the result of applying the given AggregateFunction to the data in column3, grouped by the values of column1 and column2
`static DataFrameReader`	`read()`
`Table`	`removeColumns(Column<?>... columns)` Removes the given columns
`Table`	`removeColumnsWithMissingValues()` Removes the given columns with missing values
`Table`	`replaceColumn(Column<?> newColumn)` Replaces an existing column having the same name of the given column with the given column
`Table`	`replaceColumn(int colIndex, Column<?> newColumn)` Replaces an existing column (by index) in this table with the given new column
`Table`	`replaceColumn(String columnName, Column<?> newColumn)` Replaces an existing column (by name) in this table with the given new column
`Table`	`retainColumns(Column<?>... columns)` Removes all columns except for those given in the argument from this table
`Table`	`retainColumns(String... columnNames)` Removes all columns except for those given in the argument from this table
`Iterator<Row[]>`	`rollingIterator(int n)` Iterates over rolling sets of rows.
`Stream<Row[]>`	`rollingStream(int n)` Streams over rolling sets of rows.
`void`	`rollWithRows(Consumer<Row[]> rowConsumer, int n)` Deprecated. use stream(n).forEach(rowConsumer)
`Row`	`row(int rowIndex)`
`int`	`rowCount()` Returns the number of rows in the table
`Table`	`rows(int... rowNumbers)`
`Table`	`sampleN(int nRows)` Returns a table consisting of randomly selected records from this table
`Table[]`	`sampleSplit(double table1Proportion)` Splits the table into two, randomly assigning records to each according to the proportion given in trainingProportion
`Table`	`sampleX(double proportion)` Returns a table consisting of randomly selected records from this table.
`Table`	`select(Column<?>... columns)`
`Table`	`select(String... columnNames)`
`Table`	`setName(String name)` Sets the name of the table
`Table`	`sortAscendingOn(String... columnNames)` Returns a copy of this table sorted in the order of the given column names, in ascending order
`Table`	`sortDescendingOn(String... columnNames)` Returns a copy of this table sorted on the given column names, applied in order, descending TODO: Provide equivalent methods naming columns by index
`Table`	`sortOn(Comparator<Row> rowComparator)` Returns a copy of this table sorted using the given comparator
`Table`	`sortOn(int... columnIndexes)` Sorts this table into a new table on the columns indexed
`Table`	`sortOn(Sort key)` Returns a copy of this table sorted using the given sort key.
`Table`	`sortOn(String... columnNames)` Returns a copy of this table sorted on the given column names, applied in order,
`TableSliceGroup`	`splitOn(CategoricalColumn<?>... columns)` Returns a non-overlapping and exhaustive collection of "slices" over this table.
`TableSliceGroup`	`splitOn(String... columns)` Returns a non-overlapping and exhaustive collection of "slices" over this table.
`Iterator<Row[]>`	`steppingIterator(int n)` Streams over stepped sets of rows.
`Stream<Row[]>`	`steppingStream(int n)` Streams over stepped sets of rows.
`void`	`stepWithRows(Consumer<Row[]> rowConsumer, int n)` Deprecated. use steppingStream(n).forEach(rowConsumer)
`Table[]`	`stratifiedSampleSplit(CategoricalColumn<?> column, double table1Proportion)` Splits the table into two stratified samples, this uses the specified column to divide the table into groups, randomly assigning records to each according to the proportion given in trainingProportion.
`Stream<Row>`	`stream()`
`Table`	`structure()`
`Summarizer`	`summarize(Column<?> numberColumn, AggregateFunction<?,?>... function)`
`Summarizer`	`summarize(Column<?> column1, Column<?> column2, AggregateFunction<?,?>... function)`
`Summarizer`	`summarize(Column<?> column1, Column<?> column2, Column<?> column3, AggregateFunction<?,?>... function)`
`Summarizer`	`summarize(Column<?> column1, Column<?> column2, Column<?> column3, Column<?> column4, AggregateFunction<?,?>... function)`
`Summarizer`	`summarize(List<String> columnNames, AggregateFunction<?,?>... functions)`
`Summarizer`	`summarize(String columName, AggregateFunction<?,?>... functions)`
`Summarizer`	`summarize(String numericColumn1Name, String numericColumn2Name, AggregateFunction<?,?>... functions)`
`Summarizer`	`summarize(String col1Name, String col2Name, String col3Name, AggregateFunction<?,?>... functions)`
`Summarizer`	`summarize(String col1Name, String col2Name, String col3Name, String col4Name, AggregateFunction<?,?>... functions)`
`Table`	`where(Function<Table,Selection> selection)`
`Table`	`where(Selection selection)`
`DataFrameWriter`	`write()`
`Table`	`xTabColumnPercents(String column1Name, String column2Name)`
`Table`	`xTabCounts(String column1Name)` Returns a table with two columns, the first contains a value each unique value in the argument, and the second contains the number of observations of each value
`Table`	`xTabCounts(String column1Name, String column2Name)` Returns a table with n by m + 1 cells.
`Table`	`xTabPercents(String column1Name)` Returns a table with two columns, the first contains a value each unique value in the argument, and the second contains the proportion of observations having that value
`Table`	`xTabRowPercents(String column1Name, String column2Name)`
`Table`	`xTabTablePercents(String column1Name, String column2Name)` Returns a table with n by m + 1 cells.

Methods inherited from class tech.tablesaw.table.Relation
as, booleanColumn, booleanColumn, booleanColumns, categoricalColumn, categoricalColumn, column, columns, columns, columnsOfType, columnTypes, colWidths, containsColumn, dateColumn, dateColumn, dateColumns, dateTimeColumn, dateTimeColumn, dateTimeColumns, doubleColumn, doubleColumn, floatColumn, floatColumn, get, getString, getString, getUnformatted, instantColumn, instantColumn, instantColumns, intColumn, intColumn, isEmpty, longColumn, longColumn, nCol, nCol, numberColumn, numberColumn, numberColumns, numericColumns, numericColumns, numericColumns, print, print, printAll, removeColumns, removeColumns, shape, shortColumn, shortColumn, smile, stringColumn, stringColumn, stringColumns, summary, textColumn, textColumn, timeColumn, timeColumn, timeColumns, toString

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - defaultReaderRegistry
```
public static final ReaderRegistry defaultReaderRegistry
```
  - defaultWriterRegistry
```
public static final WriterRegistry defaultWriterRegistry
```
- Constructor Detail
  - Table
```
protected Table(Column<?>... columns)
```
    Returns a new Table initialized with the given columns
    
    Parameters:
    
    columns - One or more columns, all of which must have either the same length or size 0
  - Table
```
protected Table(String name,
                Column<?>... columns)
```
    Returns a new Table initialized with the given names and columns
    
    Parameters:
    
    name - The name of the table
    
    columns - One or more columns, all of which must have either the same length or size 0
- Method Detail
  - create
```
public static Table create()
```
    Returns a new, empty table (without rows or columns)
  - create
```
public static Table create(String tableName)
```
    Returns a new, empty table (without rows or columns) with the given name
  - create
```
public static Table create(Column<?>... columns)
```
    Returns a new table with the given columns
    
    Parameters:
    
    columns - one or more columns, all of the same @code{column.size()}
  - create
```
public static Table create(String name,
                           Column<?>... columns)
```
    Returns a new table with the given columns and given name
    
    Parameters:
    
    name - the name for this table
    
    columns - one or more columns, all of the same @code{column.size()}
  - read
```
public static DataFrameReader read()
```
  - write
```
public DataFrameWriter write()
```
  - addColumns
```
public Table addColumns(Column<?>... cols)
```
    Adds the given column to this table
    
    Specified by:
    
    addColumns in class Relation
  - insertColumn
```
public Table insertColumn(int index,
                          Column<?> column)
```
    Adds the given column to this table at the given position in the column list
    
    Parameters:
    
    index - Zero-based index into the column list
    
    column - Column to be added
  - replaceColumn
```
public Table replaceColumn(int colIndex,
                           Column<?> newColumn)
```
    Replaces an existing column (by index) in this table with the given new column
    
    Parameters:
    
    colIndex - Zero-based index of the column to be replaced
    
    newColumn - Column to be added
  - replaceColumn
```
public Table replaceColumn(String columnName,
                           Column<?> newColumn)
```
    Replaces an existing column (by name) in this table with the given new column
    
    Parameters:
    
    columnName - String name of the column to be replaced
    
    newColumn - Column to be added
  - replaceColumn
```
public Table replaceColumn(Column<?> newColumn)
```
    Replaces an existing column having the same name of the given column with the given column
    
    Parameters:
    
    newColumn - Column to be added
  - setName
```
public Table setName(String name)
```
    Sets the name of the table
    
    Specified by:
    
    setName in class Relation
  - column
```
public Column<?> column(int columnIndex)
```
    Returns the column at the given index in the column list
    
    Specified by:
    
    column in class Relation
    
    Parameters:
    
    columnIndex - an integer at least 0 and less than number of columns in the table
    
    Returns:
    
    the column at the given index
  - columnCount
```
public int columnCount()
```
    Returns the number of columns in the table
    
    Specified by:
    
    columnCount in class Relation
  - rowCount
```
public int rowCount()
```
    Returns the number of rows in the table
    
    Specified by:
    
    rowCount in class Relation
  - columns
```
public List<Column<?>> columns()
```
    Returns the list of columns
    
    Specified by:
    
    columns in class Relation
  - columnArray
```
public Column<?>[] columnArray()
```
  - categoricalColumns
```
public List<CategoricalColumn<?>> categoricalColumns(String... columnNames)
```
    Returns only the columns whose names are given in the input array
    
    Overrides:
    
    categoricalColumns in class Relation
  - columnIndex
```
public int columnIndex(String columnName)
```
    Returns the index of the column with the given name
    
    Overrides:
    
    columnIndex in class Relation
    
    Throws:
    
    IllegalArgumentException - if the input string is not the name of any column in the table
  - columnIndex
```
public int columnIndex(Column<?> column)
```
    Returns the index of the given column (its position in the list of columns)
    
    Specified by:
    
    columnIndex in class Relation
    
    Throws:
    
    IllegalArgumentException - if the column is not present in this table
  - name
```
public String name()
```
    Returns the name of the table
    
    Specified by:
    
    name in class Relation
  - columnNames
```
public List<String> columnNames()
```
    Returns a List of the names of all the columns in this table
    
    Specified by:
    
    columnNames in class Relation
  - copy
```
public Table copy()
```
    Returns a table with the same columns as this table
  - emptyCopy
```
public Table emptyCopy()
```
    Returns a table with the same columns as this table, but no data
  - emptyCopy
```
public Table emptyCopy(int rowSize)
```
    Returns a table with the same columns as this table, but no data, initialized to the given row size
  - sampleSplit
```
public Table[] sampleSplit(double table1Proportion)
```
    Splits the table into two, randomly assigning records to each according to the proportion given in trainingProportion
    
    Parameters:
    
    table1Proportion - The proportion to go in the first table
    
    Returns:
    
    An array two tables, with the first table having the proportion specified in the method parameter, and the second table having the balance of the rows
  - stratifiedSampleSplit
```
public Table[] stratifiedSampleSplit(CategoricalColumn<?> column,
                                     double table1Proportion)
```
    Splits the table into two stratified samples, this uses the specified column to divide the table into groups, randomly assigning records to each according to the proportion given in trainingProportion.
    
    Parameters:
    
    column - the column to be used for the stratified sampling
    
    table1Proportion - The proportion to go in the first table
    
    Returns:
    
    An array two tables, with the first table having the proportion specified in the method parameter, and the second table having the balance of the rows
  - sampleX
```
public Table sampleX(double proportion)
```
    Returns a table consisting of randomly selected records from this table. The sample size is based on the given proportion
    
    Parameters:
    
    proportion - The proportion to go in the sample
  - sampleN
```
public Table sampleN(int nRows)
```
    Returns a table consisting of randomly selected records from this table
    
    Parameters:
    
    nRows - The number of rows to go in the sample
  - clear
```
public void clear()
```
    Clears all the data from this table
    
    Specified by:
    
    clear in class Relation
  - first
```
public Table first(int nRows)
```
    Returns a new table containing the first nrows of data in this table
    
    Specified by:
    
    first in class Relation
  - last
```
public Table last(int nRows)
```
    Returns a new table containing the last nrows of data in this table
  - sortOn
```
public Table sortOn(int... columnIndexes)
```
    Sorts this table into a new table on the columns indexed
    if index is negative then sort that column in descending order otherwise sort ascending
  - sortOn
```
public Table sortOn(String... columnNames)
```
    Returns a copy of this table sorted on the given column names, applied in order,
    if column name starts with - then sort that column descending otherwise sort ascending
  - sortAscendingOn
```
public Table sortAscendingOn(String... columnNames)
```
    Returns a copy of this table sorted in the order of the given column names, in ascending order
  - sortDescendingOn
```
public Table sortDescendingOn(String... columnNames)
```
    Returns a copy of this table sorted on the given column names, applied in order, descending TODO: Provide equivalent methods naming columns by index
  - sortOn
```
public Table sortOn(Sort key)
```
    Returns a copy of this table sorted using the given sort key.
    
    Parameters:
    
    key - to sort on.
    
    Returns:
    
    a sorted copy of this table.
  - sortOn
```
public Table sortOn(Comparator<Row> rowComparator)
```
    Returns a copy of this table sorted using the given comparator
  - addRow
```
public void addRow(int rowIndex,
                   Table sourceTable)
```
    Adds a single row to this table from sourceTable, copying every column in sourceTable
    
    Parameters:
    
    rowIndex - The row in sourceTable to add to this table
    
    sourceTable - A table with the same column structure as this table
  - addRow
```
public void addRow(Row row)
```
  - row
```
public Row row(int rowIndex)
```
  - rows
```
public Table rows(int... rowNumbers)
```
  - dropRows
```
public Table dropRows(int... rowNumbers)
```
  - inRange
```
public Table inRange(int rowCount)
```
    Retains the first rowCount rows if rowCount positive. Retains the last rowCount rows if rowCount negative.
  - inRange
```
public Table inRange(int rowStart,
                     int rowEnd)
```
  - dropRange
```
public Table dropRange(int rowCount)
```
    Drops the first rowCount rows if rowCount positive. Drops the last rowCount rows if rowCount negative.
  - dropRange
```
public Table dropRange(int rowStart,
                       int rowEnd)
```
  - where
```
public Table where(Selection selection)
```
  - where
```
public Table where(Function<Table,Selection> selection)
```
  - dropWhere
```
public Table dropWhere(Function<Table,Selection> selection)
```
  - dropWhere
```
public Table dropWhere(Selection selection)
```
  - pivot
```
public Table pivot(CategoricalColumn<?> column1,
                   CategoricalColumn<?> column2,
                   NumericColumn<?> column3,
                   AggregateFunction<?,?> aggregateFunction)
```
    Returns a pivot on this table, where: The first column contains unique values from the index column1 There are n additional columns, one for each unique value in column2 The values in each of the cells in these new columns are the result of applying the given AggregateFunction to the data in column3, grouped by the values of column1 and column2
  - pivot
```
public Table pivot(String column1Name,
                   String column2Name,
                   String column3Name,
                   AggregateFunction<?,?> aggregateFunction)
```
    Returns a pivot on this table, where: The first column contains unique values from the index column1 There are n additional columns, one for each unique value in column2 The values in each of the cells in these new columns are the result of applying the given AggregateFunction to the data in column3, grouped by the values of column1 and column2
  - splitOn
```
public TableSliceGroup splitOn(String... columns)
```
    Returns a non-overlapping and exhaustive collection of "slices" over this table. Each slice is like a virtual table containing a subset of the records in this table
    This method is intended for advanced or unusual operations on the subtables. If you want to calculate summary statistics for each subtable, the summarize methods (e.g)
    table.summarize(myColumn, mean, median).by(columns)
    are preferred
  - splitOn
```
public TableSliceGroup splitOn(CategoricalColumn<?>... columns)
```
    Returns a non-overlapping and exhaustive collection of "slices" over this table. Each slice is like a virtual table containing a subset of the records in this table
    This method is intended for advanced or unusual operations on the subtables. If you want to calculate summary statistics for each subtable, the summarize methods (e.g)
    table.summarize(myColumn, mean, median).by(columns)
    are preferred
  - structure
```
public Table structure()
```
    Overrides:
    
    structure in class Relation
  - dropDuplicateRows
```
public Table dropDuplicateRows()
```
    Returns the unique records in this table Note: Uses a lot of memory for a sort
  - dropRowsWithMissingValues
```
public Table dropRowsWithMissingValues()
```
    Returns only those records in this table that have no columns with missing values
  - select
```
public Table select(Column<?>... columns)
```
  - select
```
public Table select(String... columnNames)
```
  - removeColumns
```
public Table removeColumns(Column<?>... columns)
```
    Removes the given columns
    
    Specified by:
    
    removeColumns in class Relation
  - removeColumnsWithMissingValues
```
public Table removeColumnsWithMissingValues()
```
    Removes the given columns with missing values
  - retainColumns
```
public Table retainColumns(Column<?>... columns)
```
    Removes all columns except for those given in the argument from this table
  - retainColumns
```
public Table retainColumns(String... columnNames)
```
    Removes all columns except for those given in the argument from this table
  - append
```
public Table append(Table tableToAppend)
```
  - appendRow
```
public Row appendRow()
```
    Appends an empty row and returns a Row object indexed to the newly added row so values can be set.
    Intended usage:
    for (int i = 0; ...) { Row row = table.appendRow(); row.setString("name", "Bob"); row.setFloat("IQ", 123.4f); ...etc. }
  - concat
```
public Table concat(Table tableToConcatenate)
```
    Add all the columns of tableToConcatenate to this table Note: The columns in the result must have unique names, when compared case insensitive Note: Both tables must have the same number of rows
    
    Parameters:
    
    tableToConcatenate - The table containing the columns to be added
    
    Returns:
    
    This table
  - summarize
```
public Summarizer summarize(String columName,
                            AggregateFunction<?,?>... functions)
```
  - summarize
```
public Summarizer summarize(List<String> columnNames,
                            AggregateFunction<?,?>... functions)
```
  - summarize
```
public Summarizer summarize(String numericColumn1Name,
                            String numericColumn2Name,
                            AggregateFunction<?,?>... functions)
```
  - summarize
```
public Summarizer summarize(String col1Name,
                            String col2Name,
                            String col3Name,
                            AggregateFunction<?,?>... functions)
```
  - summarize
```
public Summarizer summarize(String col1Name,
                            String col2Name,
                            String col3Name,
                            String col4Name,
                            AggregateFunction<?,?>... functions)
```
  - summarize
```
public Summarizer summarize(Column<?> numberColumn,
                            AggregateFunction<?,?>... function)
```
  - summarize
```
public Summarizer summarize(Column<?> column1,
                            Column<?> column2,
                            AggregateFunction<?,?>... function)
```
  - summarize
```
public Summarizer summarize(Column<?> column1,
                            Column<?> column2,
                            Column<?> column3,
                            AggregateFunction<?,?>... function)
```
  - summarize
```
public Summarizer summarize(Column<?> column1,
                            Column<?> column2,
                            Column<?> column3,
                            Column<?> column4,
                            AggregateFunction<?,?>... function)
```
  - xTabCounts
```
public Table xTabCounts(String column1Name,
                        String column2Name)
```
    Returns a table with n by m + 1 cells. The first column contains labels, the other cells contains the counts for every unique combination of values from the two specified columns in this table
  - xTabRowPercents
```
public Table xTabRowPercents(String column1Name,
                             String column2Name)
```
  - xTabColumnPercents
```
public Table xTabColumnPercents(String column1Name,
                                String column2Name)
```
  - xTabTablePercents
```
public Table xTabTablePercents(String column1Name,
                               String column2Name)
```
    Returns a table with n by m + 1 cells. The first column contains labels, the other cells contains the proportion for a unique combination of values from the two specified columns in this table
  - xTabPercents
```
public Table xTabPercents(String column1Name)
```
    Returns a table with two columns, the first contains a value each unique value in the argument, and the second contains the proportion of observations having that value
  - xTabCounts
```
public Table xTabCounts(String column1Name)
```
    Returns a table with two columns, the first contains a value each unique value in the argument, and the second contains the number of observations of each value
  - countBy
```
public Table countBy(CategoricalColumn<?> groupingColumn)
```
    Returns a table containing two columns, the grouping column, and a column named "Count" that contains the counts for each grouping column value
  - countBy
```
public Table countBy(String categoricalColumnName)
```
    Returns a table containing two columns, the grouping column, and a column named "Count" that contains the counts for each grouping column value
    
    Parameters:
    
    categoricalColumnName - The name of a CategoricalColumn in this table
    
    Returns:
    
    A table containing counts of rows grouped by the categorical column
    
    Throws:
    
    ClassCastException - if the categoricalColumnName parameter is the name of a column that does not * implement categorical
  - joinOn
```
public DataFrameJoiner joinOn(String... columnNames)
```
    Returns a new DataFrameJoiner initialized with multiple columnNames
    
    Parameters:
    
    columnNames - Name of the columns to join on.
    
    Returns:
    
    The new DataFrameJoiner
  - missingValueCounts
```
public Table missingValueCounts()
```
  - iterator
```
public Iterator<Row> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Row>
  - rollingIterator
```
public Iterator<Row[]> rollingIterator(int n)
```
    Iterates over rolling sets of rows. I.e. 0 to n-1, 1 to n, 2 to n+1, etc.
    
    Parameters:
    
    n - the number of rows to return for each iteration
  - steppingIterator
```
public Iterator<Row[]> steppingIterator(int n)
```
    Streams over stepped sets of rows. I.e. 0 to n-1, n to 2n-1, 2n to 3n-1, etc. Only returns full sets of rows.
    
    Parameters:
    
    n - the number of rows to return for each iteration
  - stream
```
public Stream<Row> stream()
```
  - steppingStream
```
public Stream<Row[]> steppingStream(int n)
```
    Streams over stepped sets of rows. I.e. 0 to n-1, n to 2n-1, 2n to 3n-1, etc. Only returns full sets of rows.
    
    Parameters:
    
    n - the number of rows to return for each iteration
  - rollingStream
```
public Stream<Row[]> rollingStream(int n)
```
    Streams over rolling sets of rows. I.e. 0 to n-1, 1 to n, 2 to n+1, etc.
    
    Parameters:
    
    n - the number of rows to return for each iteration
  - doWithRows
```
@Deprecated
public void doWithRows(Consumer<Row> doable)
```
    Deprecated. use stream().forEach
    
    Applies the operation in doable to every row in the table
  - detect
```
@Deprecated
public boolean detect(Predicate<Row> predicate)
```
    Deprecated. use stream().anyMatch
    
    Applies the predicate to each row, and return true if any row returns true
  - stepWithRows
```
@Deprecated
public void stepWithRows(Consumer<Row[]> rowConsumer,
                                     int n)
```
    Deprecated. use steppingStream(n).forEach(rowConsumer)
  - doWithRows
```
@Deprecated
public void doWithRows(tech.tablesaw.api.Table.Pairs pairs)
```
    Deprecated. use stream(2).forEach(rowConsumer)
  - doWithRowPairs
```
@Deprecated
public void doWithRowPairs(Consumer<Table.RowPair> pairConsumer)
```
    Deprecated. use stream(2).forEach(rowConsumer)
  - rollWithRows
```
@Deprecated
public void rollWithRows(Consumer<Row[]> rowConsumer,
                                     int n)
```
    Deprecated. use stream(n).forEach(rowConsumer)

Class Table

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class tech.tablesaw.table.Relation

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

defaultReaderRegistry

defaultWriterRegistry

Constructor Detail

Table

Table

Method Detail

create

create

create

create

read

write

addColumns

insertColumn

replaceColumn

replaceColumn

replaceColumn

setName

column

columnCount

rowCount

columns

columnArray

categoricalColumns

columnIndex

columnIndex

name

columnNames

copy

emptyCopy

emptyCopy

sampleSplit

stratifiedSampleSplit

sampleX

sampleN

clear

first

last

sortOn

sortOn

sortAscendingOn

sortDescendingOn

sortOn

sortOn

addRow

addRow

row

rows

dropRows

inRange

inRange

dropRange

dropRange

where

where

dropWhere

dropWhere

pivot

pivot

splitOn

splitOn

structure

dropDuplicateRows

dropRowsWithMissingValues

select

select

removeColumns

removeColumnsWithMissingValues

retainColumns

retainColumns

append