Column (tablesaw-core 0.34.1 API)

All Superinterfaces:

Comparator<T>, Iterable<T>

All Known Subinterfaces:

BooleanMapUtils, CategoricalColumn<T>, DateFilters, DateMapFunctions, DateTimeFilters, DateTimeMapFunctions, NumericColumn<T>, StringFilters, StringMapFunctions, StringReduceUtils, TemporalColumn<T>, TemporalFilters<T>, TemporalMapFunctions<T>, TimeFilters, TimeMapFunctions

All Known Implementing Classes:

AbstractColumn, BooleanColumn, DateColumn, DateTimeColumn, DoubleColumn, FloatColumn, InstantColumn, IntColumn, LongColumn, NumberColumn, ShortColumn, StringColumn, TextColumn, TimeColumn
```
public interface Column<T>
extends Iterable<T>, Comparator<T>
```
The general interface for columns.
Columns can either exist on their own or be a part of a table. All the data in a single column is of a particular type.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default boolean`	`allMatch(Predicate<? super T> test)` Returns true if all rows satisfy the predicate, false otherwise
`default boolean`	`anyMatch(Predicate<? super T> test)` Returns true if any row satisfies the predicate, false otherwise
`Column<T>`	`append(Column<T> column)`
`Column<T>`	`append(Column<T> column, int row)`
`Column<T>`	`append(T value)`
`Column<T>`	`appendCell(String stringValue)`
`Column<T>`	`appendCell(String stringValue, AbstractColumnParser<?> parser)`
`Column<T>`	`appendMissing()` Appends a missing value appropriate to the column
`Column<T>`	`appendObj(Object value)`
`byte[]`	`asBytes(int rowNumber)` Returns the contents of the cell at rowNumber as a byte[].
`default List<T>`	`asList()` Returns a list of all the elements in this column Note, if a value in the column is missing, a `null` is added in it's place
`T[]`	`asObjectArray()`
`StringColumn`	`asStringColumn()`
`int`	`byteSize()` Returns the width of a cell in this column, in bytes.
`void`	`clear()`
`default int`	`columnWidth()` Returns the width of the column in characters, for printing
`default boolean`	`contains(T object)` Returns `true` if the given object appears in this column, and false otherwise TODO override in column subtypes for performance
`Column<T>`	`copy()` Returns a deep copy of the receiver
`default int`	`count(Predicate<? super T> test)` Counts the number of rows satisfying predicate
`default int`	`count(Predicate<? super T> test, int max)` Counts the number of rows satisfying predicate, but only upto the max value
`int`	`countMissing()` Returns the count of missing values in this column.
`default int`	`countUnique()` Returns the count of unique values in this column.
`Column<T>`	`emptyCopy()` Returns a copy of the receiver with no data.
`Column<T>`	`emptyCopy(int rowSize)` Returns an empty copy of the receiver, with its internal storage initialized to the given row size.
`default Column<T>`	`filter(Predicate<? super T> test)` Returns a new Column of the same type with only those rows satisfying the predicate
`default Column<T>`	`first(int numRows)`
`T`	`get(int row)`
`String`	`getString(int row)` Returns a string representation of the value at the given row.
`String`	`getUnformattedString(int r)`
`default Column<T>`	`inRange(int start, int end)` Returns a column containing the rows in this column beginning with start inclusive, and ending with end exclusive
`boolean`	`isEmpty()` Returns true if the column has no data
`Selection`	`isMissing()`
`boolean`	`isMissing(int rowNumber)`
`Selection`	`isNotMissing()`
`Column<T>`	`lag(int n)` Returns a column of the same type and size as the receiver, containing the receivers values offset by n.
`default Column<T>`	`last(int numRows)`
`default Column<T>`	`lead(int n)` Returns a column of the same type as the receiver, containing the receivers values offset -n For example if you lead a column containing 2, 3, 4 by 1, you get a column containing 3, 4, NA.
`default Column<T>`	`map(Function<? super T,? extends T> fun)` Maps the function across all rows, appending the results to a new Column of the same type
`default <R> Column<R>`	`mapInto(Function<? super T,? extends R> fun, Column<R> into)` Maps the function across all rows, appending the results to the provided Column
`default Column<T>`	`max(Column<T> other)` Returns a column containing the element-wise min between this column and other column TODO(lwhite) Override in column subtypes for better performance
`default Optional<T>`	`max(Comparator<? super T> comp)` Returns the maximum row according to the provided Comparator
`default Column<T>`	`min(Column<T> other)` Returns a column containing the element-wise min between this column and other column TODO(lwhite) Override in column subtypes for better performance
`default Optional<T>`	`min(Comparator<? super T> comp)` Returns the minimum row according to the provided Comparator
`String`	`name()` Returns the column's name.
`default boolean`	`noneMatch(Predicate<? super T> test)` Returns true if no row satisfies the predicate, false otherwise
`default String`	`print()` TODO(lwhite): Print n from the top and bottom, like a table;
`default Optional<T>`	`reduce(BinaryOperator<T> op)` Reduction with binary operator
`default T`	`reduce(T initial, BinaryOperator<T> op)` Reduction with binary operator and initial value
`Column<T>`	`removeMissing()`
`default RollingColumn`	`rolling(int windowSize)`
`it.unimi.dsi.fastutil.ints.IntComparator`	`rowComparator()`
`default Column<T>`	`sampleN(int n)` Returns a column containing a random sample of the values in this column
`default Column<T>`	`sampleX(double proportion)` Returns a table consisting of randomly selected values from this column.
`Column<T>`	`set(int row, Column<T> sourceColumn, int sourceRow)`
`Column<T>`	`set(int row, T value)`
`default Column<T>`	`set(Predicate<T> condition, Column<T> other)` Updates this column where values matching the selection are replaced with the corresponding value from the given column
`default Column<T>`	`set(Selection condition, Column<T> other)` Updates this column where values matching the selection are replaced with the corresponding value from the given column
`default Column<T>`	`set(Selection rowSelection, T newValue)` Conditionally update this column, replacing current values with newValue for all rows where the current value matches the selection criteria
`Column<T>`	`setMissing(int i)`
`Column<T>`	`setName(String name)` Sets the columns name to the given string
`int`	`size()`
`void`	`sortAscending()`
`void`	`sortDescending()`
`default Column<T>`	`sorted(Comparator<? super T> comp)` Returns a new Column of the same type sorted according to the provided Comparator
`default Column<T>`	`subset(int[] rows)`
`Table`	`summary()`
`default String`	`title()`
`ColumnType`	`type()` Returns this column's ColumnType
`Column<T>`	`unique()` Returns a column of the same type as the receiver, containing only the unique values of the receiver.
`Column<T>`	`where(Selection selection)`

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

Methods inherited from interface java.util.Comparator
compare, comparing, comparing, comparingDouble, comparingInt, comparingLong, equals, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

- Method Detail
  - size
```
int size()
```
  - summary
```
Table summary()
```
  - asObjectArray
```
T[] asObjectArray()
```
  - countMissing
```
int countMissing()
```
    Returns the count of missing values in this column.
    
    Returns:
    
    missing values as int
  - countUnique
```
default int countUnique()
```
    Returns the count of unique values in this column.
    
    Returns:
    
    unique values as int
  - name
```
String name()
```
    Returns the column's name.
    
    Returns:
    
    name as String
  - type
```
ColumnType type()
```
    Returns this column's ColumnType
    
    Returns:
    
    ColumnType
  - getString
```
String getString(int row)
```
    Returns a string representation of the value at the given row.
    
    Parameters:
    
    row - The index of the row.
    
    Returns:
    
    value as String
  - get
```
T get(int row)
```
  - reduce
```
default T reduce(T initial,
                 BinaryOperator<T> op)
```
    Reduction with binary operator and initial value
    
    Parameters:
    
    initial - initial value
    
    op - the operator
    
    Returns:
    
    the result of reducing initial value and all rows with operator
  - reduce
```
default Optional<T> reduce(BinaryOperator<T> op)
```
    Reduction with binary operator
    
    Parameters:
    
    op - the operator
    
    Returns:
    
    Optional with the result of reducing all rows with operator
  - clear
```
void clear()
```
  - sortAscending
```
void sortAscending()
```
  - sortDescending
```
void sortDescending()
```
  - isEmpty
```
boolean isEmpty()
```
    Returns true if the column has no data
    
    Returns:
    
    true if empty, false if not
  - rowComparator
```
it.unimi.dsi.fastutil.ints.IntComparator rowComparator()
```
  - title
```
default String title()
```
  - isMissing
```
Selection isMissing()
```
  - isNotMissing
```
Selection isNotMissing()
```
  - byteSize
```
int byteSize()
```
    Returns the width of a cell in this column, in bytes.
    
    Returns:
    
    width in bytes
  - asBytes
```
byte[] asBytes(int rowNumber)
```
    Returns the contents of the cell at rowNumber as a byte[].
    
    Parameters:
    
    rowNumber - index of the row
    
    Returns:
    
    content as byte[]
  - rolling
```
default RollingColumn rolling(int windowSize)
```
  - getUnformattedString
```
String getUnformattedString(int r)
```
  - isMissing
```
boolean isMissing(int rowNumber)
```
  - print
```
default String print()
```
    TODO(lwhite): Print n from the top and bottom, like a table;
  - columnWidth
```
default int columnWidth()
```
    Returns the width of the column in characters, for printing
  - asList
```
default List<T> asList()
```
    Returns a list of all the elements in this column Note, if a value in the column is missing, a null is added in it's place
  - contains
```
default boolean contains(T object)
```
    Returns true if the given object appears in this column, and false otherwise TODO override in column subtypes for performance
  - count
```
default int count(Predicate<? super T> test,
                  int max)
```
    Counts the number of rows satisfying predicate, but only upto the max value
    
    Parameters:
    
    test - the predicate
    
    max - the maximum number of rows to count
    
    Returns:
    
    the number of rows satisfying the predicate
  - count
```
default int count(Predicate<? super T> test)
```
    Counts the number of rows satisfying predicate
    
    Parameters:
    
    test - the predicate
    
    Returns:
    
    the number of rows satisfying the predicate
  - allMatch
```
default boolean allMatch(Predicate<? super T> test)
```
    Returns true if all rows satisfy the predicate, false otherwise
    
    Parameters:
    
    test - the predicate
    
    Returns:
    
    true if all rows satisfy the predicate, false otherwise
  - anyMatch
```
default boolean anyMatch(Predicate<? super T> test)
```
    Returns true if any row satisfies the predicate, false otherwise
    
    Parameters:
    
    test - the predicate
    
    Returns:
    
    true if any rows satisfies the predicate, false otherwise
  - noneMatch
```
default boolean noneMatch(Predicate<? super T> test)
```
    Returns true if no row satisfies the predicate, false otherwise
    
    Parameters:
    
    test - the predicate
    
    Returns:
    
    true if no row satisfies the predicate, false otherwise
  - max
```
default Optional<T> max(Comparator<? super T> comp)
```
    Returns the maximum row according to the provided Comparator
    
    Parameters:
    
    comp -
    
    Returns:
    
    the maximum row
  - min
```
default Optional<T> min(Comparator<? super T> comp)
```
    Returns the minimum row according to the provided Comparator
    
    Parameters:
    
    comp -
    
    Returns:
    
    the minimum row
  - mapInto
```
default <R> Column<R> mapInto(Function<? super T,? extends R> fun,
                              Column<R> into)
```
    Maps the function across all rows, appending the results to the provided Column
    
    Parameters:
    
    fun - function to map
    
    into - Column to which results are appended
    
    Returns:
    
    the provided Column, to which results are appended
  - setMissing
```
Column<T> setMissing(int i)
```
  - filter
```
default Column<T> filter(Predicate<? super T> test)
```
    Returns a new Column of the same type with only those rows satisfying the predicate
    
    Parameters:
    
    test - the predicate
    
    Returns:
    
    a new Column of the same type with only those rows satisfying the predicate
  - subset
```
default Column<T> subset(int[] rows)
```
  - sorted
```
default Column<T> sorted(Comparator<? super T> comp)
```
    Returns a new Column of the same type sorted according to the provided Comparator
    
    Parameters:
    
    comp - the Comparator
    
    Returns:
    
    a sorted Column
  - emptyCopy
```
Column<T> emptyCopy()
```
    Returns a copy of the receiver with no data. The column name and type are the same.
    
    Returns:
    
    a empty copy of Column
  - copy
```
Column<T> copy()
```
    Returns a deep copy of the receiver
    
    Returns:
    
    a Column
  - emptyCopy
```
Column<T> emptyCopy(int rowSize)
```
    Returns an empty copy of the receiver, with its internal storage initialized to the given row size.
    
    Parameters:
    
    rowSize - the initial row size
    
    Returns:
    
    a Column
  - map
```
default Column<T> map(Function<? super T,? extends T> fun)
```
    Maps the function across all rows, appending the results to a new Column of the same type
    
    Parameters:
    
    fun - function to map
    
    Returns:
    
    the Column with the results
  - min
```
default Column<T> min(Column<T> other)
```
    Returns a column containing the element-wise min between this column and other column TODO(lwhite) Override in column subtypes for better performance
  - max
```
default Column<T> max(Column<T> other)
```
    Returns a column containing the element-wise min between this column and other column TODO(lwhite) Override in column subtypes for better performance
  - set
```
default Column<T> set(Predicate<T> condition,
                      Column<T> other)
```
    Updates this column where values matching the selection are replaced with the corresponding value from the given column
  - set
```
default Column<T> set(Selection condition,
                      Column<T> other)
```
    Updates this column where values matching the selection are replaced with the corresponding value from the given column
  - lead
```
default Column<T> lead(int n)
```
    Returns a column of the same type as the receiver, containing the receivers values offset -n For example if you lead a column containing 2, 3, 4 by 1, you get a column containing 3, 4, NA.
  - set
```
default Column<T> set(Selection rowSelection,
                      T newValue)
```
    Conditionally update this column, replacing current values with newValue for all rows where the current value matches the selection criteria
  - lag
```
Column<T> lag(int n)
```
    Returns a column of the same type and size as the receiver, containing the receivers values offset by n.
    For example if you lag a column containing 2, 3, 4 by 1, you get a column containing NA, 2, 3
  - appendCell
```
Column<T> appendCell(String stringValue)
```
  - appendCell
```
Column<T> appendCell(String stringValue,
                     AbstractColumnParser<?> parser)
```
  - set
```
Column<T> set(int row,
              T value)
```
  - set
```
Column<T> set(int row,
              Column<T> sourceColumn,
              int sourceRow)
```
  - append
```
Column<T> append(T value)
```
  - append
```
Column<T> append(Column<T> column)
```
  - append
```
Column<T> append(Column<T> column,
                 int row)
```
  - appendObj
```
Column<T> appendObj(Object value)
```
  - appendMissing
```
Column<T> appendMissing()
```
    Appends a missing value appropriate to the column
  - where
```
Column<T> where(Selection selection)
```
  - removeMissing
```
Column<T> removeMissing()
```
  - unique
```
Column<T> unique()
```
    Returns a column of the same type as the receiver, containing only the unique values of the receiver.
    
    Returns:
    
    a Column
  - first
```
default Column<T> first(int numRows)
```
  - last
```
default Column<T> last(int numRows)
```
  - setName
```
Column<T> setName(String name)
```
    Sets the columns name to the given string
    
    Parameters:
    
    name - The new name MUST be unique for any table containing this column
    
    Returns:
    
    this Column to allow method chaining
  - inRange
```
default Column<T> inRange(int start,
                          int end)
```
    Returns a column containing the rows in this column beginning with start inclusive, and ending with end exclusive
  - sampleN
```
default Column<T> sampleN(int n)
```
    Returns a column containing a random sample of the values in this column
    
    Parameters:
    
    n - the number of values to select
    
    Returns:
    
    A column of the same type as the receiver
  - sampleX
```
default Column<T> sampleX(double proportion)
```
    Returns a table consisting of randomly selected values from this column. The sample size is based on the given proportion of the total number of cells in this column
    
    Parameters:
    
    proportion - The proportion to go in the sample
  - asStringColumn
```
StringColumn asStringColumn()
```

Interface Column<T>

Method Summary

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.Comparator

Method Detail

size

summary

asObjectArray

countMissing

countUnique

name

type

getString

get

reduce

reduce

clear

sortAscending

sortDescending

isEmpty

rowComparator

title

isMissing

isNotMissing

byteSize

asBytes

rolling

getUnformattedString

isMissing

print

columnWidth

asList

contains

count

count

allMatch

anyMatch

noneMatch

max

min

mapInto

setMissing

filter

subset

sorted

emptyCopy

copy

emptyCopy

map

min

max

set

set

lead

set

lag

appendCell

appendCell

set

set

append

append

append

appendObj

appendMissing

where

removeMissing

unique

first

last

setName

inRange

sampleN

sampleX

asStringColumn