java常用工具类（三）

一、连接数据库的综合类

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. package com.itjh.javaUtil;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.PreparedStatement;  
  6. import java.sql.ResultSet;  
  7. import java.sql.ResultSetMetaData;  
  8. import java.sql.SQLException;  
  9. import java.util.ArrayList;  
  10. import java.util.Collections;  
  11. import java.util.HashMap;  
  12. import java.util.List;  
  13. import java.util.Map;  
  14.   
  15. import org.apache.commons.dbcp.ConnectionFactory;  
  16. import org.apache.commons.dbcp.DriverManagerConnectionFactory;  
  17. import org.apache.commons.dbcp.PoolableConnectionFactory;  
  18. import org.apache.commons.dbcp.PoolingDriver;  
  19. import org.apache.commons.dbutils.DbUtils;  
  20. import org.apache.commons.dbutils.QueryRunner;  
  21. import org.apache.commons.dbutils.handlers.MapListHandler;  
  22. import org.apache.commons.pool.ObjectPool;  
  23. import org.apache.commons.pool.impl.GenericObjectPool;  
  24.   
  25. /** 
  26.  * 连接数据库的综合类。</br> 
  27.  * 依赖jar包：commons.dbcp-1.4，commons.dbutils-1.3，commons.pool-1.5.4包。 
  28.  *  
  29.  * @author 宋立君 
  30.  * @date 2014年07月03日 
  31.  */  
  32.   
  33. public class DBUtil {  
  34.   
  35.     private String dri = null;  
  36.     private String url = null;  
  37.     private String username = null;  
  38.     private String password = null;  
  39.     private String poolName = null; // 连接池名称  
  40.     private ObjectPool connectionPool = null; // 连接池  
  41.     // 对应的定时查询类  
  42.     private QueryThread queryThread = null;  
  43.   
  44.     /** 
  45.      * 功能：构造函数 
  46.      *  
  47.      * @author 宋立君 
  48.      * @date 2014年07月03日 
  49.      * @param dri 
  50.      *            驱动全类名，例如：com.mysql.jdbc.Driver。 
  51.      * @param url 
  52.      *            数据库url连接，例如： 
  53.      *            "jdbc:mysql://127.0.0.1:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8" 
  54.      * @param userName 
  55.      *            数据库用户名，例如：root 
  56.      * @param password 
  57.      *            数据库密码，例如：abc 
  58.      * @param poolName 
  59.      *            创建的数据库连接池的名称，例如mypool，注意一个web容器此名称不能重复。 
  60.      */  
  61.     public DBUtil(String dri, String url, String userName, String password,  
  62.             String poolName) {  
  63.         this.dri = dri;  
  64.         this.url = url;  
  65.         this.username = userName;  
  66.         this.password = password;  
  67.         this.poolName = poolName;  
  68.     }  
  69.   
  70.     /** 
  71.      * 执行sql。 
  72.      *  
  73.      * @param conn 
  74.      *            连接 
  75.      * @param pstm 
  76.      *            PreparedStatement 
  77.      * @return int 执行sql对应的影响行。 
  78.      * @throws SQLException 
  79.      * @author 宋立君 
  80.      * @date 2014年07月03日 
  81.      */  
  82.     public int execute(Connection conn, PreparedStatement pstm)  
  83.             throws SQLException {  
  84.         try {  
  85.             return pstm.executeUpdate();  
  86.         } finally {  
  87.             Close(conn);  
  88.         }  
  89.     }  
  90.   
  91.     /** 
  92.      * 查询sql。 
  93.      *  
  94.      * @param conn 
  95.      *            连接 
  96.      * @param pstm 
  97.      *            PreparedStatement 
  98.      * @return List<Map<String,Object>> 查询的结果集 
  99.      * @throws SQLException 
  100.      * @author 宋立君 
  101.      * @date 2014年07月03日 
  102.      */  
  103.     public List<Map<String, Object>> query(Connection conn,  
  104.             PreparedStatement pstm) throws SQLException {  
  105.         try {  
  106.             return resultSetToList(pstm.executeQuery());  
  107.         } finally {  
  108.             Close(conn);  
  109.         }  
  110.     }  
  111.   
  112.     /** 
  113.      * 功能：ResultSet 转为List<Map<String,Object>> 
  114.      *  
  115.      *  
  116.      * @param rs 
  117.      *            ResultSet 原始数据集 
  118.      * @return List<Map<String,Object>> 
  119.      * @throws java.sql.SQLException 
  120.      * @author 宋立君 
  121.      * @date 2014年07月03日 
  122.      */  
  123.     private List<Map<String, Object>> resultSetToList(ResultSet rs)  
  124.             throws java.sql.SQLException {  
  125.         if (rs == null)  
  126.             return Collections.EMPTY_LIST;  
  127.   
  128.         ResultSetMetaData md = rs.getMetaData(); // 得到结果集(rs)的结构信息，比如字段数、字段名等  
  129.         int columnCount = md.getColumnCount(); // 返回此 ResultSet 对象中的列数  
  130.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
  131.         Map<String, Object> rowData = new HashMap<String, Object>();  
  132.         while (rs.next()) {  
  133.             rowData = new HashMap<String, Object>(columnCount);  
  134.             for (int i = 1; i <= columnCount; i++) {  
  135.                 rowData.put(md.getColumnName(i), rs.getObject(i));  
  136.             }  
  137.             list.add(rowData);  
  138.         }  
  139.         return list;  
  140.     }  
  141.   
  142.     /** 
  143.      * 查询sql语句。 
  144.      *  
  145.      * @param sql 
  146.      *            被执行的sql语句 
  147.      * @return List<Map<String,Object>> 
  148.      * @throws SQLException 
  149.      * @author 宋立君 
  150.      * @date 2014年07月03日 
  151.      */  
  152.     public List<Map<String, Object>> query(String sql) throws SQLException {  
  153.         List<Map<String, Object>> results = null;  
  154.         Connection conn = null;  
  155.         try {  
  156.             conn = getConnection();  
  157.             QueryRunner qr = new QueryRunner();  
  158.             results = qr.query(conn, sql, new MapListHandler());  
  159.         } finally {  
  160.             Close(conn);  
  161.         }  
  162.         return results;  
  163.     }  
  164.   
  165.     /** 
  166.      * 根据参数查询sql语句 
  167.      *  
  168.      * @param sql 
  169.      *            sql语句 
  170.      * @param param 
  171.      *            参数 
  172.      * @return List<Map<String,Object>> 
  173.      * @throws SQLException 
  174.      * @author 宋立君 
  175.      * @date 2014年07月03日 
  176.      */  
  177.     public List<Map<String, Object>> query(String sql, Object param)  
  178.             throws SQLException {  
  179.         List<Map<String, Object>> results = null;  
  180.         Connection conn = null;  
  181.         try {  
  182.             conn = getConnection();  
  183.             QueryRunner qr = new QueryRunner();  
  184.             results = (List<Map<String, Object>>) qr.query(conn, sql, param,  
  185.                     new MapListHandler());  
  186.         } catch (SQLException e) {  
  187.             e.printStackTrace();  
  188.         } finally {  
  189.             Close(conn);  
  190.         }  
  191.         return results;  
  192.     }  
  193.   
  194.     /** 
  195.      * 执行sql语句 
  196.      *  
  197.      * @param sql 
  198.      *            被执行的sql语句 
  199.      * @return 受影响的行 
  200.      * @throws Exception 
  201.      * @author 宋立君 
  202.      * @date 2014年07月03日 
  203.      */  
  204.     public int execute(String sql) throws Exception {  
  205.         Connection conn = getConnection();  
  206.         int rows = 0;  
  207.         try {  
  208.             QueryRunner qr = new QueryRunner();  
  209.             rows = qr.update(conn, sql);  
  210.         } finally {  
  211.             Close(conn);  
  212.         }  
  213.         return rows;  
  214.     }  
  215.   
  216.     /** 
  217.      * 执行含参数的sql语句 
  218.      *  
  219.      * @param sql 
  220.      *            被执行的sql语句 
  221.      * @param params 
  222.      *            参数 
  223.      * @return 返回受影响的行 
  224.      * @throws Exception 
  225.      * @author 宋立君 
  226.      * @date 2014年07月03日 
  227.      */  
  228.     public int execute(String sql, Object[] params) throws Exception {  
  229.         Connection conn = getConnection();  
  230.         int rows = 0;  
  231.         try {  
  232.             QueryRunner qr = new QueryRunner();  
  233.             rows = qr.update(conn, sql, params);  
  234.         } finally {  
  235.             Close(conn);  
  236.         }  
  237.         return rows;  
  238.     }  
  239.   
  240.     /** 
  241.      * 关闭连接 
  242.      *  
  243.      * @param conn 
  244.      * @throws SQLException 
  245.      * @author 宋立君 
  246.      * @date 2014年07月03日 
  247.      */  
  248.     public void Close(Connection conn) throws SQLException {  
  249.         if (conn != null) {  
  250.             conn.close();  
  251.         }  
  252.         DbUtils.closeQuietly(conn);  
  253.     }  
  254.   
  255.     /** 
  256.      * 启动连接池 
  257.      *  
  258.      * @author 宋立君 
  259.      * @date 2014年07月03日 
  260.      */  
  261.     private void StartPool() {  
  262.         try {  
  263.             Class.forName(dri);  
  264.         } catch (ClassNotFoundException e1) {  
  265.             e1.printStackTrace();  
  266.         }  
  267.         if (connectionPool != null) {  
  268.             ShutdownPool();  
  269.         }  
  270.         try {  
  271.             connectionPool = new GenericObjectPool(null);  
  272.             ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(  
  273.                     url, username, password);  
  274.             PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(  
  275.                     connectionFactory, connectionPool, null, "SELECT 1", false,  
  276.                     true);  
  277.             Class.forName("org.apache.commons.dbcp.PoolingDriver");  
  278.             PoolingDriver driver = (PoolingDriver) DriverManager  
  279.                     .getDriver("jdbc:apache:commons:dbcp:");  
  280.             driver.registerPool(poolName, poolableConnectionFactory.getPool());  
  281.   
  282.         } catch (Exception e) {  
  283.             e.printStackTrace();  
  284.         }  
  285.         // 开启查询程序  
  286.         queryThread = new QueryThread(this);  
  287.         queryThread.start();  
  288.     }  
  289.   
  290.     /** 
  291.      * 关闭连接池 
  292.      *  
  293.      * @author 宋立君 
  294.      * @date 2014年07月03日 
  295.      */  
  296.     private void ShutdownPool() {  
  297.         try {  
  298.             PoolingDriver driver = (PoolingDriver) DriverManager  
  299.                     .getDriver("jdbc:apache:commons:dbcp:");  
  300.             driver.closePool(poolName);  
  301.             // 关闭定时查询  
  302.             queryThread.setStartQuery(false);  
  303.         } catch (SQLException e) {  
  304.             e.printStackTrace();  
  305.         }  
  306.     }  
  307.   
  308.     /** 
  309.      * 得到一个连接 
  310.      *  
  311.      * @return 
  312.      * @author 宋立君 
  313.      * @date 2014年07月03日 
  314.      */  
  315.     public synchronized Connection getConnection() {  
  316.         Connection conn = null;  
  317.         try {  
  318.             if (connectionPool == null)  
  319.                 StartPool();  
  320.             conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:"  
  321.                     + poolName);  
  322.         } catch (Exception e) {  
  323.             e.printStackTrace();  
  324.         }  
  325.         return conn;  
  326.     }  
  327. }  
  328.   
  329. /** 
  330.  * 当连接池启动后会自动定时查询数据库，防止数据库连接超时。 
  331.  *  
  332.  * @author 宋立君 
  333.  * @date 2014年07月03日 
  334.  */  
  335. class QueryThread extends Thread {  
  336.   
  337.     private DBUtil dbUtil = null;  
  338.     // 是否开启查询  
  339.     private boolean startQuery = true;  
  340.   
  341.     /** 
  342.      * 功能：对应的数据库连接。 
  343.      *  
  344.      * @author 宋立君 
  345.      * @date 2014年07月03日 
  346.      * @param dbUtil 
  347.      *            数据库连接 
  348.      */  
  349.     public QueryThread(DBUtil dbUtil) {  
  350.         this.dbUtil = dbUtil;  
  351.     }  
  352.   
  353.     public void run() {  
  354.         while (true) {  
  355.             try {  
  356.                 if (startQuery) {  
  357.                     this.dbUtil.query("select 1");  
  358.                 }  
  359.                 // System.out.println(startQuery+"   123");  
  360.             } catch (Exception e) {  
  361.                 e.printStackTrace();  
  362.             } finally {  
  363.                 try {  
  364.                     Thread.sleep(120000);  
  365.                 } catch (InterruptedException e) {  
  366.                     e.printStackTrace();  
  367.                 }  
  368.             }  
  369.         }  
  370.     }  
  371.   
  372.     public void setStartQuery(boolean startQuery) {  
  373.         // System.out.println("startQuery shut:"+startQuery);  
  374.         this.startQuery = startQuery;  
  375.     }  
  376. }  

二、DES加密和解密

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. package com.itjh.javaUtil;  
  2.   
  3. import java.io.UnsupportedEncodingException;  
  4. import java.security.InvalidKeyException;  
  5. import java.security.NoSuchAlgorithmException;  
  6. import java.security.SecureRandom;  
  7. import java.security.spec.InvalidKeySpecException;  
  8.   
  9. import javax.crypto.BadPaddingException;  
  10. import javax.crypto.Cipher;  
  11. import javax.crypto.IllegalBlockSizeException;  
  12. import javax.crypto.KeyGenerator;  
  13. import javax.crypto.NoSuchPaddingException;  
  14. import javax.crypto.SecretKey;  
  15. import javax.crypto.SecretKeyFactory;  
  16. import javax.crypto.spec.DESKeySpec;  
  17.   
  18. /** 
  19.  * DES加密和解密。 
  20.  *  
  21.  * @author 宋立君 
  22.  * @date 2014年07月03日 
  23.  */  
  24. public class DESUtil {  
  25.   
  26.     /** 安全密钥 */  
  27.     private String keyData = "ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstwxyz0123456789-_.";  
  28.   
  29.     /** 
  30.      * 功能：构造 
  31.      *  
  32.      * @author 宋立君 
  33.      * @date 2014年07月03日 
  34.      */  
  35.     public DESUtil() {  
  36.     }  
  37.   
  38.     /** 
  39.      * 功能：构造 
  40.      *  
  41.      * @author 宋立君 
  42.      * @date 2014年07月03日 
  43.      * @param keyData 
  44.      *            key 
  45.      */  
  46.     public DESUtil(String key) {  
  47.         this.keyData = key;  
  48.     }  
  49.   
  50.     /** 
  51.      * 功能：加密 (UTF-8) 
  52.      *  
  53.      * @author 宋立君 
  54.      * @date 2014年07月03日 
  55.      * @param source 
  56.      *            源字符串 
  57.      * @param charSet 
  58.      *            编码 
  59.      * @return String 
  60.      * @throws UnsupportedEncodingException 
  61.      *             编码异常 
  62.      */  
  63.     public String encrypt(String source) throws UnsupportedEncodingException {  
  64.         return encrypt(source, "UTF-8");  
  65.     }  
  66.   
  67.     /** 
  68.      *  
  69.      * 功能：解密 (UTF-8) 
  70.      *  
  71.      * @author 宋立君 
  72.      * @date 2014年07月03日 
  73.      * @param encryptedData 
  74.      *            被加密后的字符串 
  75.      * @return String 
  76.      * @throws UnsupportedEncodingException 
  77.      *             编码异常 
  78.      */  
  79.     public String decrypt(String encryptedData)  
  80.             throws UnsupportedEncodingException {  
  81.         return decrypt(encryptedData, "UTF-8");  
  82.     }  
  83.   
  84.     /** 
  85.      * 功能：加密 
  86.      *  
  87.      * @author 宋立君 
  88.      * @date 2014年07月03日 
  89.      * @param source 
  90.      *            源字符串 
  91.      * @param charSet 
  92.      *            编码 
  93.      * @return String 
  94.      * @throws UnsupportedEncodingException 
  95.      *             编码异常 
  96.      */  
  97.     public String encrypt(String source, String charSet)  
  98.             throws UnsupportedEncodingException {  
  99.         String encrypt = null;  
  100.         byte[] ret = encrypt(source.getBytes(charSet));  
  101.         encrypt = new String(Base64.encode(ret));  
  102.         return encrypt;  
  103.     }  
  104.   
  105.     /** 
  106.      *  
  107.      * 功能：解密 
  108.      *  
  109.      * @author 宋立君 
  110.      * @date 2014年07月03日 
  111.      * @param encryptedData 
  112.      *            被加密后的字符串 
  113.      * @param charSet 
  114.      *            编码 
  115.      * @return String 
  116.      * @throws UnsupportedEncodingException 
  117.      *             编码异常 
  118.      */  
  119.     public String decrypt(String encryptedData, String charSet)  
  120.             throws UnsupportedEncodingException {  
  121.         String descryptedData = null;  
  122.         byte[] ret = descrypt(Base64.decode(encryptedData.toCharArray()));  
  123.         descryptedData = new String(ret, charSet);  
  124.         return descryptedData;  
  125.     }  
  126.   
  127.     /** 
  128.      * 加密数据 用生成的密钥加密原始数据 
  129.      *  
  130.      * @param primaryData 
  131.      *            原始数据 
  132.      * @return byte[] 
  133.      * @author 宋立君 
  134.      * @date 2014年07月03日 
  135.      */  
  136.     private byte[] encrypt(byte[] primaryData) {  
  137.   
  138.         /** 取得安全密钥 */  
  139.         byte rawKeyData[] = getKey();  
  140.   
  141.         /** DES算法要求有一个可信任的随机数源 */  
  142.         SecureRandom sr = new SecureRandom();  
  143.   
  144.         /** 使用原始密钥数据创建DESKeySpec对象 */  
  145.         DESKeySpec dks = null;  
  146.         try {  
  147.             dks = new DESKeySpec(keyData.getBytes());  
  148.         } catch (InvalidKeyException e) {  
  149.             e.printStackTrace();  
  150.         }  
  151.   
  152.         /** 创建一个密钥工厂 */  
  153.         SecretKeyFactory keyFactory = null;  
  154.         try {  
  155.             keyFactory = SecretKeyFactory.getInstance("DES");  
  156.         } catch (NoSuchAlgorithmException e) {  
  157.             e.printStackTrace();  
  158.         }  
  159.   
  160.         /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */  
  161.         SecretKey key = null;  
  162.         try {  
  163.             key = keyFactory.generateSecret(dks);  
  164.         } catch (InvalidKeySpecException e) {  
  165.             e.printStackTrace();  
  166.         }  
  167.   
  168.         /** Cipher对象实际完成加密操作 */  
  169.         Cipher cipher = null;  
  170.         try {  
  171.             cipher = Cipher.getInstance("DES");  
  172.         } catch (NoSuchAlgorithmException e) {  
  173.             e.printStackTrace();  
  174.         } catch (NoSuchPaddingException e) {  
  175.             e.printStackTrace();  
  176.         }  
  177.   
  178.         /** 用密钥初始化Cipher对象 */  
  179.         try {  
  180.             cipher.init(Cipher.ENCRYPT_MODE, key, sr);  
  181.         } catch (InvalidKeyException e) {  
  182.             e.printStackTrace();  
  183.         }  
  184.   
  185.         /** 正式执行加密操作 */  
  186.         byte encryptedData[] = null;  
  187.         try {  
  188.             encryptedData = cipher.doFinal(primaryData);  
  189.         } catch (IllegalStateException e) {  
  190.             e.printStackTrace();  
  191.         } catch (IllegalBlockSizeException e) {  
  192.             e.printStackTrace();  
  193.         } catch (BadPaddingException e) {  
  194.             e.printStackTrace();  
  195.         }  
  196.   
  197.         /** 返回加密数据 */  
  198.         return encryptedData;  
  199.     }  
  200.   
  201.     /** 
  202.      * 用密钥解密数据 
  203.      *  
  204.      * @param encryptedData 
  205.      *            加密后的数据 
  206.      * @return byte[] 
  207.      * @author 宋立君 
  208.      * @date 2014年07月03日 
  209.      */  
  210.     private byte[] descrypt(byte[] encryptedData) {  
  211.   
  212.         /** DES算法要求有一个可信任的随机数源 */  
  213.         SecureRandom sr = new SecureRandom();  
  214.   
  215.         /** 取得安全密钥 */  
  216.         byte rawKeyData[] = getKey();  
  217.   
  218.         /** 使用原始密钥数据创建DESKeySpec对象 */  
  219.         DESKeySpec dks = null;  
  220.         try {  
  221.             dks = new DESKeySpec(keyData.getBytes());  
  222.         } catch (InvalidKeyException e) {  
  223.             e.printStackTrace();  
  224.         }  
  225.   
  226.         /** 创建一个密钥工厂 */  
  227.         SecretKeyFactory keyFactory = null;  
  228.         try {  
  229.             keyFactory = SecretKeyFactory.getInstance("DES");  
  230.         } catch (NoSuchAlgorithmException e) {  
  231.             e.printStackTrace();  
  232.         }  
  233.   
  234.         /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */  
  235.         SecretKey key = null;  
  236.         try {  
  237.             key = keyFactory.generateSecret(dks);  
  238.         } catch (InvalidKeySpecException e) {  
  239.             e.printStackTrace();  
  240.         }  
  241.   
  242.         /** Cipher对象实际完成加密操作 */  
  243.         Cipher cipher = null;  
  244.         try {  
  245.             cipher = Cipher.getInstance("DES");  
  246.         } catch (NoSuchAlgorithmException e) {  
  247.             e.printStackTrace();  
  248.         } catch (NoSuchPaddingException e) {  
  249.             e.printStackTrace();  
  250.         }  
  251.   
  252.         /** 用密钥初始化Cipher对象 */  
  253.         try {  
  254.             cipher.init(Cipher.DECRYPT_MODE, key, sr);  
  255.         } catch (InvalidKeyException e) {  
  256.             e.printStackTrace();  
  257.         }  
  258.   
  259.         /** 正式执行解密操作 */  
  260.         byte decryptedData[] = null;  
  261.         try {  
  262.             decryptedData = cipher.doFinal(encryptedData);  
  263.         } catch (IllegalStateException e) {  
  264.             e.printStackTrace();  
  265.         } catch (IllegalBlockSizeException e) {  
  266.             e.printStackTrace();  
  267.         } catch (BadPaddingException e) {  
  268.             e.printStackTrace();  
  269.         }  
  270.   
  271.         return decryptedData;  
  272.     }  
  273.   
  274.     /** 
  275.      * 取得安全密钥 此方法作废,因为每次key生成都不一样导致解密加密用的密钥都不一样， 从而导致Given final block not 
  276.      * properly padded错误. 
  277.      *  
  278.      * @return byte数组 
  279.      * @author 宋立君 
  280.      * @date 2014年07月03日 
  281.      */  
  282.     private byte[] getKey() {  
  283.   
  284.         /** DES算法要求有一个可信任的随机数源 */  
  285.         SecureRandom sr = new SecureRandom();  
  286.   
  287.         /** 为我们选择的DES算法生成一个密钥生成器对象 */  
  288.         KeyGenerator kg = null;  
  289.         try {  
  290.             kg = KeyGenerator.getInstance("DES");  
  291.         } catch (NoSuchAlgorithmException e) {  
  292.             e.printStackTrace();  
  293.         }  
  294.         kg.init(sr);  
  295.   
  296.         /** 生成密钥工具类 */  
  297.         SecretKey key = kg.generateKey();  
  298.   
  299.         /** 生成密钥byte数组 */  
  300.         byte rawKeyData[] = key.getEncoded();  
  301.   
  302.         return rawKeyData;  
  303.     }  
  304.   
  305. }  

Base64.java

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. package com.itjh.javaUtil;  
  2.   
  3. import java.io.*;  
  4.   
  5. /** 
  6.  * Base64 编码和解码。 
  7.  *  
  8.  * @author 宋立君 
  9.  * @date 2014年07月03日 
  10.  */  
  11. public class Base64 {  
  12.   
  13.     public Base64() {  
  14.     }  
  15.   
  16.     /** 
  17.      * 功能：编码字符串 
  18.      *  
  19.      * @author 宋立君 
  20.      * @date 2014年07月03日 
  21.      * @param data 
  22.      *            源字符串 
  23.      * @return String 
  24.      */  
  25.     public static String encode(String data) {  
  26.         return new String(encode(data.getBytes()));  
  27.     }  
  28.   
  29.     /** 
  30.      * 功能：解码字符串 
  31.      *  
  32.      * @author 宋立君 
  33.      * @date 2014年07月03日 
  34.      * @param data 
  35.      *            源字符串 
  36.      * @return String 
  37.      */  
  38.     public static String decode(String data) {  
  39.         return new String(decode(data.toCharArray()));  
  40.     }  
  41.   
  42.     /** 
  43.      * 功能：编码byte[] 
  44.      *  
  45.      * @author 宋立君 
  46.      * @date 2014年07月03日 
  47.      * @param data 
  48.      *            源 
  49.      * @return char[] 
  50.      */  
  51.     public static char[] encode(byte[] data) {  
  52.         char[] out = new char[((data.length + 2) / 3) * 4];  
  53.         for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {  
  54.             boolean quad = false;  
  55.             boolean trip = false;  
  56.   
  57.             int val = (0xFF & (int) data[i]);  
  58.             val <<= 8;  
  59.             if ((i + 1) < data.length) {  
  60.                 val |= (0xFF & (int) data[i + 1]);  
  61.                 trip = true;  
  62.             }  
  63.             val <<= 8;  
  64.             if ((i + 2) < data.length) {  
  65.                 val |= (0xFF & (int) data[i + 2]);  
  66.                 quad = true;  
  67.             }  
  68.             out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];  
  69.             val >>= 6;  
  70.             out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];  
  71.             val >>= 6;  
  72.             out[index + 1] = alphabet[val & 0x3F];  
  73.             val >>= 6;  
  74.             out[index + 0] = alphabet[val & 0x3F];  
  75.         }  
  76.         return out;  
  77.     }  
  78.   
  79.     /** 
  80.      * 功能：解码 
  81.      *  
  82.      * @author 宋立君 
  83.      * @date 2014年07月03日 
  84.      * @param data 
  85.      *            编码后的字符数组 
  86.      * @return byte[] 
  87.      */  
  88.     public static byte[] decode(char[] data) {  
  89.   
  90.         int tempLen = data.length;  
  91.         for (int ix = 0; ix < data.length; ix++) {  
  92.             if ((data[ix] > 255) || codes[data[ix]] < 0) {  
  93.                 --tempLen; // ignore non-valid chars and padding  
  94.             }  
  95.         }  
  96.         // calculate required length:  
  97.         // -- 3 bytes for every 4 valid base64 chars  
  98.         // -- plus 2 bytes if there are 3 extra base64 chars,  
  99.         // or plus 1 byte if there are 2 extra.  
  100.   
  101.         int len = (tempLen / 4) * 3;  
  102.         if ((tempLen % 4) == 3) {  
  103.             len += 2;  
  104.         }  
  105.         if ((tempLen % 4) == 2) {  
  106.             len += 1;  
  107.   
  108.         }  
  109.         byte[] out = new byte[len];  
  110.   
  111.         int shift = 0; // # of excess bits stored in accum  
  112.         int accum = 0; // excess bits  
  113.         int index = 0;  
  114.   
  115.         // we now go through the entire array (NOT using the 'tempLen' value)  
  116.         for (int ix = 0; ix < data.length; ix++) {  
  117.             int value = (data[ix] > 255) ? -1 : codes[data[ix]];  
  118.   
  119.             if (value >= 0) { // skip over non-code  
  120.                 accum <<= 6; // bits shift up by 6 each time thru  
  121.                 shift += 6; // loop, with new bits being put in  
  122.                 accum |= value; // at the bottom.  
  123.                 if (shift >= 8) { // whenever there are 8 or more shifted in,  
  124.                     shift -= 8; // write them out (from the top, leaving any  
  125.                     out[index++] = // excess at the bottom for next iteration.  
  126.                     (byte) ((accum >> shift) & 0xff);  
  127.                 }  
  128.             }  
  129.         }  
  130.   
  131.         // if there is STILL something wrong we just have to throw up now!  
  132.         if (index != out.length) {  
  133.             throw new Error("Miscalculated data length (wrote " + index  
  134.                     + " instead of " + out.length + ")");  
  135.         }  
  136.   
  137.         return out;  
  138.     }  
  139.   
  140.     /** 
  141.      * 功能：编码文件 
  142.      *  
  143.      * @author 宋立君 
  144.      * @date 2014年07月03日 
  145.      * @param file 
  146.      *            源文件 
  147.      */  
  148.     public static void encode(File file) throws IOException {  
  149.         if (!file.exists()) {  
  150.             System.exit(0);  
  151.         }  
  152.   
  153.         else {  
  154.             byte[] decoded = readBytes(file);  
  155.             char[] encoded = encode(decoded);  
  156.             writeChars(file, encoded);  
  157.         }  
  158.         file = null;  
  159.     }  
  160.   
  161.     /** 
  162.      * 功能：解码文件。 
  163.      *  
  164.      * @author 宋立君 
  165.      * @date 2014年07月03日 
  166.      * @param file 
  167.      *            源文件 
  168.      * @throws IOException 
  169.      */  
  170.     public static void decode(File file) throws IOException {  
  171.         if (!file.exists()) {  
  172.             System.exit(0);  
  173.         } else {  
  174.             char[] encoded = readChars(file);  
  175.             byte[] decoded = decode(encoded);  
  176.             writeBytes(file, decoded);  
  177.         }  
  178.         file = null;  
  179.     }  
  180.   
  181.     //  
  182.     // code characters for values 0..63  
  183.     //  
  184.     private static char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="  
  185.             .toCharArray();  
  186.   
  187.     //  
  188.     // lookup table for converting base64 characters to value in range 0..63  
  189.     //  
  190.     private static byte[] codes = new byte[256];  
  191.     static {  
  192.         for (int i = 0; i < 256; i++) {  
  193.             codes[i] = -1;  
  194.             // LoggerUtil.debug(i + "&" + codes[i] + " ");  
  195.         }  
  196.         for (int i = 'A'; i <= 'Z'; i++) {  
  197.             codes[i] = (byte) (i - 'A');  
  198.             // LoggerUtil.debug(i + "&" + codes[i] + " ");  
  199.         }  
  200.   
  201.         for (int i = 'a'; i <= 'z'; i++) {  
  202.             codes[i] = (byte) (26 + i - 'a');  
  203.             // LoggerUtil.debug(i + "&" + codes[i] + " ");  
  204.         }  
  205.         for (int i = '0'; i <= '9'; i++) {  
  206.             codes[i] = (byte) (52 + i - '0');  
  207.             // LoggerUtil.debug(i + "&" + codes[i] + " ");  
  208.         }  
  209.         codes['+'] = 62;  
  210.         codes['/'] = 63;  
  211.     }  
  212.   
  213.     private static byte[] readBytes(File file) throws IOException {  
  214.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  215.         byte[] b = null;  
  216.         InputStream fis = null;  
  217.         InputStream is = null;  
  218.         try {  
  219.             fis = new FileInputStream(file);  
  220.             is = new BufferedInputStream(fis);  
  221.             int count = 0;  
  222.             byte[] buf = new byte[16384];  
  223.             while ((count = is.read(buf)) != -1) {  
  224.                 if (count > 0) {  
  225.                     baos.write(buf, 0, count);  
  226.                 }  
  227.             }  
  228.             b = baos.toByteArray();  
  229.   
  230.         } finally {  
  231.             try {  
  232.                 if (fis != null)  
  233.                     fis.close();  
  234.                 if (is != null)  
  235.                     is.close();  
  236.                 if (baos != null)  
  237.                     baos.close();  
  238.             } catch (Exception e) {  
  239.                 System.out.println(e);  
  240.             }  
  241.         }  
  242.   
  243.         return b;  
  244.     }  
  245.   
  246.     private static char[] readChars(File file) throws IOException {  
  247.         CharArrayWriter caw = new CharArrayWriter();  
  248.         Reader fr = null;  
  249.         Reader in = null;  
  250.         try {  
  251.             fr = new FileReader(file);  
  252.             in = new BufferedReader(fr);  
  253.             int count = 0;  
  254.             char[] buf = new char[16384];  
  255.             while ((count = in.read(buf)) != -1) {  
  256.                 if (count > 0) {  
  257.                     caw.write(buf, 0, count);  
  258.                 }  
  259.             }  
  260.   
  261.         } finally {  
  262.             try {  
  263.                 if (caw != null)  
  264.                     caw.close();  
  265.                 if (in != null)  
  266.                     in.close();  
  267.                 if (fr != null)  
  268.                     fr.close();  
  269.             } catch (Exception e) {  
  270.                 System.out.println(e);  
  271.             }  
  272.         }  
  273.   
  274.         return caw.toCharArray();  
  275.     }  
  276.   
  277.     private static void writeBytes(File file, byte[] data) throws IOException {  
  278.         OutputStream fos = null;  
  279.         OutputStream os = null;  
  280.         try {  
  281.             fos = new FileOutputStream(file);  
  282.             os = new BufferedOutputStream(fos);  
  283.             os.write(data);  
  284.   
  285.         } finally {  
  286.             try {  
  287.                 if (os != null)  
  288.                     os.close();  
  289.                 if (fos != null)  
  290.                     fos.close();  
  291.             } catch (Exception e) {  
  292.                 System.out.println(e);  
  293.             }  
  294.         }  
  295.     }  
  296.   
  297.     private static void writeChars(File file, char[] data) throws IOException {  
  298.         Writer fos = null;  
  299.         Writer os = null;  
  300.         try {  
  301.             fos = new FileWriter(file);  
  302.             os = new BufferedWriter(fos);  
  303.             os.write(data);  
  304.   
  305.         } finally {  
  306.             try {  
  307.                 if (os != null)  
  308.                     os.close();  
  309.                 if (fos != null)  
  310.                     fos.close();  
  311.             } catch (Exception e) {  
  312.                 e.printStackTrace();  
  313.             }  
  314.         }  
  315.     }  
  316.   
  317.     // /////////////////////////////////////////////////  
  318.     // end of test code.  
  319.     // /////////////////////////////////////////////////  
  320.   
  321. }  

三、ExcelUtil工具类

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. package com.itjh.javaUtil;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8. import java.io.OutputStream;  
  9. import java.text.DecimalFormat;  
  10. import java.util.LinkedList;  
  11. import java.util.List;  
  12.   
  13. import javax.servlet.http.HttpServletResponse;  
  14.   
  15. import org.apache.poi.hssf.usermodel.HSSFCell;  
  16. import org.apache.poi.hssf.usermodel.HSSFRichTextString;  
  17. import org.apache.poi.hssf.usermodel.HSSFRow;  
  18. import org.apache.poi.hssf.usermodel.HSSFSheet;  
  19. import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
  20. import org.apache.poi.openxml4j.exceptions.InvalidFormatException;  
  21. import org.apache.poi.ss.usermodel.Cell;  
  22. import org.apache.poi.ss.usermodel.DateUtil;  
  23. import org.apache.poi.ss.usermodel.Row;  
  24. import org.apache.poi.ss.usermodel.Sheet;  
  25. import org.apache.poi.ss.usermodel.Workbook;  
  26. import org.apache.poi.ss.usermodel.WorkbookFactory;  
  27.   
  28. /** 
  29.  * 封装对excel的操作，包括本地读写excel和流中输出excel,支持office 2007。<br/> 
  30.  * 依赖于poi-3.9-20121203.jar,poi-ooxml-3.9-20121203.jar,poi-ooxml-schemas-3.9- 
  31.  * 20121203.jar,dom4j-1.6.1.jar<br/> 
  32.  * 有参构造函数参数为excel的全路径<br/> 
  33.  *  
  34.  * @author 宋立君 
  35.  * @date 2014年07月03日 
  36.  */  
  37. public class ExcelUtil {  
  38.   
  39.     // excel文件路径  
  40.     private String path = "";  
  41.   
  42.     // 写入excel时，是否自动扩展列宽度来符合内容。  
  43.     private boolean autoColumnWidth = false;  
  44.   
  45.     /** 
  46.      * 无参构造函数 默认 
  47.      */  
  48.     public ExcelUtil() {  
  49.     }  
  50.   
  51.     /** 
  52.      * 有参构造函数 
  53.      *  
  54.      * @param path 
  55.      *            excel路径 
  56.      */  
  57.     public ExcelUtil(String path) {  
  58.         this.path = path;  
  59.     }  
  60.   
  61.     /** 
  62.      * 读取某个工作簿上的所有单元格的值。 
  63.      *  
  64.      * @param sheetOrder 
  65.      *            工作簿序号，从0开始。 
  66.      * @return List<Object[]> 所有单元格的值。 
  67.      * @throws IOException 
  68.      *             加载excel文件IO异常。 
  69.      * @throws FileNotFoundException 
  70.      *             excel文件没有找到异常。 
  71.      * @throws InvalidFormatException 
  72.      * @author 宋立君 
  73.      * @date 2014年07月03日 
  74.      */  
  75.     public List<Object[]> read(int sheetOrder) throws FileNotFoundException,  
  76.             IOException, InvalidFormatException {  
  77.         FileInputStream fis = new FileInputStream(path);  
  78.         Workbook workbook = WorkbookFactory.create(fis);  
  79.         if (fis != null) {  
  80.             fis.close();  
  81.         }  
  82.         Sheet sheet = workbook.getSheetAt(sheetOrder);  
  83.         // 用来记录excel值  
  84.         List<Object[]> valueList = new LinkedList<Object[]>();  
  85.         // 循环遍历每一行、每一列。  
  86.         for (Row row : sheet) {  
  87.             // 每一行  
  88.             Object[] rowObject = null;  
  89.             for (Cell cell : row) {  
  90.                 // cell.getCellType是获得cell里面保存的值的type  
  91.                 switch (cell.getCellType()) {  
  92.                 case Cell.CELL_TYPE_BOOLEAN:  
  93.                     // 得到Boolean对象的方法  
  94.                     rowObject = CollectionUtil.addObjectToArray(rowObject,  
  95.                             cell.getBooleanCellValue());  
  96.                     break;  
  97.                 case Cell.CELL_TYPE_NUMERIC:  
  98.                     // 先看是否是日期格式  
  99.                     if (DateUtil.isCellDateFormatted(cell)) {  
  100.                         // 读取日期格式  
  101.                         rowObject = CollectionUtil.addObjectToArray(rowObject,  
  102.                                 cell.getDateCellValue());  
  103.                     } else {  
  104.                         DecimalFormat df = new DecimalFormat();  
  105.                         // 单元格的值,替换掉,  
  106.                         String value = df.format(cell.getNumericCellValue())  
  107.                                 .replace(",", "");  
  108.                         // 读取数字  
  109.                         rowObject = CollectionUtil.addObjectToArray(rowObject,  
  110.                                 value);  
  111.                     }  
  112.                     break;  
  113.                 case Cell.CELL_TYPE_FORMULA:  
  114.                     // 读取公式  
  115.                     rowObject = CollectionUtil.addObjectToArray(rowObject,  
  116.                             cell.getCellFormula());  
  117.                     break;  
  118.                 case Cell.CELL_TYPE_STRING:  
  119.                     // 读取String  
  120.                     rowObject = CollectionUtil.addObjectToArray(rowObject, cell  
  121.                             .getRichStringCellValue().toString());  
  122.                     break;  
  123.                 }  
  124.             }  
  125.             // 将这行添加到list。  
  126.             valueList.add(rowObject);  
  127.         }  
  128.         return valueList;  
  129.     }  
  130.   
  131.     /** 
  132.      * 读取某个工作簿上的某个单元格的值。 
  133.      *  
  134.      * @param sheetOrder 
  135.      *            工作簿序号,从0开始。 
  136.      * @param colum 
  137.      *            列数 从1开始 
  138.      * @param row 
  139.      *            行数 从1开始 
  140.      * @return 单元格的值。 
  141.      * @throws Exception 
  142.      *             加载excel异常。 
  143.      * @author 宋立君 
  144.      * @date 2014年07月03日 
  145.      */  
  146.     public String read(int sheetOrder, int colum, int row) throws Exception {  
  147.         FileInputStream fis = new FileInputStream(path);  
  148.         Workbook workbook = WorkbookFactory.create(fis);  
  149.         if (fis != null) {  
  150.             fis.close();  
  151.         }  
  152.         Sheet sheet = workbook.getSheetAt(sheetOrder);  
  153.         Row rows = sheet.getRow(row - 1);  
  154.         Cell cell = rows.getCell(colum - 1);  
  155.         String content = cell.getStringCellValue();  
  156.         return content;  
  157.     }  
  158.   
  159.     /** 
  160.      * 在指定的工作簿、行、列书写值。 
  161.      *  
  162.      * @param sheetOrder 
  163.      *            工作簿序号，基于0. 
  164.      * @param colum 
  165.      *            列 基于1 
  166.      * @param row 
  167.      *            行 基于1 
  168.      * @param content 
  169.      *            将要被书写的内容。 
  170.      * @throws Exception 
  171.      *             书写后保存异常。 
  172.      * @author 宋立君 
  173.      * @date 2014年07月03日 
  174.      */  
  175.     public void write(int sheetOrder, int colum, int row, String content)  
  176.             throws Exception {  
  177.         FileInputStream fis = new FileInputStream(path);  
  178.         Workbook workbook = WorkbookFactory.create(fis);  
  179.         if (fis != null) {  
  180.             fis.close();  
  181.         }  
  182.         Sheet sheet = workbook.getSheetAt(sheetOrder);  
  183.         Row rows = sheet.createRow(row - 1);  
  184.         Cell cell = rows.createCell(colum - 1);  
  185.         cell.setCellValue(content);  
  186.         FileOutputStream fileOut = new FileOutputStream(path);  
  187.         workbook.write(fileOut);  
  188.         fileOut.close();  
  189.   
  190.     }  
  191.   
  192.     /** 
  193.      * 得到一个工作区最后一条记录的序号，相当于这个工作簿共多少行数据。 
  194.      *  
  195.      * @param sheetOrder 
  196.      *            工作区序号 
  197.      * @return int 序号。 
  198.      * @throws IOException 
  199.      *             根据excel路径加载excel异常。 
  200.      * @throws InvalidFormatException 
  201.      * @author 宋立君 
  202.      * @date 2014年07月03日 
  203.      */  
  204.     public int getSheetLastRowNum(int sheetOrder) throws IOException,  
  205.             InvalidFormatException {  
  206.         FileInputStream fis = new FileInputStream(path);  
  207.         Workbook workbook = WorkbookFactory.create(fis);  
  208.         if (fis != null) {  
  209.             fis.close();  
  210.         }  
  211.         Sheet sheet = workbook.getSheetAt(sheetOrder);  
  212.         return sheet.getLastRowNum();  
  213.     }  
  214.   
  215.     /** 
  216.      * 在磁盘生成一个含有内容的excel,路径为path属性 
  217.      *  
  218.      * @param sheetName 
  219.      *            导出的sheet名称 
  220.      * @param fieldName 
  221.      *            列名数组 
  222.      * @param data 
  223.      *            数据组 
  224.      * @throws IOException 
  225.      * @author 宋立君 
  226.      * @date 2014年07月03日 
  227.      */  
  228.     public void makeExcel(String sheetName, String[] fieldName,  
  229.             List<Object[]> data) throws IOException {  
  230.         // 在内存中生成工作薄  
  231.         HSSFWorkbook workbook = makeWorkBook(sheetName, fieldName, data);  
  232.         // 截取文件夹路径  
  233.         String filePath = path.substring(0, path.lastIndexOf("\\"));  
  234.         // 如果路径不存在，创建路径  
  235.         File file = new File(filePath);  
  236.         // System.out.println(path+"-----------"+file.exists());  
  237.         if (!file.exists())  
  238.             file.mkdirs();  
  239.         FileOutputStream fileOut = new FileOutputStream(path);  
  240.         workbook.write(fileOut);  
  241.         fileOut.close();  
  242.     }  
  243.   
  244.     /** 
  245.      * 在输出流中导出excel。 
  246.      *  
  247.      * @param excelName 
  248.      *            导出的excel名称 包括扩展名 
  249.      * @param sheetName 
  250.      *            导出的sheet名称 
  251.      * @param fieldName 
  252.      *            列名数组 
  253.      * @param data 
  254.      *            数据组 
  255.      * @param response 
  256.      *            response 
  257.      * @throws IOException 
  258.      *             转换流时IO错误 
  259.      * @author 宋立君 
  260.      * @date 2014年07月03日 
  261.      */  
  262.     public void makeStreamExcel(String excelName, String sheetName,  
  263.             String[] fieldName, List<Object[]> data,  
  264.             HttpServletResponse response) throws IOException {  
  265.         OutputStream os = null;  
  266.         response.reset(); // 清空输出流  
  267.         os = response.getOutputStream(); // 取得输出流  
  268.         response.setHeader("Content-disposition", "attachment; filename="  
  269.                 + new String(excelName.getBytes(), "ISO-8859-1")); // 设定输出文件头  
  270.         response.setContentType("application/msexcel"); // 定义输出类型  
  271.         // 在内存中生成工作薄  
  272.         HSSFWorkbook workbook = makeWorkBook(sheetName, fieldName, data);  
  273.         os.flush();  
  274.         workbook.write(os);  
  275.     }  
  276.   
  277.     /** 
  278.      * 根据条件，生成工作薄对象到内存。 
  279.      *  
  280.      * @param sheetName 
  281.      *            工作表对象名称 
  282.      * @param fieldName 
  283.      *            首列列名称 
  284.      * @param data 
  285.      *            数据 
  286.      * @return HSSFWorkbook 
  287.      * @author 宋立君 
  288.      * @date 2014年07月03日 
  289.      */  
  290.     private HSSFWorkbook makeWorkBook(String sheetName, String[] fieldName,  
  291.             List<Object[]> data) {  
  292.         // 用来记录最大列宽,自动调整列宽。  
  293.         Integer collength[] = new Integer[fieldName.length];  
  294.   
  295.         // 产生工作薄对象  
  296.         HSSFWorkbook workbook = new HSSFWorkbook();  
  297.         // 产生工作表对象  
  298.         HSSFSheet sheet = workbook.createSheet();  
  299.         // 为了工作表能支持中文,设置字符集为UTF_16  
  300.         workbook.setSheetName(0, sheetName);  
  301.         // 产生一行  
  302.         HSSFRow row = sheet.createRow(0);  
  303.         // 产生单元格  
  304.         HSSFCell cell;  
  305.         // 写入各个字段的名称  
  306.         for (int i = 0; i < fieldName.length; i++) {  
  307.             // 创建第一行各个字段名称的单元格  
  308.             cell = row.createCell((short) i);  
  309.             // 设置单元格内容为字符串型  
  310.             cell.setCellType(HSSFCell.CELL_TYPE_STRING);  
  311.             // 为了能在单元格中输入中文,设置字符集为UTF_16  
  312.             // cell.setEncoding(HSSFCell.ENCODING_UTF_16);  
  313.             // 给单元格内容赋值  
  314.             cell.setCellValue(new HSSFRichTextString(fieldName[i]));  
  315.             // 初始化列宽  
  316.             collength[i] = fieldName[i].getBytes().length;  
  317.         }  
  318.         // 临时单元格内容  
  319.         String tempCellContent = "";  
  320.         // 写入各条记录,每条记录对应excel表中的一行  
  321.         for (int i = 0; i < data.size(); i++) {  
  322.             Object[] tmp = data.get(i);  
  323.             // 生成一行  
  324.             row = sheet.createRow(i + 1);  
  325.             for (int j = 0; j < tmp.length; j++) {  
  326.                 cell = row.createCell((short) j);  
  327.                 // 设置单元格字符类型为String  
  328.                 cell.setCellType(HSSFCell.CELL_TYPE_STRING);  
  329.                 tempCellContent = (tmp[j] == null) ? "" : tmp[j].toString();  
  330.                 cell.setCellValue(new HSSFRichTextString(tempCellContent));  
  331.   
  332.                 // 如果自动调整列宽度。  
  333.                 if (autoColumnWidth) {  
  334.                     if (j >= collength.length) { // 标题列数小于数据列数时。  
  335.                         collength = CollectionUtil.addObjectToArray(collength,  
  336.                                 tempCellContent.getBytes().length);  
  337.                     } else {  
  338.                         // 如果这个内容的宽度大于之前最大的，就按照这个设置宽度。  
  339.                         if (collength[j] < tempCellContent.getBytes().length) {  
  340.                             collength[j] = tempCellContent.getBytes().length;  
  341.                         }  
  342.                     }  
  343.                 }  
  344.             }  
  345.         }  
  346.   
  347.         // 自动调整列宽度。  
  348.         if (autoColumnWidth) {  
  349.             // 调整列为这列文字对应的最大宽度。  
  350.             for (int i = 0; i < fieldName.length; i++) {  
  351.                 sheet.setColumnWidth(i, collength[i] * 2 * 256);  
  352.             }  
  353.         }  
  354.         return workbook;  
  355.     }  
  356.   
  357.     /** 
  358.      * 功能：设置写入excel时，是否自动扩展列宽度来符合内容，默认为false。 
  359.      *  
  360.      * @author 宋立君 
  361.      * @date 2014年07月03日 
  362.      * @param autoColumnWidth 
  363.      *            true或者false 
  364.      */  
  365.     public void setAutoColumnWidth(boolean autoColumnWidth) {  
  366.         this.autoColumnWidth = autoColumnWidth;  
  367.     }  
  368. } 

posted on 2015-10-09 12:06  菜鸟Z  阅读(103)  评论(0)  编辑  收藏  举报

导航