Class Table

    • Field Detail

      • rowCount

        protected int rowCount
      • allocCount

        protected int allocCount
      • missingString

        protected String missingString
      • missingInt

        protected int missingInt
      • missingLong

        protected long missingLong
      • missingFloat

        protected float missingFloat
      • missingDouble

        protected double missingDouble
      • missingCategory

        protected int missingCategory
      • columns

        protected Object[] columns
      • rowIterator

        protected processing.data.Table.RowIterator rowIterator
      • expandIncrement

        protected int expandIncrement
    • Constructor Detail

      • Table

        public Table()
        Creates a new, empty table. Use addRow() to add additional rows.
      • 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,
                     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
    • Method Detail

      • init

        protected void init()
      • extensionOptions

        public static String extensionOptions​(boolean loading,
                                              String filename,
                                              String options)
      • splitLineCSV

        protected String[] splitLineCSV​(String line,
                                        BufferedReader reader)
                                 throws IOException
        Parse a line of text as comma-separated values, returning each value as one entry in an array of String objects. Remove quotes from entries that begin and end with them, and convert 'escaped' quotes to actual quotes.
        Parameters:
        line - line of text to be parsed
        Returns:
        an array of the individual values formerly separated by commas
        Throws:
        IOException
      • odsParse

        protected void odsParse​(InputStream input,
                                String worksheet,
                                boolean header)
      • parseInto

        public void parseInto​(Object enclosingObject,
                              String fieldName)
        incomplete, do not use
      • writeTSV

        protected void writeTSV​(PrintWriter writer)
      • writeCSV

        protected void writeCSV​(PrintWriter writer)
      • writeEntryCSV

        protected void writeEntryCSV​(PrintWriter writer,
                                     String entry)
      • writeHTML

        protected void writeHTML​(PrintWriter writer)
      • writeEntryHTML

        protected void writeEntryHTML​(PrintWriter writer,
                                      String entry)
      • 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()
      • 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)
      • getColumnIndex

        protected int getColumnIndex​(String name,
                                     boolean report)
        Get the index of a column.
        Parameters:
        name - Name of the column.
        report - Whether to throw an exception if the column wasn't found.
        Returns:
        index of the found column, or -1 if not found.
      • 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
      • lastRowIndex

        public int lastRowIndex()
      • setRowCount

        public void setRowCount​(int newCount)
      • addRow

        public TableRow addRow​(TableRow source)
        Parameters:
        source - a reference to the original row to be duplicated
      • 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)
      • setRowCol

        protected void setRowCol​(int row,
                                 int col,
                                 Object piece)
      • 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,
                           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,
                              String columnName)
        Parameters:
        columnName - title of the column to reference
      • setMissingFloat

        public void setMissingFloat​(float value)
      • 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,
                                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,
                              String columnName,
                              String value)
        Parameters:
        columnName - title of the target 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,
                                String columnName)
        Parameters:
        columnName - title of the column to search
      • 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:
        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,
                                 String columnName)
        Parameters:
        columnName - title of the column to search
      • 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)
      • 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()
      • 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
      • isEmptyArray

        protected boolean isEmptyArray​(String[] contents)
      • 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
      • ensureColumn

        protected void ensureColumn​(int col)
        Make sure this is a legit column, and if not, expand the table.
      • ensureRow

        protected void ensureRow​(int row)
        Make sure this is a legit row, and if not, expand the table.
      • ensureBounds

        protected void ensureBounds​(int row,
                                    int col)
        Make sure this is a legit row and column. If not, expand the table.
      • checkRow

        protected void checkRow​(int row)
        Throw an error if this row doesn't exist.
      • checkColumn

        protected void checkColumn​(int column)
        Throw an error if this column doesn't exist.
      • checkBounds

        protected void checkBounds​(int row,
                                   int column)
        Throw an error if this entry is out of bounds.
      • 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()
      • 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)
      • sort

        protected void sort​(int column,
                            boolean reverse)
      • getUnique

        public String[] getUnique​(String columnName)
      • getUnique

        public String[] getUnique​(int column)
      • getTally

        public IntDict getTally​(int column)
      • getOrder

        public IntDict getOrder​(int column)
      • getIntList

        public IntList getIntList​(int column)
      • getFloatList

        public FloatList getFloatList​(int column)
      • getStringList

        public StringList getStringList​(int column)
      • getIntDict

        public IntDict getIntDict​(int keyColumn,
                                  int valueColumn)
      • getFloatDict

        public FloatDict getFloatDict​(int keyColumn,
                                      int valueColumn)
      • getStringDict

        public StringDict getStringDict​(int keyColumn,
                                        int valueColumn)
      • 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");
         
      • createSubset

        protected Table createSubset​(int[] rowSubset)
      • getMaxFloat

        protected float getMaxFloat()
        Searches the entire table for float values. Returns missing float (Float.NaN by default) if no valid numbers found.
      • copy

        public Table copy()
        Make a copy of the current table
      • print

        public void print()