怎么将查询数据库获得的结果集转化为 二维数组

Question

public static String back(final String carnum) throws SQLException {//获取该车牌所在车位位置信息
        //加载数据库驱动
        String a;
        Connection  conn = null;
        conn = getConnection("whoere");
        //使用DriverManager获取数据库连接
        Statement  stmt = conn.createStatement();
        //使用Connection来创建一个Statment对象
        ResultSet rs =stmt.executeQuery(
                "select x,y from parking where carnum='"+carnum+"'");//从数据库中查询车牌对应的位置信息并返回
        rs.first();
        a=rs.getString(1);
        rs.close();
        return a;
        //把查询结果输出来
 

whoere是数据库的名称，我怎么样以坐标形式能得到车牌对应的位置信息呢 因为我理解的是 a获取了当前记录的第1列数据 我希望最后出来的是一个坐标(数组），因为我后续是需要对这个坐标进行二次处理的 不知道怎么做

Answer 1

第一段代码是用于从resultset获取结果的，然后我用了自己封装的Result，类似一个TABLE的数据结构
后续使用直接用result.getString(rowIndex,columnIndex) 使用坐标获取数据，也可以使用result.getString(rowIndex,columnName)两种方式获取，第二段则是RESULT的源码。封装好了直接送你了

protected Result callBack(ResultSet resultSet, int index) throws SQLException {
        if (resultSet == null) {
            return new Result();
        }
        Long startTime = System.currentTimeMillis();
        Result result = new Result();
        for (int i = 1; i <= resultSet.getMetaData().getColumnCount(); i++) {
            result.addColumnName(resultSet.getMetaData().getColumnName(i));
        }
        int count = 0;
        Clob clob = null;
        while (resultSet.next()) {
            for (int i = 1; i <= result.getColumnCount(); i++) {
                if (Types.CLOB == resultSet.getMetaData().getColumnType(i)) {
                    clob = resultSet.getClob(i);
                    if (clob != null) {
                        addValue(count, result, clob.getSubString(1L, (int) clob.length()));
                    }
                } else if (Types.NUMERIC == resultSet.getMetaData().getColumnType(i)) {
                    //防止出现科学计数法
//                    String value = new BigDecimal(String.valueOf(resultSet.getDouble(i))).toString();
//                    if(value.indexOf(".")>=0){
//                        String[] array = value.split("[.]");
//                        if(array.length==2&&Long.parseLong(array[1])==0){
//                            value = String.valueOf(Long.parseLong(array[0]));
//                        }
//                    }

                    addValue(count, result, setNumber(resultSet.getDouble(i)));
                } else {
                    addValue(count, result, resultSet.getString(i));
                }

            }
            count++;
        }
        result.setAffectedRows(count);
        result.isSuccessed(true);
        LogHelper.getLogger().debug(BaseHandler.class.getSimpleName(), LogHelper.DEBUG, "[" + index + "]封装数据耗时:" + (System.currentTimeMillis() - startTime) + "ms 共[" + count + "]行");
        return result;
    }

private void addValue(int count, Result result, String content) {
        if (nullToEmpty) {//是否把null值转换为空
            result.addValue(count, content == null ? "" : content);
        } else {
            result.addValue(count, content);
        }
    }

public class DataType {
    public final static int STRING = 1;
    public final static int INT = 2;
    public final static int LONG = 3;
    public final static int BOOLEAN = 4;
    public final static int DOUBLE = 5;
    public final static int DATE = 6;
    public final static int CLOB = 10;
    /**byte写入blob*/
    public final static int BYTE = 20;
    
}




public class Table extends DataType implements Serializable{
    private boolean nullStringToEmpty = false;
    public void nullStringToEmpty(boolean flag){
        nullStringToEmpty = flag;
    }
    /**行*/
    private List<Row> rows = new ArrayList<Row>();
    /**列名称*/
    private List<String> columnNames = new ArrayList<String>();
    /**列类型*/
    private List<Integer> columnTypes = new ArrayList<Integer>(); 
    /**
     * 添加列的名称 默认为String类型
     * @param name 
     */
    public void addColumnName(String name){
        columnNames.add(name);
        columnTypes.add(STRING);
    }
    /**
     * 设置某一列的数据类型
     * @param column
     * @param type 
     */
    public void setColumnType(int column,int type){
        columnTypes.set(column, type);
    }
    /**
     * 根据索引获取列的名称
     * @param index
     * @return 
     */
    public String getColumnName(int index){
        if(index>=getColumnCount())return null;
        return columnNames.get(index);
    }
    
    /**
     * 获取列的长度
     * @return 
     */
    public int getColumnCount(){
        return columnNames.size();
    }
    /**
     * 根据名称获取列的索引
     * @param name
     * @return 
     */
    public int getColumnIndex(String name){
        for(int i=0;i<columnNames.size();i++){
            if(columnNames.get(i).equals(name))return i;
        }
        return -1;
    }
    /**
     * 获取列的类型
     * @param index
     * @return 
     */
    public int getColumnType(int index){
        return columnTypes.get(index);
    }
    
    /**
     * 获取某一行
     * @param index
     * @return 
     */
    public Row getRow(int index){
        return rows.get(index);
    }
   
    
    public Object getObject(int rowIndex,int columnIndex){
        if(rowIndex<0||columnIndex<0)return null;
        return rows.get(rowIndex).getValue(columnIndex);
    }
    public Object getObject(int rowIndex,String columnName){
        int columnIndex = -1;
        for(int i=0;i<columnNames.size();i++){
            if(columnNames.get(i).equals(columnName)){
                columnIndex = i;
            }
        }
        return getObject(rowIndex, columnIndex);
    }
    
    public String getString(int rowIndex,int columnIndex){
        Object value = getObject(rowIndex, columnIndex);
        if(value==null){
            if(nullStringToEmpty)return "";
            return null;
        }
        return value.toString();
    }
    
    public String getString(int rowIndex,String columnName){
        int columnIndex = -1;
        for(int i=0;i<columnNames.size();i++){
            if(columnNames.get(i).equals(columnName)){
                columnIndex = i;
            }
        }
        return getString(rowIndex, columnIndex);
    }
    
    public double getDouble(int rowIndex,int columnIndex){
        String value = getString(rowIndex, columnIndex);
        return Double.parseDouble(value);
    }
    /**
     * 获取double数值，如果为null则返回0.0
     * @param rowIndex
     * @param columnName
     * @return 
     */
    public double getDouble(int rowIndex,String columnName){
        int columnIndex = -1;
        for(int i=0;i<columnNames.size();i++){
            if(columnNames.get(i).equals(columnName)){
                columnIndex = i;
            }
        }
        String value = getString(rowIndex, columnIndex);
        if(value==null||value.trim().length()==0)return 0.0d;
        return Double.parseDouble(value);
    }
    /**
     * 获取整形数值，如果为null则返回0
     * @param rowIndex
     * @param columnName
     * @return 
     */
    public int getInt(int rowIndex,String columnName){
        int columnIndex = -1;
        for(int i=0;i<columnNames.size();i++){
            if(columnNames.get(i).equals(columnName)){
                columnIndex = i;
            }
        }
        String value = getString(rowIndex, columnIndex);
        if(value==null||value.trim().length()==0)return 0;
        return Integer.parseInt(value);
    }
    public int getInt(int rowIndex,int columnIndex){
        String value = getString(rowIndex, columnIndex);
        return Integer.parseInt(value);
    }
    
    
    public long getLong(int rowIndex,String columnName){
        int columnIndex = -1;
        for(int i=0;i<columnNames.size();i++){
            if(columnNames.get(i).equals(columnName)){
                columnIndex = i;
            }
        }
        String value = getString(rowIndex, columnIndex);
        if(value==null||value.trim().length()==0)return 0;
        return Long.parseLong(value);
    }
    public long getLong(int rowIndex,int columnIndex){
        String value = getString(rowIndex, columnIndex);
        return Long.parseLong(value);
    }
    
    public Boolean getBoolean(int rowIndex,int columnIndex){
        String value = getString(rowIndex, columnIndex);
        if((value != null) && value.equalsIgnoreCase("true")){
            return true;
        }
        if((value != null) && value.equalsIgnoreCase("Y")){
            return true;
        }
        return false;
    }
    
    public Boolean getBoolean(int rowIndex,String columnName){
        String value = getString(rowIndex, columnName);
        if((value != null) && value.equalsIgnoreCase("true")){
            return true;
        }
        if((value != null) && value.equalsIgnoreCase("Y")){
            return true;
        }
        return false;
    }
    
    /**
     * 获取行的长度
     * @return 
     */
    public int getRowCount(){
        return rows.size();
    }
    
    
    
            
            

    //========================================添加值==========================================================
    
    /**
     * 为某一行添加数据，如果行索引大于现有行，则新增一行，并将该值作为该行的第一列的值。反之对该行新增一列。
     * @param rowIndex
     * @param data 
     */
    public void addValue(int rowIndex,String data){
        setRow(rowIndex).addColumnValue(data);
    } 
    public void addValue(int rowIndex,int data){
        setRow(rowIndex).addColumnValue(data);
    }
    public void addValue(int rowIndex,long data){
        setRow(rowIndex).addColumnValue(data);
    }
    public void addValue(int rowIndex,double data){
        setRow(rowIndex).addColumnValue(data);
    }
    public void addValue(int rowIndex,Object data){
        setRow(rowIndex).addColumnValue(data);
    }
    /**
     * 替换某一个行某一列的值
     * 如果行索引大于现有行，则新增加一行，并将值作为该行的第一列
     * 如何行索引小于现有行，则获取该行，并处理列。列索引大于此行现有的列，则新增列，反之则将该行的该列替换为现有值
     * @param rowIndex      行索引
     * @param columnIndex   列索引
     * @param data 
     */
    public void setValue(int rowIndex,int columnIndex,Object data,int type){
        setRow(rowIndex).setColumnValue(columnIndex, data,type);
    }
    public void setValue(int rowIndex,int columnIndex,String data){
        this.setValue(rowIndex, columnIndex, data, STRING);
    }
    
    
    /**
     * 根据索引来获取行，如果索引大于现有的行数，则添加新行，否则返回索引指定行
     * @param index
     * @return 
     */
    private Row setRow(int index){
        Row row = null;
        if(index>=rows.size()){
           row = new Row();
           rows.add(row);
        }else{
           row = rows.get(index);;
        }       
        return row;
    }
    
    
    
    
    public class Row implements Serializable{
        private List<Object> rowColValues = new ArrayList<Object>();        
        /**
         * 添加数据
         * @param parameter 
         */
        private void addColumnValue(Object parameter){           
            rowColValues.add(parameter); 
            //每次添加的时候验证列表的总列数和每一行的总列，因为用户可能会忘记设置列，从而导致出错。所以设置默认值
            if(columnNames.size()<rowColValues.size()){
                columnNames.add(String.valueOf(rowColValues.size()));
                columnTypes.add(STRING);
            }
            
        }
        
        /**
         * 将指定的索引的数据进行替换，如果索引大于现有的数据，则添加新的数据
         * @param index
         * @param parameter 
         * @param type  参数的数据类型
         */
        private void setColumnValue(int index,Object parameter,int type){
            if(index<rowColValues.size()){
                rowColValues.set(index, parameter);
            }else{
                addColumnValue(parameter);
            }            
        }
        private Object getValue(int index){
            if(index>=rowColValues.size())return null;
            return rowColValues.get(index);
        }     
        private int size(){
            return rowColValues.size();
        }
        
    }
    
    
    public String toString(){
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<getColumnCount();i++){
           sb.append(getColumnName(i)).append("\t");
        }
        sb.append("\n");
        for(int i=0;i<getRowCount();i++){
            for(int j=0;j<getColumnCount();j++){
                sb.append(getString(i, j)).append("\t");
            }
            sb.append("\n");
        }
        return sb.toString();
    }
}


public class Result extends Table{
    public class Attributes{
        public Attributes(){
            
        }
        public Attributes(Map<String,String> attr){
            attribute.putAll(attr);
        }
        public String getString(String key){
            return attribute.get(key);
        }
        public void put(String key,String value){
            attribute.put(key, value);
        }
        public void putAll(Map<String,String> attr){
            attribute.putAll(attr);
        }
        public int getInt(String key){
            return attribute.get(key)==null?null:Integer.parseInt(attribute.get(key));
        }
        Map<String,String> attribute = new HashMap<String,String>();
        
    }
    private Map<String,Attributes> attributes = new HashMap<String,Attributes>();
    private Map<String,String> resultAttribute = new HashMap<String,String>();
    /**
     * 用于设置整个结果的属性
     * @param name
     * @param value 
     */
    public void setAttribute(String name,String value){
        resultAttribute.put(name, value);
    }
    public String getAttribute(String name){
        return resultAttribute.get(name);
    }
    /**
     * 用于设置某个单元格的属性
     * @param rowIndex
     * @param columnIndex
     * @param attr 
     */
    public void addAttribute(int rowIndex,int columnIndex,Map<String,String> attr){
        attributes.put(String.valueOf(rowIndex)+String.valueOf(columnIndex), new Attributes(attr));
    }
    /**
     * 用于设置某个单元格的属性
     * @param rowIndex
     * @param columnIndex
     * @param attr 
     */
    public void addAttribute(int rowIndex,int columnIndex,Attributes attr){
        attributes.put(String.valueOf(rowIndex)+String.valueOf(columnIndex), attr);
    }
    /**
     * 用于设置某个单元格的属性
     * @param rowIndex
     * @param columnIndex
     * @param attrName
     * @param attrValue 
     */
    public void addAttribute(int rowIndex,int columnIndex,String attrName,String attrValue){
        Attributes attribue = getAttributes(rowIndex, columnIndex);
        if(attribue==null){
            attribue = new Attributes();
            attribue.put(attrName, attrValue);
            addAttribute(rowIndex, columnIndex, attribue);
            return;
        }
        attribue.put(attrName, attrValue);
    }
    
    
    public Attributes getAttributes(int rowIndex,int columnIndex){
        return attributes.get(String.valueOf(rowIndex)+String.valueOf(columnIndex));
    }
    public String getAttribute(int rowIndex,int columnIndex,String key){
        return getAttributes(rowIndex, columnIndex)==null?null:getAttributes(rowIndex, columnIndex).getString(key);
    }
    
    private String messgage;
    public void setMessage(String messgage){
        this.messgage = messgage;
    }
    public String getMessage(){
        return messgage;
    }
    private int affectedRows = 0;
    public int getAffectedRows(){
        return affectedRows;
    }
    public void setAffectedRows(int n){
        affectedRows = n;
    }
    private boolean isSuccessed = false;
    public void isSuccessed(boolean b){
        this.isSuccessed = b;
    }
    public boolean isSuccessed(){
        return isSuccessed;
    }
    public String[] getColumnNames(){
        String[] columns = new String[getColumnCount()];
        for(int i=0;i<getColumnCount();i++){
            columns[i] = getColumnName(i);
        }
        return columns;
    }
    public Object[] getArrRow(int index){
        if(index>=getRowCount())return null;
        Object[] array = new Object[getColumnCount()];
        int type = DataType.STRING;
        for(int i=0;i<getColumnCount();i++){
            type = getColumnType(i);
            if(type==DataType.BOOLEAN){
                array[i] = getBoolean(index, i);
            }else {
                array[i] = getObject(index, i);
            }
            
        }
        return array;
    }
    
    public String[] getStringArrRow(int index){
        if(index>=getRowCount())return null;
        String[] array = new String[getColumnCount()];
        for(int i=0;i<getColumnCount();i++){
            array[i] = this.getString(index, i);
        }
        return array;
    }
    
    public Map<String,String> getMapRow(int index){
        if(index>=getRowCount())return null;
        Map<String,String> map = new HashMap<String,String>();
        for(int i=0;i<getColumnCount();i++){
            map.put(getColumnName(i), getString(index, i));
        }
        return map;
    }
    
//    public String toString(){
//        StringBuilder sb = new StringBuilder();
//        return sb.toString();
//    }

    
    
    
    
    
    
    
    
    
}