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

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

   1:  import java.util.ArrayList;

   2:  import java.util.List;

   3:   

   6:   

   7:  public final class DataTable {

   8:   

   9:      private DataRowCollection rows; //用于保存DataRow的集合对象

  10:      private DataColumnCollection columns; //用于保存DataColumn的对象

  11:      private String tableName; //表名

  12:      private boolean readOnly = false;

  13:      private int nextRowIndex = 0;

  14:      private DataExpression dataExpression;

  15:      private Object tag;

  16:   

  17:      public DataTable() {

  18:          this.columns = new DataColumnCollection();

  19:          this.rows = new DataRowCollection();

  20:          this.rows.setColumns(columns);

  21:          dataExpression = new DataExpression(this);

  22:      }

  23:   

  24:      public DataTable(String dataTableName) {

  25:          this();

  26:          this.tableName = dataTableName;

  27:      }

  28:   

  29:      public int getTotalCount() {

  30:          return rows.size();

  31:      }

  32:   

  33:      public boolean isReadOnly() {

  34:          return this.readOnly;

  35:      }

  36:   

  37:      public void setReadOnly(boolean readOnly) {

  38:          this.readOnly = readOnly;

  39:      }

  40:   

  41:      /**  

  42:       * 功能描述：  返回表名

  43:       * @param    

  44:       */

  45:      public String getTableName() {

  46:          return this.tableName;

  47:      }

  48:   

  49:      /**  

  50:       * 功能描述：  设置表名

  51:       * @param    

  52:       */

  53:      public void setTableName(String tableName) {

  54:          this.tableName = tableName;

  55:      }

  56:   

  57:      /**  

  58:       * 功能描述：  返回该表引用的封装类

  59:       * @param

  60:       * @return: DataRowCollection    

  61:       */

  62:      public DataRowCollection getRows() {

  63:          return this.rows;

  64:      }

  65:   

  66:      public DataColumnCollection getColumns() {

  67:          return this.columns;

  68:      }

  69:   

  70:      /**  

  71:       * 功能描述：  获取指定行指定列的数据

  72:       * @param

  73:       * @return: Object    

  74:       */

  75:   

  76:      public Object getValue(int row,

  77:              String colName) {

  78:          return this.rows.get(row).getValue(colName);

  79:      }

  80:   

  81:      public Object getValue(int row,

  82:              int col) {

  83:          return this.rows.get(row).getValue(col);

  84:      }

  85:   

  86:      /**  

  87:       * 功能描述：  为该表数据新建一行

  88:       * @param

  89:       * @return: DataRow     

  90:       */

  91:      public DataRow newRow() throws Exception {

  92:          DataRow tempRow = new DataRow(this);

  93:          nextRowIndex = nextRowIndex < this.rows.size() ? this.rows.size()

  94:                  : nextRowIndex;

  95:          tempRow.setColumns(this.columns);

  96:          tempRow.setRowIndex(nextRowIndex++);

  97:          return tempRow;

  98:      }

  99:   

 100:      public void setValue(int row,

 101:              int col,

 102:              Object value) {

 103:          this.rows.get(row).setValue(col, value);

 104:      }

 105:   

 106:      public void setValue(int row,

 107:              String colName,

 108:              Object value) {

 109:          this.rows.get(row).setValue(colName, value);

 110:      }

 111:   

 112:      /**  

 113:       * @param tag

 114:       */

 115:      public void setTag(Object tag) {

 116:          this.tag = tag;

 117:      }

 118:   

 119:      /**  

 120:       * @return  the tag   

 121:      */

 122:      public Object getTag() {

 123:          return tag;

 124:      }

 125:   

 126:      public DataColumn addColumn(String columnName,

 127:              int dataType) throws Exception {

 128:          return this.columns.addColumn(columnName, dataType);

 129:      }

 130:   

 131:      public boolean addRow(DataRow row) throws Exception {

 132:          if (row.getRowIndex() > this.rows.size())

 133:              row.setRowIndex(this.rows.size());

 134:          return this.rows.add(row);

 135:      }

 136:   

 137:      //以下为数据表扩展方法实现集合

 138:      /**  

 139:       * 功能描述：  返回符合过滤条件的数据行集合，并返回

 140:       * @param

 141:       * @return: DataTable    

 142:       */

 143:      public List<DataRow> select(String filterString) {

 144:          List<DataRow> rows = new ArrayList<DataRow>();

 145:          if (StringUtil.isNotEmpty(filterString)) {

 146:              for (Object row : this.rows) {

 147:                  DataRow currentRow = (DataRow) row;

 148:                  if ((Boolean) dataExpression.compute(filterString,

 149:                          currentRow.getItemMap())) {

 150:                      rows.add(currentRow);

 151:                  }

 152:              }

 153:              return rows;

 154:          } else {

 155:              return this.rows;

 156:          }

 157:      }

 158:   

 159:      /**  

 160:       * 功能描述：  对当前表进行查询 过滤，并返回指定列集合拼装的DataTable对象

 161:       * @param

 162:       * @return: DataTable    

 163:       */

 164:      public DataTable select(String filterString,

 165:              String[] columns,

 166:              boolean distinct) throws Exception {

 167:          DataTable result = new DataTable();

 168:          List<DataRow> rows = select(filterString);

 169:          //构造表结构

 170:          for (String c : columns) {

 171:              DataColumn dc = this.columns.get(c);

 172:              DataColumn newDc = new DataColumn(dc.getColumnName(),

 173:                      dc.getDataType());

 174:              newDc.setCaptionName(dc.getCaptionName());

 175:              result.columns.add(newDc);

 176:          }

 177:          //填充数据

 178:          for (DataRow r : rows) {

 179:              DataRow newRow = result.newRow();

 180:              newRow.copyFrom(r);

 181:              result.addRow(newRow);

 182:          }

 183:          return result;

 184:      }

 185:   

 186:      public DataTable select(String tableName,

 187:              String selectField,

 188:              String filterString,

 189:              String groupField) {

 190:          DataTable result = new DataTable();

 191:          //

 192:          return result;

 193:      }

 194:   

 195:      /**  

 196:       * 功能描述：  根据指定表达式对符合过滤条件的数据进行计算

 197:       * @param

 198:       * @return: Object

 199:       * @author: James Cheung

 200:       * @version: 2.0 

 201:       */

 202:      public Object compute(String expression,

 203:              String filter) {

 204:          return dataExpression.compute(expression, select(filter));

 205:      }

 206:   

 207:      public Object max(String columns,

 208:              String filter) {

 209:          return null;

 210:      }

 211:   

 212:      public Object min(String columns,

 213:              String filter) {

 214:          return null;

 215:      }

 216:   

 217:      public Object avg(String columns,

 218:              String filter) {

 219:          return null;

 220:      }

 221:   

 222:      public Object max(String columns,

 223:              String filter,

 224:              String groupBy) {

 225:          return null;

 226:      }

 227:   

 228:      public Object min(String columns,

 229:              String filter,

 230:              String groupBy) {

 231:          return null;

 232:      }

 233:   

 234:      public Object avg(String columns,

 235:              String filter,

 236:              String groupBy) {

 237:          return null;

 238:      }

 239:   

 240:      private List<DataColumn> getColumns(String colString) {

 241:          List<DataColumn> columns = new ArrayList<DataColumn>();

 242:   

 243:          return columns;

 244:      }

 245:  }