在JAVA实现DataTable对象（三）——DataTable对象实现

大家都是行家，我就直接上代码了，我这个代码应该还是能看懂的，嘻嘻….

import java.util.ArrayList;
import java.util.List;


public final class DataTable {

    private DataRowCollection rows; //用于保存DataRow的集合对象
    private DataColumnCollection columns; //用于保存DataColumn的对象
    private String tableName; //表名
    private boolean readOnly = false;
    private int nextRowIndex = 0;
    private DataExpression dataExpression;
    private Object tag;

    public DataTable() {
        this.columns = new DataColumnCollection();
        this.rows = new DataRowCollection();
        this.rows.setColumns(columns);
        dataExpression = new DataExpression(this);
    }

    public DataTable(String dataTableName) {
        this();
        this.tableName = dataTableName;
    }

    public int getTotalCount() {
        return rows.size();
    }

    public boolean isReadOnly() {
        return this.readOnly;
    }

    public void setReadOnly(boolean readOnly) {
        this.readOnly = readOnly;
    }

    /**
     * 功能描述：  返回表名
     * @param
     */
    public String getTableName() {
        return this.tableName;
    }

    /**
     * 功能描述：  设置表名
     * @param
     */
    public void setTableName(String tableName) {
        this.tableName = tableName;
    }

    /**
     * 功能描述：  返回该表引用的封装类
     * @param
     * @return: DataRowCollection
     */
    public DataRowCollection getRows() {
        return this.rows;
    }

    public DataColumnCollection getColumns() {
        return this.columns;
    }

    /**
     * 功能描述：  获取指定行指定列的数据
     * @param
     * @return: Object
     */

    public Object getValue(int row,
            String colName) {
        return this.rows.get(row).getValue(colName);
    }

    public Object getValue(int row,
            int col) {
        return this.rows.get(row).getValue(col);
    }

    /**
     * 功能描述：  为该表数据新建一行
     * @param
     * @return: DataRow
     */
    public DataRow newRow() throws Exception {
        DataRow tempRow = new DataRow(this);
        nextRowIndex = nextRowIndex < this.rows.size() ? this.rows.size()
                : nextRowIndex;
        tempRow.setColumns(this.columns);
        tempRow.setRowIndex(nextRowIndex++);
        return tempRow;
    }

    public void setValue(int row,
            int col,
            Object value) {
        this.rows.get(row).setValue(col, value);
    }

    public void setValue(int row,
            String colName,
            Object value) {
        this.rows.get(row).setValue(colName, value);
    }

    /**
     * @param tag
     */
    public void setTag(Object tag) {
        this.tag = tag;
    }

    /**
     * @return  the tag
    */
    public Object getTag() {
        return tag;
    }

    public DataColumn addColumn(String columnName,
            int dataType) throws Exception {
        return this.columns.addColumn(columnName, dataType);
    }

    public boolean addRow(DataRow row) throws Exception {
        if (row.getRowIndex() > this.rows.size())
            row.setRowIndex(this.rows.size());
        return this.rows.add(row);
    }

    //以下为数据表扩展方法实现集合
    /**
     * 功能描述：  返回符合过滤条件的数据行集合，并返回
     * @param
     * @return: DataTable
     */
    public List<DataRow> select(String filterString) {
        List<DataRow> rows = new ArrayList<DataRow>();
        if (StringUtil.isNotEmpty(filterString)) {
            for (Object row : this.rows) {
                DataRow currentRow = (DataRow) row;
                if ((Boolean) dataExpression.compute(filterString,
                        currentRow.getItemMap())) {
                    rows.add(currentRow);
                }
            }
            return rows;
        } else {
            return this.rows;
        }
    }

    /**
     * 功能描述：  对当前表进行查询 过滤，并返回指定列集合拼装的DataTable对象
     * @param
     * @return: DataTable
     */
    public DataTable select(String filterString,
            String[] columns,
            boolean distinct) throws Exception {
        DataTable result = new DataTable();
        List<DataRow> rows = select(filterString);
        //构造表结构
        for (String c : columns) {
            DataColumn dc = this.columns.get(c);
            DataColumn newDc = new DataColumn(dc.getColumnName(),
                    dc.getDataType());
            newDc.setCaptionName(dc.getCaptionName());
            result.columns.add(newDc);
        }
        //填充数据
        for (DataRow r : rows) {
            DataRow newRow = result.newRow();
            newRow.copyFrom(r);
            result.addRow(newRow);
        }
        return result;
    }

    public DataTable select(String tableName,
            String selectField,
            String filterString,
            String groupField) {
        DataTable result = new DataTable();
        //
        return result;
    }

    /**
     * 功能描述：  根据指定表达式对符合过滤条件的数据进行计算
     * @param
     * @return: Object
     * @author: James Cheung
     * @version: 2.0
     */
    public Object compute(String expression,
            String filter) {
        return dataExpression.compute(expression, select(filter));
    }

    public Object max(String columns,
            String filter) {
        return null;
    }

    public Object min(String columns,
            String filter) {
        return null;
    }

    public Object avg(String columns,
            String filter) {
        return null;
    }

    public Object max(String columns,
            String filter,
            String groupBy) {
        return null;
    }

    public Object min(String columns,
            String filter,
            String groupBy) {
        return null;
    }

    public Object avg(String columns,
            String filter,
            String groupBy) {
        return null;
    }

    private List<DataColumn> getColumns(String colString) {
        List<DataColumn> columns = new ArrayList<DataColumn>();

        return columns;
    }
}