哪位仁兄分部分JAVA的活做做，不用任何报酬，就为练手！

Question

做个能处理图像的panel吧，可以处理到像素一级的。

Answer 1

好呀。既然你很愿意，我给你活做吧，你写一个Java GUI，用来实现把简单word文档读取成字节流形式，如何？

Answer 2

你好，有个想法不错，你现在没有工作吗？帮我写一个类似访问数据库的类，我想将我下面给的代的public String[][] getQueryRecord()，用ArrayList返回！同时帮我看看错误的地方，这个可以正常运行。/**
 * 功能：
 *     数据库连接设计，主要是连接数据库，访问数据库，更新数据库信息；
 *     数据库的查询信息等。此处同时用到的JDOM设计解析配置文件，配置
 *     文件中主要有数据库的连接信息，数据库访问用户名、用户密码及数
 *     据库服务器的IP地址。
 *
 *
 *
 * 文件：ConnectDB.java
 * 时间：2003-07-02
 * 编写：
 *
 */
 
package com.xwn;import java.sql.*;
import javax.swing.JOptionPane;
import java.util.Vector;public class ConnectDB
{
    /**功能：获得访问数据库的唯用实例
     *参数：int nDataBaseType数据库类型,现在支持Oracle、Postgres及MSSQL
     *返回值：返回类的唯一实例
     */
    public static ConnectDB getInstance(int nDatabaseType)
    {
        return (null == INSTANCE) ? (INSTANCE = new ConnectDB(nDatabaseType)) : INSTANCE;
    }
    
    /**功能：更新数据库，如执行Insert, delete update等操作!
     *参数：String strSQL 要执行的更新SQL语句
     *返回值：如果更新成功则返回true，否则返回false
     */
    public boolean executeUpdate(String strSQL)
    {
        try {
            m_stmt = m_connection.createStatement();
            int state = m_stmt.executeUpdate(strSQL);
            return true;
        } catch(SQLException sqle) {
            try {
                m_stmt.close();
            } catch(SQLException e) {
                String strMsg = "查询数据库发生错误!\n" + "错误代码:" + e.getErrorCode() + "\n错误信息:" + e.getMessage();
                JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
                sqle.printStackTrace();
                return false;                
            }
            String strMsg = "查询数据库发生错误!\n" + "错误代码:" + sqle.getErrorCode() + "\n错误信息:" + sqle.getMessage();
            JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
            sqle.printStackTrace();
            return false;
        }
    }
    
    /**功能：更新数据库，如执行Insert, delete update等操作!
     *参数：String[] strArraySQL 要执行的更新SQL语句
     *返回值：如果更新成功则返回true，否则返回false
     */
    public boolean executeUpdate(String[] strArraySQL)
    {
        try {
            m_stmt = m_connection.createStatement();
            
            for (int i = 0; i < strArraySQL.length; i++)
                m_stmt.addBatch(strArraySQL[i]);
            int[] nArrayState = m_stmt.executeBatch();
            // 如果所有的执全部成功，则提交
            m_connection.commit();
            m_stmt.close();
            return true;
        } catch(SQLException sqle) {
            try {
                m_stmt.close();
            } catch(SQLException e) {
                String strMsg = "查询数据库发生错误!\n" + "错误代码:" + e.getErrorCode() + "\n错误信息:" + e.getMessage();
                JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
                sqle.printStackTrace();
                return false;                
            }
            
            String strMsg = "查询数据库发生错误!\n" + "错误代码:" + sqle.getErrorCode() + "\n错误信息:" + sqle.getMessage();
            JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
            sqle.printStackTrace();
            return false;
        }
    }
    
    /**功能：执行SQL语句的查询，返回所有的记录，并以字符串数组的形式返回；
     *参数：String strSQL 执行查询的SQL语句
     *返回值：String[] 查询结果的字符串数组
     */
    public void executeQuery(String strSQL)
    {
        try {
            m_stmt = m_connection.createStatement();
            m_resultSet = m_stmt.executeQuery(strSQL);
            
            m_rsmd = m_resultSet.getMetaData();
            
            int nColumnCount = m_rsmd.getColumnCount();
            m_strColumnName = new String[nColumnCount];
            
            // 查询结束后获得表的字段名，并存储在字符串数组中
            for (int i = 0; i < getColumnCount(); i++)
                m_strColumnName[i] = m_rsmd.getColumnName(i + 1);        } catch(SQLException sqle) {
            String strMsg = "查询数据库发生错误!\n" + "错误代码:" + sqle.getErrorCode() + "\n错误信息:" + sqle.getMessage();
            JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
            sqle.printStackTrace();
            return;
        }
    }
    
    public String[][] getQueryRecord()
    {
        try {
            if (null != m_resultSet) {
                m_vRecord = new Vector();
                
                while(m_resultSet.next()) {
                    Vector oneRecord = new Vector();
                    for (int i = 0; i < getColumnCount(); i++) {
                        System.out.println("i = " + i);
                        oneRecord.addElement(m_resultSet.getObject(i + 1));
                    }                    m_vRecord.addElement(oneRecord);
                }
                
                
                int nRecordCount = this.getRecordCount();
                int nColumnCount = this.getColumnCount();
                
                
                //分配存储数据库记录缓存
                String[][] strArrayRecord = new String[nRecordCount][nColumnCount];                for (int i = 0; i < nRecordCount; i++)
                    for (int j = 0; j < nColumnCount; j++) {
                        Vector tmp = (Vector)m_vRecord.get(i);                        // 获得每一条记录的所有字段值
                        String strVal = null;
                        
                        Class recordClass = this.getColumnClass(j);                        
                        
                        //判断字段的类型，所有类型全部转化为字符串
                        if (recordClass.getName().equalsIgnoreCase("java.lang.String")) {
                            strVal = (String)tmp.get(j);
                        } else if (recordClass.getName().equalsIgnoreCase("java.lang.Integer")) {
                            Integer nVal = (Integer)tmp.get(j);
                            strVal = nVal.toString();//Integer.toString(nVal);
                        } else if (recordClass.getName().equalsIgnoreCase("java.lang.Double")) {
                            Double dVal = (Double)tmp.get(j);
                            strVal = dVal.toString();//Double.toString(dVal);
                        } else if (recordClass.getName().equalsIgnoreCase("java.lang.Long")) {
                            Long lVal = (Long)tmp.get(j);
                            strVal = lVal.toString();//Long.toString(lVal);
                        } else if (recordClass.getName().equalsIgnoreCase("java.sql.Date")) {
                            java.sql.Date dateVal = (java.sql.Date)tmp.get(j);
                            strVal = dateVal.toString();
                        } else if (recordClass.getName().equalsIgnoreCase("java.lang.Boolean")) {
                            Boolean bVal = (Boolean)tmp.get(j);
                            strVal = bVal.toString();
                        }
                        System.out.println("strVal" + strVal);
                        strArrayRecord[i][j] = strVal;
                    }
                return strArrayRecord;
            } else {
                JOptionPane.showMessageDialog(null, "RESULTSET为空指针!", "错误", JOptionPane.YES_OPTION);
                return null;
            }
        } catch(SQLException sqle) {
            String strMsg = "查询数据库发生错误!\n" + "错误代码:" + sqle.getErrorCode() + "\n错误信息:" + sqle.getMessage();
            JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
            sqle.printStackTrace();
            return null;
        }
    }

Answer 3

/**功能：获得数据库表列的大小
     *参数：
     *返回值：返回表列大小
     */
    public int getColumnCount()
    {
        return m_strColumnName.length;
    }
    
    /** 功能：获得查询语句的列名
     * 参数：无
     * 返回值：列名数据(Object对象)
     */
    public String[] getColumnName()
    {
        return m_strColumnName;
    }
    
    /**功能：获得数据库表字段的变量，如果此字段为字符串或整型
     *参数：int nColumnIndex 表列名的索引
     *返回值：此字段的类型名
     */
    public Class getColumnClass(int nColumnIndex)
    {
        int nType = -1;
        
        try {
            if (null != m_rsmd)
                nType = m_rsmd.getColumnType(nColumnIndex + 1);
            
        } catch(SQLException sqle) {
            String strMsg = "查询数据库发生错误!\n" + "错误代码:" + sqle.getErrorCode() + "\n错误信息:" + sqle.getMessage();
            JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
            sqle.printStackTrace();
            return null;
        }
        
        switch(nType) {
        case Types.CHAR:
        case Types.VARCHAR:
        case Types.LONGVARCHAR:
            return String.class;
        case Types.BIT:
            return Boolean.class;
        case Types.TINYINT:
        case Types.SMALLINT:
        case Types.INTEGER:
            return Integer.class;
        case Types.BIGINT:
            return Long.class;
        case Types.FLOAT:
        case Types.DOUBLE:
            return Double.class;
        case Types.DATE:
            return java.sql.Date.class;
        default:
            return Object.class;
        }
    }
    
    /**功能：获得查询表的记录总数
     *参数：
     *返回值：返回记录的大小
     */
    public int getRecordCount()
    {
        return m_vRecord.size();
    }
    
    /**功能：构造函数
     *参数：String strDriverName 数据库驱动名
     *      String strURL数据库URL
     *      String strUser数据库用户名
     *      String strPasswd数据库访问密码
     *返回值：访问数据库类实例
     */
    public ConnectDB(String strDriverName, 
                     String strURL, 
                     String strUser, 
                     String strPasswd)
    {
        m_strDriverName = strDriverName;
        m_strURL = strURL;
        m_strUser = strUser;
        m_strPasswd = strPasswd;
        
        init();
    }
    
    /**功能：构造数数
     *参数：无
     *返回值：无
     */
    private ConnectDB(int nDatabaseType)
    {
        String strDatabaseName = null;
        if (ConnectDB.ORACLE == nDatabaseType)
            strDatabaseName = "oracle";
        else if (ConnectDB.POSTGRES == nDatabaseType)
            strDatabaseName = "postgres";
        else if (ConnectDB.SQLSERVER == nDatabaseType)
            strDatabaseName = "sqlserver";
        else
            strDatabaseName = "oracle";        
        m_strDriverName = m_parse.getElementAttribute("database", strDatabaseName, "driver");
        m_strURL = m_parse.getElementAttribute("database", strDatabaseName, "url");
        m_strUser = m_parse.getElementAttribute("database", strDatabaseName, "user");
        m_strPasswd = m_parse.getElementAttribute("database", strDatabaseName, "pwd");
        
        String strDatabase = m_parse.getElementAttribute("database", strDatabaseName, "database");
        
        m_strURL += strDatabase;
        
        init();
    }
    
    /** 初始化 */
    protected void init()
    {
        try {
            Class.forName(m_strDriverName);
            m_connection = DriverManager.getConnection(m_strURL, m_strUser, m_strPasswd);
            m_connection.setAutoCommit(false);
        }
        catch(ClassNotFoundException cnfe) {
            String strMsg = "连接数据库发生错误,没有发现数据库驱动! \n错误信息:" + cnfe.getMessage();
            JOptionPane.showMessageDialog(null, strMsg, "错误", JOptionPane.YES_OPTION);
            cnfe.printStackTrace();
            return;
        }
        catch(SQLException sqle) {
            String strMsg = "连接数据库发生错误! \n错误代码:" + sqle.getErrorCode() + "\n错误信息:" + sqle.getMessage();
            JOptionPane.showMessageDialog(null, strMsg, "SQLException错误", JOptionPane.YES_OPTION);
            sqle.printStackTrace();
            return;
        }
    }
    
    // Variable declaration
    public static ConnectDB INSTANCE = null;
    
    private Connection m_connection = null;
    private ResultSetMetaData m_rsmd = null;
    private ResultSet m_resultSet = null;
    private Statement m_stmt = null;
    
    
    private String m_strDriverName = null;
    private String m_strURL        = null;
    private String m_strUser       = null;
    private String m_strPasswd     = null;    private String[] m_strColumnName = null;
    private Vector m_vRecord = null;
    
    public static final int POSTGRES = 0;
    public static final int ORACLE = 1;
    public static final int SQLSERVER = 2;    private Parse m_parse = Parse.getInstance();
    // End variable declaration
}