JAVA常用方法

 

    /**
     * 將某個日期以固定格式轉化成字符串
     *
     * @param date
     * @return String
     */
    public static String dateToStr(java.util.Date date)
    {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = sdf.format(date);
        return str;
    }



  /**
     * 判斷任意一個整數是否素數
     *
     * @param n
     * @return boolean
     */
    public static boolean isPrimes(int n)
    {
        for (int i = 2; i <= Math.sqrt(n); i++)
        {
            if (n % i == 0)
            {
                return false;
            }
        }
        return true;
    }


/**
     * 獲得任意一個整數的階乘，遞歸
      *
     * @param n
     * @return n!
     */
    public static int factorial(int n)
    {
        if (n == 1)
        {
            return 1;
        }
        return n * factorial(n - 1);
    }

  /**
     * 將指定byte數組以16進制的形式打印到控制檯
     *
     * @param hint
     *            String
     * @param b
     *            byte[]
     * @return void
     */
    public static void printHexString(String hint, byte[] b)
    {
        System.out.print(hint);
        for (int i = 0; i < b.length; i++)
        {
            String hex = Integer.toHexString(b & 0xFF);
            if (hex.length() == 1)
            {
                hex = '0' + hex;
            }
            System.out.print(hex.toUpperCase() + " ");
        }
        System.out.println("");
    }


package net.java2000.tools;

/**
* Title:        Java Bean 工具
* @version 1.0
*/
import java.util.*;
import java.util.regex.Pattern;

public class StrTools {
  /**
   * 分割字符串
   *
   * @param str String 原始字符串
   * @param splitsign String 分隔符
   * @return String[] 分割後的字符串數組
   */
  @SuppressWarnings("unchecked")
  public static String[] split(String str, String splitsign) {
    int index;
    if (str == null || splitsign == null)
      return null;
    ArrayList al = new ArrayList();
    while ((index = str.indexOf(splitsign)) != -1) {
      al.add(str.substring(0, index));
      str = str.substring(index + splitsign.length());
    }
    al.add(str);
    return (String[]) al.toArray(new String[0]);
  }

  /**
   * 替換字符串
   *
   * @param from String 原始字符串
   * @param to String 目標字符串
   * @param source String 母字符串
   * @return String 替換後的字符串
   */
  public static String replace(String from, String to, String source) {
    if (source == null || from == null || to == null)
      return null;
    StringBuffer bf = new StringBuffer("");
    int index = -1;
    while ((index = source.indexOf(from)) != -1) {
      bf.append(source.substring(0, index) + to);
      source = source.substring(index + from.length());
      index = source.indexOf(from);
    }
    bf.append(source);
    return bf.toString();
  }

  /**
   * 替換字符串，能能夠在HTML頁面上直接顯示(替換雙引號和小於號)
   *
   * @param str String 原始字符串
   * @return String 替換後的字符串
   */
  public static String htmlencode(String str) {
    if (str == null) {
      return null;
    }

    return replace("\"", "&quot;", replace("<", "&lt;", str));
  }

  /**
   * 替換字符串，將被編碼的轉換成原始碼（替換成雙引號和小於號）
   *
   * @param str String
   * @return String
   */
  public static String htmldecode(String str) {
    if (str == null) {
      return null;
    }

    return replace("&quot;", "\"", replace("&lt;", "<", str));
  }

  private static final String _BR = "<br/>";

  /**
   * 在頁面上直接顯示文本內容，替換小於號，空格，回車，TAB
   *
   * @param str String 原始字符串
   * @return String 替換後的字符串
   */
  public static String htmlshow(String str) {
    if (str == null) {
      return null;
    }

    str = replace("<", "&lt;", str);
    str = replace(" ", "&nbsp;", str);
    str = replace("\r\n", _BR, str);
    str = replace("\n", _BR, str);
    str = replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;", str);
    return str;
  }

  /**
   * 返回指定字節長度的字符串
   *
   * @param str String 字符串
   * @param length int 指定長度
   * @return String 返回的字符串
   */
  public static String toLength(String str, int length) {
    if (str == null) {
      return null;
    }
    if (length <= 0) {
      return "";
    }
    try {
      if (str.getBytes("GBK").length <= length) {
        return str;
      }
    } catch (Exception ex) {
    }
    StringBuffer buff = new StringBuffer();

    int index = 0;
    char c;
    length -= 3;
    while (length > 0) {
      c = str.charAt(index);
      if (c < 128) {
        length--;
      } else {
        length--;
        length--;
      }
      buff.append(c);
      index++;
    }
    buff.append("...");
    return buff.toString();
  }

  /**
   * 判斷是否爲整數
   *
   * @param str 傳入的字符串
   * @return 是整數返回true,否則返回false
   */
  public static boolean isInteger(String str) {
    Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
    return pattern.matcher(str).matches();
  }

  /**
   * 判斷是否爲浮點數，包括double和float
   *
   * @param str 傳入的字符串
   * @return 是浮點數返回true,否則返回false
   */
  public static boolean isDouble(String str) {
    Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
    return pattern.matcher(str).matches();
  }

  /**
   * 判斷輸入的字符串是否符合Email樣式.
   *
   * @param str 傳入的字符串
   * @return 是Email樣式返回true,否則返回false
   */
  public static boolean isEmail(String str) {
    Pattern pattern = Pattern.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
    return pattern.matcher(str).matches();
  }

  /**
   * 判斷輸入的字符串是否爲純漢字
   *
   * @param str 傳入的字符竄
   * @return 如果是純漢字返回true,否則返回false
   */
  public static boolean isChinese(String str) {
    Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
    return pattern.matcher(str).matches();
  }

  /**
   * 是否爲空白,包括null和""
   *
   * @param str
   * @return
   */
  public static boolean isBlank(String str) {
    return str == null || str.trim().length() == 0;
  }

  /**
   * 判斷是否爲質數
   *
   * @param x
   * @return
   */
  public static boolean isPrime(int x) {
    if (x <= 7) {
      if (x == 2 || x == 3 || x == 5 || x == 7)
        return true;
    }
    int c = 7;
    if (x % 2 == 0)
      return false;
    if (x % 3 == 0)
      return false;
    if (x % 5 == 0)
      return false;
    int end = (int) Math.sqrt(x);
    while (c <= end) {
      if (x % c == 0) {
        return false;
      }
      c += 4;
      if (x % c == 0) {
        return false;
      }
      c += 2;
      if (x % c == 0) {
        return false;
      }
      c += 4;
      if (x % c == 0) {
        return false;
      }
      c += 2;
      if (x % c == 0) {
        return false;
      }
      c += 4;
      if (x % c == 0) {
        return false;
      }
      c += 6;
      if (x % c == 0) {
        return false;
      }
      c += 2;
      if (x % c == 0) {
        return false;
      }
      c += 6;
    }
    return true;
  }

  public static void main(String[] args) {
    String[] numbers = { "12345", "-12345", "123.45", "-123.45", ".12345", "-.12345", "a12345", "12345a", "123.a45" };
    for (String str : numbers) {
      System.out.println(str + "=" + isInteger(str) + " " + isDouble(str));
    }

    String[] emails = { "[email protected]", "[email protected]", "[email protected]" };
    for (String str : emails) {
      System.out.println(str + "=" + isEmail(str));
    }
    String[] chineses = { "中國", "1中國", "中國1", "1中國2", "中1國" };
    for (String str : chineses) {
      System.out.println(str + "=" + isChinese(str));
    }
  }
}




/* * Db.java
Created on 2007年8月20日, 上午 8:37
*/
import java.io.*;
import java.sql.*;
import java.util.Properties;
public class Db {
    private String driver;
    private String url;
    private String user;
    private String password;
    private Connection conn;
    private Statement stm;
    private ResultSet rs;
    public Db(){
        this("DBConf.properties");
    }
    public Db(String conf) {
        loadProperties(conf);
        setConn();
    }
    public Connection getConn(){
        return this.conn;
    }
  //handle the properties file to get the informations for connection
    private void loadProperties(String conf){
        Properties props = new Properties();
        try {
            props.load(new FileInputStream(conf));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.driver = props.getProperty("driver");
        this.url = props.getProperty("url");
        this.user = props.getProperty("user");
        this.password = props.getProperty("password");
    }
    //implement the Connection
    private void setConn(){
        try {
            Class.forName(driver);
            this.conn = DriverManager.getConnection(url,user,password);
        } catch(ClassNotFoundException classnotfoundexception) {
              classnotfoundexception.printStackTrace();
            System.err.println("db: " + classnotfoundexception.getMessage());
        } catch(SQLException sqlexception) {
            System.err.println("db.getconn(): " + sqlexception.getMessage());
        }
    }
       public void doInsert(String sql) {
        try {
            Statement statement = conn.createStatement();
            int i = stm.executeUpdate(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeInset:" + sqlexception.getMessage());
        }
    }
    public void doDelete(String sql) {
        try {
            stm = conn.createStatement();
            int i = stm.executeUpdate(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeDelete:" + sqlexception.getMessage());
        }
    }
    public void doUpdate(String sql) {
        try {
            stm = conn.createStatement();
            int i = stm.executeUpdate(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeUpdate:" + sqlexception.getMessage());
        }
    }

    public ResultSet doSelect(String sql) {
        try {
stm = conn.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,java.sql.ResultSet.CONCUR_READ_ONLY);
            rs = stm.executeQuery(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeQuery: " + sqlexception.getMessage());
        }
        return rs;
    }
    public static void main(String[] args){
        try{
            Db db = new Db();
            Connection conn = db.getConn();
            if(conn != null && !conn.isClosed()) {
                System.out.println("連結成功");
                ResultSet rs = db.doSelect("select * from content");
                while(rs.next()){
                    System.out.println(rs.getString(1)+":"+rs.getString(2)+":"+rs.getString(3));
                  }
                rs.close();
                conn.close();
            }
        }catch(SQLException e) {
            e.printStackTrace();
        }
    } 
}





DBConf.properties:
driver=oracle.jdbc.driver.OracleDriver
url=jdbcracle:thintdt151:1521:train
user=XX
password=XX



/**
     * 人民幣轉成大寫
     *
     * @param value
     * @return String
     */
    public static String hangeToBig(double value)
    {
        char[] hunit = { '拾', '佰', '仟' }; // 段內位置表示
        char[] vunit = { '萬', '億' }; // 段名錶示
        char[] digit = { '零', '壹', '貳', '叄', '肆', '伍', '陸', '柒', '捌', '玖' }; // 數字表示
        long midVal = (long) (value * 100); // 轉化成整形
        String valStr = String.valueOf(midVal); // 轉化成字符串

        String head = valStr.substring(0, valStr.length() - 2); // 取整數部分
        String rail = valStr.substring(valStr.length() - 2); // 取小數部分

        String prefix = ""; // 整數部分轉化的結果
        String suffix = ""; // 小數部分轉化的結果
        // 處理小數點後面的數
        if (rail.equals("00"))
        { // 如果小數部分爲0
            suffix = "整";
        }
        else
        {
            suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否則把角分轉化出來
        }
        // 處理小數點前面的數
        char[] chDig = head.toCharArray(); // 把整數部分轉化成字符數組
        char zero = '0'; // 標誌'0'表示出現過0
        byte zeroSerNum = 0; // 連續出現0的次數
        for (int i = 0; i < chDig.length; i++)
        { // 循環處理每個數字
            int idx = (chDig.length - i - 1) % 4; // 取段內位置
            int vidx = (chDig.length - i - 1) / 4; // 取段位置
            if (chDig == '0')
            { // 如果當前字符是0
                zeroSerNum++; // 連續0次數遞增
                if (zero == '0')
                { // 標誌
                    zero = digit[0];
                }
                else if (idx == 0 && vidx > 0 && zeroSerNum < 4)
                {
                    prefix += vunit[vidx - 1];
                    zero = '0';
                }
                continue;
            }
            zeroSerNum = 0; // 連續0次數清零
            if (zero != '0')
            { // 如果標誌不爲0,則加上,例如萬,億什麼的
                prefix += zero;
                zero = '0';
            }
            prefix += digit[chDig - '0']; // 轉化該數字表示
            if (idx > 0)
                prefix += hunit[idx - 1];
            if (idx == 0 && vidx > 0)
            {
                prefix += vunit[vidx - 1]; // 段結束位置應該加上段名如萬,億
            }
        }

        if (prefix.length() > 0)
            prefix += '圓'; // 如果整數部分存在,則有圓的字樣
        return prefix + suffix; // 返回正確表示
    }


/**
     * 全角字符轉半角字符
     *
     * @param QJStr
     * @return String
     */
    public static final String QJToBJChange(String QJStr)
    {
        char[] chr = QJStr.toCharArray();
        String str = "";
        for (int i = 0; i < chr.length; i++)
        {
            chr = (char) ((int) chr - 65248);
            str += chr;
        }
        return str;
    }


   /**
     * 去掉字符串中重複的子字符串
     *
     * @param str
     * @return String
     */
    private static String removeSameString(String str)
    {
        Set<String> mLinkedSet = new LinkedHashSet<String>();
        String[] strArray = str.split(" ");
        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < strArray.length; i++)
        {
            if (!mLinkedSet.contains(strArray))
            {
                mLinkedSet.add(strArray);
                sb.append(strArray + " ");
            }
        }
        System.out.println(mLinkedSet);
        return sb.toString().substring(0, sb.toString().length() - 1);
    }




  /**
     * 設置JSpinner的編輯屬性
     * @param spinner 目標JSpinner
     * @param isAllowInvalid 是否允許輸入非法值
     * @param isEditable 是否允許編輯
     */
    public static void setAllowsInvalid(JSpinner spinner, boolean isAllowInvalid, boolean isEditable)
    {
        JSpinner.NumberEditor editor = new JSpinner.NumberEditor(spinner, "#");
        spinner.setEditor(editor);
        JFormattedTextField tf = ((JSpinner.NumberEditor)spinner.getEditor()).getTextField();
        tf.setEditable(isEditable);
        DefaultFormatterFactory factory = (DefaultFormatterFactory)tf.getFormatterFactory();
        NumberFormatter formatter = (NumberFormatter)factory.getDefaultFormatter();
        formatter.setAllowsInvalid(isAllowInvalid);
    }




  /**  
     * 根據指定方法的參數去構造一個新的對象的拷貝並將他返回
     * @param obj 原始對象
     * @return 新對象
     * @throws NoSuchMethodException   
     * @throws InvocationTargetException   
     * @throws IllegalAccessException   
     * @throws InstantiationException   
     * @throws SecurityException   
     * @throws IllegalArgumentException   
     */
    @SuppressWarnings("unchecked")
    public static Object copy(Object obj) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException,
                    InvocationTargetException, NoSuchMethodException
    {
        //獲得對象的類型   
        Class classType = obj.getClass();

        //通過默認構造方法去創建一個新的對象，getConstructor的視其參數決定調用哪個構造方法   
        Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

        //獲得對象的所有屬性   
        Field[] fields = classType.getDeclaredFields();

        for(int i = 0; i < fields.length; i++)
        {
            //獲取數組中對應的屬性   
            Field field = fields;

            String fieldName = field.getName();
            String stringLetter = fieldName.substring(0, 1).toUpperCase();

            //獲得相應屬性的getXXX和setXXX方法名稱   
            String getName = "get" + stringLetter + fieldName.substring(1);
            String setName = "set" + stringLetter + fieldName.substring(1);

            //獲取相應的方法   
            Method getMethod = classType.getMethod(getName, new Class[]{});
            Method setMethod = classType.getMethod(setName, new Class[]{field.getType()});

            //調用源對象的getXXX（）方法   
            Object value = getMethod.invoke(obj, new Object[]{});

            //調用拷貝對象的setXXX（）方法   
            setMethod.invoke(objectCopy, new Object[]{value});
        }

        return objectCopy;
    }


//過濾特殊字符
public static String encoding(String src){
        if (src==null)
            return "";
        StringBuilder result=new StringBuilder();
        if (src!=null){
            src=src.trim();
            for (int pos=0;pos<src.length();pos++){
                switch(src.charAt(pos)){
                    case '\"':result.append("&quot;");break;
                    case '<':result.append("&lt;");break;
                    case '>':result.append("&gt;");break;
                    case '\'':result.append("&apos;");break;
                    case '&':result.append("&amp;");break;
                    case '%':result.append("&pc;");break;
                    case '_':result.append("&ul;");break;
                    case '#':result.append("&shap;");break;
                    case '?':result.append("&ques;");break;
                    default:result.append(src.charAt(pos));break;
                }
            }
        }
        return result.toString();
    }

//反過濾特殊字符
    public static String decoding(String src){
        if (src==null)
            return "";
        String result=src;
        result=result.replace("&quot;", "\"").replace("&apos;", "\'");
        result=result.replace("&lt;", "<").replace("&gt;", ">");
        result=result.replace("&amp;", "&");
        result=result.replace("&pc;", "%").replace("&ul", "_");
        result=result.replace("&shap;", "#").replace("&ques", "?");
        return result;
    }

//利用反射調用一個繼承層次上的函數族，比如安裝程序，有安裝數據庫的，安裝文件系統的等，命名均已“install”開始，你就可以將參數part設爲“install”，src是其實類實例，root是終止父類
    public static <T> void invokeMethods(String part,T src,Class root) throws ExceptionManager{
        if (root!=null){
            if (!root.isInstance(src))return;
            root=(Class)root.getGenericSuperclass();
        }
        HashMap<String,Method> invokees=new HashMap<String,Method>();
        Class target=src.getClass();
        do{
            Method [] methods=target.getDeclaredMethods();
            for (Method method:methods){
                String mn=method.getName();
                Boolean isPass=mn.startsWith(part);
                if (isPass){
                    Integer nopt=method.getParameterTypes().length;
                    Boolean isStatic=Modifier.isStatic(method.getModifiers());
                    if ((nopt==0)&&(!isStatic)){
                        if (!invokees.containsKey(mn))
                            invokees.put(mn, method);
                    }
                }
            }
            target=(Class)target.getGenericSuperclass();
        }while(target!=root);
        Iterator<String> methods=invokees.keySet().iterator();
        while (methods.hasNext()){
            Method invokee=invokees.get(methods.next());
            Boolean access=invokee.isAccessible();
            invokee.setAccessible(true);
            try {
                invokee.invoke(src);
            } catch (InvocationTargetException e) {
                throw ExceptionManager.wrap(e.getTargetException());
            }catch (Exception e){}
            invokee.setAccessible(access);
        }
    }



MySQL：   
    String Driver="com.mysql.jdbc.Driver";    //驅動程序
    String URL="jdbc:mysql://localhost:3306/db_name";    //連接的URL,db_name爲數據庫名   
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).new Instance();
    Connection con=DriverManager.getConnection(URL,Username,Password);
Microsoft SQL Server 2.0驅動(3個jar的那個):
    String Driver="com.microsoft.jdbc.sqlserver.SQLServerDriver";    //連接SQL數據庫的方法
    String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";    //db_name爲數據庫名
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).new Instance();    //加載數據可驅動
    Connection con=DriverManager.getConnection(URL,UserName,Password);    //
Microsoft SQL Server 3.0驅動(1個jar的那個): // 老紫竹完善
    String Driver="com.microsoft.sqlserver.jdbc.SQLServerDriver";    //連接SQL數據庫的方法
    String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";    //db_name爲數據庫名
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).new Instance();    //加載數據可驅動
    Connection con=DriverManager.getConnection(URL,UserName,Password);    //
Sysbase:
    String Driver="com.sybase.jdbc.SybDriver";    //驅動程序
    String URL="jdbc:Sysbase://localhost:5007/db_name";    //db_name爲數據可名
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).newInstance();   
    Connection con=DriverManager.getConnection(URL,Username,Password);
Oracle(用thin模式):
    String Driver="oracle.jdbc.driver.OracleDriver";    //連接數據庫的方法
    String URL="jdbcracle:thinloaclhost:1521rcl";    //orcl爲數據庫的SID
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).newInstance();    //加載數據庫驅動
    Connection con=DriverManager.getConnection(URL,Username,Password);   
PostgreSQL:
    String Driver="org.postgresql.Driver";    //連接數據庫的方法
    String URL="jdbc:postgresql://localhost/db_name";    //db_name爲數據可名
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).newInstance();   
    Connection con=DriverManager.getConnection(URL,Username,Password);
DB2：
    String Driver="com.ibm.db2.jdbc.app.DB2.Driver";    //連接具有DB2客戶端的Provider實例
    //String Driver="com.ibm.db2.jdbc.net.DB2.Driver";    //連接不具有DB2客戶端的Provider實例
    String URL="jdbc:db2://localhost:5000/db_name";    //db_name爲數據可名
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).newInstance();   
    Connection con=DriverManager.getConnection(URL,Username,Password);
Informix:
    String Driver="com.informix.jdbc.IfxDriver";   
    String URL="jdbc:Informix-sqli://localhost:1533/db_name:INFORMIXSER=myserver";    //db_name爲數據可名
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).newInstance();   
    Connection con=DriverManager.getConnection(URL,Username,Password);
JDBC-ODBC:
    String Driver="sun.jdbc.odbc.JdbcOdbcDriver";
    String URL="jdbcdbc:dbsource";    //dbsource爲數據源名
    String Username="username";    //用戶名
    String Password="password";    //密碼
    Class.forName(Driver).newInstance();   
    Connection con=DriverManager.getConnection(URL,Username,Password);






/**
*  把TXT轉換爲XML
*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.StringTokenizer;

public class TxtToXml {
private String strTxtFileName;

private String strXmlFileName;

public TxtToXml() {
  strTxtFileName = new String();
  strXmlFileName = new String();
}

public void createXml(String strTxt, String strXml) {
  strTxtFileName = strTxt;
  strXmlFileName = strXml;
  String strTmp;
  try {
   BufferedReader inTxt = new BufferedReader(new FileReader(
     strTxtFileName));
   BufferedWriter outXml = new BufferedWriter(new FileWriter(
     strXmlFileName));
   outXml.write("<?xml version= \"1.0\" encoding=\"gb2312\"?>");
   outXml.newLine();
   outXml.write("<people>");
   while ((strTmp = inTxt.readLine()) != null) {
    StringTokenizer strToken = new StringTokenizer(strTmp, "，");
    String arrTmp[];
    arrTmp = new String[3];
    for (int i = 0; i < 3; i++)
     arrTmp = new String("");
    int index = 0;
    outXml.newLine();
    outXml.write("    <students>");
    while (strToken.hasMoreElements()) {
     strTmp = (String) strToken.nextElement();
     strTmp = strTmp.trim();
     arrTmp[index++] = strTmp;
    }
    outXml.newLine();
    outXml.write("        <name>" + arrTmp[0] + "</name>");
    outXml.newLine();
    outXml.write("        <sex>" + arrTmp[1] + "</sex>");
    outXml.newLine();
    outXml.write("        <age>" + arrTmp[2] + "</age>");
    outXml.newLine();
    outXml.write("    </students>");
   }
   outXml.newLine();
   outXml.write("</people>");
   outXml.flush();
  } catch (Exception e) {
   e.printStackTrace();
  }
}

public static void main(String[] args) {
  String txtName = "testtxt.txt";
  String xmlName = "testxml.xml";
  TxtToXml thisClass = new TxtToXml();
  thisClass.createXml(txtName, xmlName);
}
}


/**
  * 寫入日誌
  * filePath 日誌文件的路徑
  * code 要寫入日誌文件的內容
  */
public static boolean print(String filePath,String code) {
  try {
   File tofile=new File(filePath);
   FileWriter fw=new FileWriter(tofile,true);
   BufferedWriter bw=new BufferedWriter(fw);
   PrintWriter pw=new PrintWriter(bw);

   System.out.println(getDate()+":"+code);
   pw.println(getDate()+":"+code);
   pw.close();
   bw.close();
   fw.close();
   return true;
  } catch (IOException e) {
   return false;
  }
}



/**
  * 判斷是不是合法手機
  * handset 手機號碼
  */
public static boolean isHandset(String handset) {
  try {
   if(!handset.substring(0,1).equals("1")) {
    return false;
   }
   if (handset==null || handset.length()!=11) {
    return false;
   }
   String check = "^[0123456789]+$";
   Pattern regex = Pattern.compile(check);
   Matcher matcher = regex.matcher(handset);
   boolean isMatched = matcher.matches();
   if(isMatched) {
    return true;
   } else {
    return false;
   }
  } catch (RuntimeException e) {
   return false;
  }
}
}

字符串匹配的算法.
public String getMaxMatch(String a,String b) {  
        StringBuffer tmp = new StringBuffer();  
        String maxString = "";  
        int max = 0;  
        int len = 0;  
        char[] aArray = a.toCharArray();  
        char[] bArray = b.toCharArray();  
        int posA = 0;  
        int posB = 0;  
        while(posA<aArray.length-max) {  
            posB = 0;  
            while(posB<(bArray.length-max)) {                                  
                 if(aArray[posA]==bArray[posB]) {  
                      len = 1;  
                      tmp = new StringBuffer();  
                      tmp.append(aArray[posA]);                                          
                      while((posA+len<aArray.length)&&(posB+len<bArray.length)&&(aArray[posA+len]==bArray[posB+len])) {  
                           tmp.append(aArray[posA+len]);  
                           len++;  
                      }  
                      if(len>max) {  
                            max = len;  
                            maxString = tmp.toString();  
                      }  
                 }  
                      posB++;  
            }  
                      posA++;  
         }          
            return maxString;                      
    }



import java.text.DecimalFormat;
import java.util.Arrays;

/**
* 時間計算工具類
*/
public class Time {

    /**
     * 時間字段常量，表示“秒”
      */
    public final static int SECOND = 0;

    /**
     * 時間字段常量，表示“分”
      */
    public final static int MINUTE = 1;

    /**
     * 時間字段常量，表示“時”
      */
    public final static int HOUR = 2;

    /**
     * 時間字段常量，表示“天”
      */
    public final static int DAY = 3;

    /**
     * 各常量允許的最大值
      */
    private final int[] maxFields = { 59, 59, 23, Integer.MAX_VALUE - 1 };

    /**
     * 各常量允許的最小值
      */
    private final int[] minFields = { 0, 0, 0, Integer.MIN_VALUE };

    /**
     * 默認的字符串格式時間分隔符
      */
    private String timeSeparator = ":";

    /**
     * 時間數據容器
      */
    private int[] fields = new int[4];   

    /**
     * 無參構造，將各字段置爲 0
     */
    public Time() {
        this(0, 0, 0, 0);
    }

    /**
     * 使用時、分構造一個時間
      * @param hour      小時
      * @param minute    分鐘
      */
    public Time(int hour, int minute) {
        this(0, hour, minute, 0);
    }

    /**
     * 使用時、分、秒構造一個時間
      * @param hour      小時
      * @param minute    分鐘
      * @param second    秒
      */
    public Time(int hour, int minute, int second) {
        this(0, hour, minute, second);
    }

    /**
     * 使用一個字符串構造時間<br/>
     * Time time = new Time("14:22:23");
     * @param time      字符串格式的時間，默認採用“:”作爲分隔符
      */
    public Time(String time) {       
        this(time, null);
    }

    /**
     * 使用天、時、分、秒構造時間，進行全字符的構造
      * @param day       天
      * @param hour      時
      * @param minute    分
      * @param second    秒
      */
    public Time(int day, int hour, int minute, int second) {
        set(DAY, day);
        set(HOUR, hour);
        set(MINUTE, minute);
        set(SECOND, second);
    } 

    /**
     * 使用一個字符串構造時間，指定分隔符<br/>
     * Time time = new Time("14-22-23", "-");
     * @param time      字符串格式的時間
      */
    public Time(String time, String timeSeparator) {
        if(timeSeparator != null) {
            setTimeSeparator(timeSeparator);
        }
        String pattern = patternQuote(this.timeSeparator);
        String matcher = new StringBuffer()
                                .append("\\d+?").append(pattern)
                                .append("\\d+?").append(pattern)
                                .append("\\d+?")
                                .toString();
        if(!time.matches(matcher)) {
            throw new IllegalArgumentException(time + ", time format error, HH"
                    + this.timeSeparator + "mm" + this.timeSeparator + "ss");
        }       
        String[] times = time.split(pattern);
        set(DAY, 0);
        set(HOUR, Integer.parseInt(times[0]));
        set(MINUTE, Integer.parseInt(times[1]));
        set(SECOND, Integer.parseInt(times[2]));
    }

    /**
     * 設置時間字段的值
     * @param field     時間字段常量
     * @param value     時間字段的值
     */
    public void set(int field, int value) {       
        if(value < minFields[field]) {
            throw new IllegalArgumentException(value +
                    ", time value must be positive.");
        }
        fields[field] = value % (maxFields[field] + 1);
        // 進行進位計算
         int carry = value / (maxFields[field] + 1);
        if(carry > 0) {
            int upFieldValue = get(field + 1);
            set(field + 1, upFieldValue + carry);
        }
    }

    /**
     * 獲得時間字段的值
      * @param field     時間字段常量
      * @return          該時間字段的值
      */
    public int get(int field) {
        if(field < 0 || field > fields.length - 1) {
            throw new IllegalArgumentException(field + ", field value is error.");
        }
        return fields[field];
    }

    /**
     * 將時間進行“加”運算，即加上一個時間
      * @param time      需要加的時間
      * @return          運算後的時間
      */
    public Time addTime(Time time) {
        Time result = new Time();
        int up = 0;     // 進位標誌
         for (int i = 0; i < fields.length; i++) {
            int sum = fields + time.fields + up;
            up = sum / (maxFields + 1);
            result.fields = sum % (maxFields + 1);
        }
        return result;
    }

    /**
     * 將時間進行“減”運算，即減去一個時間
      * @param time      需要減的時間
      * @return          運算後的時間
      */
    public Time subtractTime(Time time) {
        Time result = new Time();
        int down = 0;       // 退位標誌
         for (int i = 0, k = fields.length - 1; i < k; i++) {
            int difference = fields + down;
            if (difference >= time.fields) {
                difference -= time.fields;
                down = 0;
            } else {
                difference += maxFields + 1 - time.fields;
                down = -1;
            }
            result.fields = difference;
        }
        result.fields[DAY] = fields[DAY] - time.fields[DAY] + down;
        return result;
    }

    /**
     * 獲得時間字段的分隔符
      * @return
     */
    public String getTimeSeparator() {
        return timeSeparator;
    }

    /**
     * 設置時間字段的分隔符（用於字符串格式的時間）
      * @param timeSeparator     分隔符字符串
      */
    public void setTimeSeparator(String timeSeparator) {
        this.timeSeparator = timeSeparator;
    }

    /**
     * 正則表達式引用處理方法，源自 JDK @link java.util.regex.Pattern#quote(String)
     */
    private String patternQuote(String s) {
        int slashEIndex = s.indexOf("\\E");
        if (slashEIndex == -1)
            return "\\Q" + s + "\\E";

        StringBuilder sb = new StringBuilder(s.length() * 2);
        sb.append("\\Q");
        slashEIndex = 0;
        int current = 0;
        while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
            sb.append(s.substring(current, slashEIndex));
            current = slashEIndex + 2;
            sb.append("\\E\\\\E\\Q");
        }
        sb.append(s.substring(current, s.length()));
        sb.append("\\E");
        return sb.toString();
    }

    public String toString() {
        DecimalFormat df = new DecimalFormat("00");
        return new StringBuffer().append(fields[DAY]).append(", ")
                    .append(df.format(fields[HOUR])).append(timeSeparator)
                    .append(df.format(fields[MINUTE])).append(timeSeparator)
                    .append(df.format(fields[SECOND]))
                    .toString();
    }

    public int hashCode() {
        final int PRIME = 31;
        int result = 1;
        result = PRIME * result + Arrays.hashCode(fields);
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final Time other = (Time) obj;
        if (!Arrays.equals(fields, other.fields)) {
            return false;
        }
        return true;
    }
}




ISBN（國際標準書號）的校驗

public class Test {

    public static void main(String[] args) {
        System.out.println("9787302155638 " + ISBN.checkISBN("9787302155638"));
        System.out.println("7564105607 " + ISBN.checkISBN("7564105607"));
        System.out.println("730213880X " + ISBN.checkISBN("730213880X"));
        System.out.println("7302138800 " + ISBN.checkISBN("7302138800"));
        System.out.println("9790000000000 " + ISBN.checkISBN("9790000000000"));
        try {
            System.out.println(ISBN.checkISBN("9770000000000"));
        }catch(Exception e) {
            System.out.println("9770000000000 " + e.getMessage());
        }
        try {
            System.out.println(ISBN.checkISBN("123456545"));
        }catch(Exception e) {
            System.out.println("123456545 " + e.getMessage());
        }       
    }
}

public final class ISBN {

    /**
     * 根據輸入的ISBN號，檢驗ISBN的有效性。依據 GB/T 5795-2006 和 ISO 2108:2005 ISBN
     * 10位標準和13位標準實現（13位標準自2007年1月1日開始實行，在此之前採用10位標準）。
      *
     * @param String isbn：需要進行校驗的ISBN字符串
      * @return true：所輸入的ISBN校驗正確；<br/> false：所輸入的ISBN校驗錯誤
      */
    public static boolean checkISBN(String isbn) {

        int count = 0;
        int checkBitInt = 0;

        // 將ISBN數據全取大寫字母
         //isbn = isbn.toUpperCase();

        char[] cs = isbn.toCharArray();       
        switch (isbn.length()) {
        case 10:
            // ****************************************************************
            // 當ISBN爲10位時，進行的校驗，用於2007年1月1日前的出版物
              // 數據格式：從左至右前9位爲ISBN數據，第10位爲校驗位
              // 校驗方法：
              // (1) 從左至右將前9位數據從10開始至2進行編號，作爲位權
              // (2) 將9位數據與各位位權進行加權，並求其9位和（稱爲加權和，記作M）
              // (3) 第10位校驗位計算方法，校驗位爲C：
              //         M + C ≡ 0 (mod 11)
            //  C爲10時，記作“X”
              // ****************************************************************

            // 取出前9位數字進行加權和計算           
              for (int i = 0; i < 9; i++) {
                // 若前9位數據中有非數字字符，則拋出異常
                  if (cs < '0' || cs > '9') {
                    throw new ISBNFormatException("ISBN " + isbn +
                            " 第 " + (i + 1) + " 位中出現非法字符 " + cs);
                }

                int c = cs - '0';
                // 求加權和
                  count += c * (10 - i);
            }

            // 取出校驗位數據0～9和X符合校驗字符要求
              if (cs[9] >= '0' && cs[9] <= '9') {
                checkBitInt = cs[9] - '0';
            } else if (cs[9] == 'X' || cs[9] == 'x') {
                // 校驗位中的“X”表示數據“10”
                  checkBitInt = 10;
            } else {
                // 非0～9或X時拋出異常
                  throw new ISBNFormatException("ISBN " + isbn +
                        " 第 10 位中出現非法字符 " + cs[9]);
            }

            // 進行校驗
              if ((count + checkBitInt) % 11 == 0) {
                return true; // 校驗成功
              } else {
                return false; // 校驗失敗
            }
        case 13:
            // ****************************************************************
            // 當ISBN爲13位時，進行的校驗，用於2007年1月1日後的出版物
              // 數據格式：從左至右前12位爲ISBN數據，第13位爲校驗位
              // 校驗方法：
              // (1) 從左至右將前12位數的取其奇位數和和偶位數和
              // (2) 將偶位數和乘3，並其與奇位數和的和，得加權和
              // (3) 第13位校驗位計算方法，校驗位爲C：
              //         M + C ≡ 0 (mod 10)
            // ****************************************************************

            // ISBN爲13位數據時，前3位目前只能是“978”（已實行）或“979”（暫未實行）
              if (!isbn.startsWith("978") && !isbn.startsWith("979")) {
                throw new ISBNFormatException("ISBN-13 格式不符合標準");
            }
            // 取出前12位數字進行加權和計算
              int countEven = 0;
            int countOdd = 0;
            for (int i = 0; i < 12; i++) {
                int c = cs - '0';
                // 若前12位數據中有非數字字符，則拋出異常
                  if (c < 0 || c > 9) {
                    throw new ISBNFormatException("ISBN " + isbn +
                            " 第 " + (i + 1) + " 位中出現非法字符 " + cs);
                }
                // 分別計算奇位數和偶位數的和
                  if ((i & 0x1) == 0) {
                    countOdd += c;
                } else {
                    countEven += c;
                }
            }
            // 求加權和
             count = countOdd + (countEven * 3);

            // 取出校驗位數據           
             if (cs[12] < '0' || cs[12] > '9') {
                // 校驗位爲非0~9字符時，拋出異常
                  throw new ISBNFormatException("ISBN " + isbn
                        + " 第 13 位中出現非法字符 " + cs[12]);
            }

            checkBitInt = cs[12] - '0';
            // 進行校驗
             if ((count + checkBitInt) % 10 == 0) {
                return true; // 校驗成功
             } else {
                return false; // 校驗失敗
             }
        default:
            // ISBN爲非10位或13位時拋出異常
             throw new ISBNFormatException("ISBN 格式不符合標準");
        }
    }
}






import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
* JSON utility class
*
* @since 2008-04-21
*/
public class Json {

    // test
    public static void main(String[] args) {
        Json json1 = new Json();
        json1.add("totalCount", 2);
        json1.add("isTest", true);

        Json json_a = new Json();
        json_a.add("menuid", 1);
        json_a.add("menuname", "testmenu");
        json1.add("topics", json_a);

        Json json_b = new Json();
        json_b.add("menuid", 2);
        json_b.add("menuname", "testmenu");
        json1.add("topics", json_b);
        System.out.println(json1.toString());
    }

    private Map map = new LinkedHashMap();

    /**
     * 添加一個 JSON 屬性，值爲一個字符串，重複添加時產生數組<p/>
     *
     * add("name", "value");<br/>
     * 添加一個字符串，產生的 JSON 如：{"name":"value"}<p/>
     *
     * add("name", "value1");<br/>
     * add("name", "value2");<br/>
     * 添加兩個同屬性的字符串，產生的 JSON 如：{"name":["value1", "value2"]}<p/>
     *
     * @param key       JSON 屬性名
      * @param str       字符串格式的屬性值
      */
    public void add(String key, String value) {
        addElement(key, value);
    }

    public void add(String key, int num) {
        addElement(key, new Integer(num));
    }

    public void add(String key, boolean b) {
        addElement(key, new Boolean(b));
    }

    /**
     * 添加一個 JSON 屬性，值爲一個 JSON，重複添加時產生 JSON 數組<p/>
     *
     * Json json1 = new Json();<br/>
     * json1.add("name1", "value1");<br/>
     * json1.add("name2", "value2");<br/>
     * Json json = new Json();<br/>
     * json.add("message", json1);<br/>
     * 添加一個 JSON，產生的 JSON 如：{"message":{"name1":"value1", "name2":"value2"}}<p/>
     *
     * Json json1 = new Json();<br/>
     * json1.add("name1", "value1");<br/>
     * json1.add("name2", "value2");<br/>
     * Json json2 = new Json();<br/>
     * json2.add("name1", "value3");<br/>
     * json2.add("name2", "value4");<br/>
     * Json json = new Json();<br/>
     * json.add("message", json1);<br/>
     * json.add("message", json2);<br/>
     * 添加兩個同屬性的 JSON，產生的 JSON 如：{"message":[{"name1":"value1", "name2":"value2"}, {"name1":"value3", "name2":"value4"}]}<p/>
     *
     * @param key       JSON 屬性名
      * @param json      JSON 格式的屬性值
      */
    public void add(String key, Json json) {
        addElement(key, json);
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        int k = 0;
        for (Iterator i = map.keySet().iterator(); i.hasNext();) {
            String key = (String)(i.next());
            Object obj = map.get(key);
            if (k > 0) {
                sb.append(",");
            }
            appendKey(sb, key);
            if (obj instanceof String) {
                appendString(sb, (String)obj);
            } else if (obj instanceof List) {
                appendList(sb, (List)obj);
            } else if (obj instanceof Json) {
                appendJson(sb, (Json)obj);
            } else {
                appendOther(sb, obj);
            }
            k++;
        }
        sb.append("}");
        return sb.toString();
    }

    private void addElement(String key, Object obj) {
        if (!map.containsKey(key)) {
            if(obj instanceof Json) {
                List list = new ArrayList();
                list.add(obj);
                map.put(key, list);
            } else {
                map.put(key, obj);
            }
            return;
        }

        Object o = map.remove(key);

        if (o instanceof List) {
            ((List)o).add(obj);
            map.put(key, o);
            return;
        }

        // o is a String
        List list = new ArrayList();
        list.add(o);
        list.add(obj);
        map.put(key, list);
    }

    /**
     * Append JSON property name
     *
     * @param sb
     * @param key
     */
    private void appendKey(StringBuilder sb, String key) {
        sb.append("\"").append(key).append("\":");
    }

    /**
     * Append JSON property value that is a String
     *
     * @param sb
     * @param str
     */
    private void appendString(StringBuilder sb, String str) {
        sb.append("\"").append(str).append("\"");
    }

    /**
     * Append JSON property value that is a Integer
     *
     * @param sb
     * @param num
     */
    private void appendOther(StringBuilder sb, Object obj) {
        sb.append(obj);
    }

    /**
     * Append JSON property value that is a List
     *
     * @param sb
     * @param list
     */
    private void appendList(StringBuilder sb, List list) {
        sb.append("[");
        for (int j = 0, m = list.size(); j < m; j++) {
            if (j > 0) {
                sb.append(",");
            }
            Object obj = list.get(j);
            if (obj instanceof String) {
                appendString(sb, (String)obj);
            } else if (obj instanceof Json) {
                appendJson(sb, (Json)obj);
            } else {
                appendOther(sb, obj);
            }
        }
        sb.append("]");
    }

    /**
     * Append JSON property value that is a JSON
     *
     * @param sb
     * @param json
     */
    private void appendJson(StringBuilder sb, Json json) {
        sb.append(json.toString());
    }
}



  /**
  * 從指定的字符串中提取Email
  * content 指定的字符串
  */
public static String parse(String content) {
  String email = null;
  if (content==null || content.length()<1) {
   return email;
  }
  //找出含有@
  int beginPos;
  int i;
  String token = "@";
  String preHalf="";
  String sufHalf = "";

  beginPos = content.indexOf(token);
  if (beginPos>-1) {
   //前項掃描
   String s = null;
   i= beginPos;
   while(i>0) {
    s = content.substring(i-1,i);
    if (isLetter(s))
     preHalf = s+preHalf;
    else
     break;
    i--;
   }
   //後項掃描
   i= beginPos+1;
   while( i<content.length()) {
    s = content.substring(i,i+1);
    if (isLetter(s))
     sufHalf =  sufHalf +s;
    else
     break;
    i++; 
   }
   //判斷合法性
   email = preHalf + "@" + sufHalf;
   if (isEmail(email)) {
    return email;
   }
  }
  return null;
}

/**
  * 判斷是不是合法Email
  * email Email地址
  */
public static boolean isEmail(String email) {
  try {
   if (email==null || email.length()<1 || email.length()>256) {
    return false;
   }

   String check = "^([0-9a-zA-Z]+[_.0-9a-zA-Z-]+)@([a-zA-Z0-9-]+[.])+([a-zA-Z]{2,3})$";
   Pattern regex = Pattern.compile(check);
   Matcher matcher = regex.matcher(email);
   boolean isMatched = matcher.matches();
   if(isMatched) {
    return true;
   } else {
    return false;
   }
  } catch (RuntimeException e) {
   return false;
  }
}

/**
  * 判斷是不是合法字符
  * c 要判斷的字符
  */
public static boolean isLetter(String c) {
  boolean result = false;

  if (c==null || c.length()<0) {
   return false;
  }
  //a-z
  if (c.compareToIgnoreCase("a")>=0 && c.compareToIgnoreCase("z")<=0) {
   return true;
  }
  //0-9
  if (c.compareToIgnoreCase("0")>=0 && c.compareToIgnoreCase("9")<=0) {
   return true;
  }
  //. - _
  if (c.equals(".") || c.equals("-") || c.equals("_") ) {
   return true;
  }
  return result;
}



/**
     * 列出某文件夾及其子文件夾下面的文件，並可根據擴展名過濾
     *
     * @param path
     */
    public static void list(File path)
    {
        if (!path.exists())
        {
            System.out.println("文件名稱不存在!");
        }
        else
        {
            if (path.isFile())
            {
                if (path.getName().toLowerCase().endsWith(".pdf")
                        || path.getName().toLowerCase().endsWith(".doc")
                        || path.getName().toLowerCase().endsWith(".html")
                        || path.getName().toLowerCase().endsWith(".htm"))
                {
                    System.out.println(path);
                    System.out.println(path.getName());
                }
            }
            else
            {
                File[] files = path.listFiles();
                for (int i = 0; i < files.length; i++)
                {
                    list(files);
                }
            }
        }
    }




  /**
     * 拷貝一個目錄或者文件到指定路徑下
     *
     * @param source
     * @param target
     */
    public static void copy(File source, File target)
    {
        File tarpath = new File(target, source.getName());
        if (source.isDirectory())
        {
            tarpath.mkdir();
            File[] dir = source.listFiles();
            for (int i = 0; i < dir.length; i++)
            {
                copy(dir, tarpath);
            }
        }
        else
        {
            try
            {
                InputStream is = new FileInputStream(source);
                OutputStream os = new FileOutputStream(tarpath);
                byte[] buf = new byte[1024];
                int len = 0;
                while ((len = is.read(buf)) != -1)
                {
                    os.write(buf, 0, len);
                }
                is.close();
                os.close();
            }
            catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }




Java日期格式化及其使用例子
1 SimpleDateFormat擔當重任,怎樣格式化都行

import java.util.Date;
import java.text.SimpleDateFormat;
public class Demo
{
public static void main(String[] args)
{
  Date now=new Date();
  SimpleDateFormat f=newSimpleDateFormat("今天是"+"yyyy年MM月dd日 E kk點mm分");
  System.out.println(f.format(now));

  f=new SimpleDateFormat("a hh點mm分ss秒");
  System.out.println(f.format(now));
  }
}


2 從字符串到日期類型的轉換：

import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;
import java.text.*;
publicclass Demo
{
public static void main(String[] args)
{
  String strDate="2005年04月22日";
  //注意：SimpleDateFormat構造函數的樣式與strDate的樣式必須相符
  SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日");
  //必須捕獲異常

  try
  {
  Date date=simpleDateFormat.parse(strDate);
  System.out.println(date);
  }
  catch(ParseException px)
  {
  px.printStackTrace();
  }
}
}


3 將毫秒數換轉成日期類型

import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;
import java.text.*;
public class Demo
{
public static void main(String[] args)
{
  long now=System.currentTimeMillis();
  System.out.println("毫秒數："+now);
  Date dNow=new Date(now);
  System.out.println("日期類型："+dNow);
}
}


這3例源自http://blog.csdn.net/zhoujian2003/archive/2005/04/22/358363.aspx

4 獲取系統時期和時間，轉換成SQL格式後更新到數據庫
(http://blog.csdn.net/netrope/archive/2005/11/19/532729.aspx)

java.util.Date d=new java.util.Date();    //獲取當前系統的時間

//格式化日期

new java.text.SimpleDateFormat s= new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String dateStr = s.format(d); //轉爲字符串

使用RS更新數據庫，仍然要用rs.updateString，而不是rs.updateDade。
rs.updateString("regtime",dateStr);  //regtime字段爲datetime類型的
下面兩例源自 http://blog.csdn.net/kingter520/archive/2004/10/27/155435.aspx

5 按本地時區輸出當前日期

Date myDate = new Date();
System.out.println(myDate.toLocaleString());
輸出結果爲：
2003-5-30


6 如何格式化小數

DecimalFormat df = new DecimalFormat(",###.00"); 
double aNumber = 33665448856.6568975;
String result = df.format(aNumber); 
Sytem. out.println(result);


輸出結果爲：
33,665,448,856.66

其他：獲取毫秒時間 System.currentTimeMillis();

7 在數據庫裏的日期只以年-月-日的方式輸出
(http://blog.csdn.net/zzsxvzzsxv/archive/2007/08/27/1761004.aspx)
定義日期格式：SimpleDateFormat sdf = new SimpleDateFormat(yy-MM-dd);
sql語句爲：String sqlStr = "select bookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'";
輸出：
System.out.println(df.format(rs.getDate("bookDate")));





Java中的鼠標和鍵盤事件
1、使用MouseListener藉口處理鼠標事件
鼠標事件有5種：按下鼠標鍵，釋放鼠標鍵，點擊鼠標鍵，鼠標進入和鼠標退出
鼠標事件類型是MouseEvent，主要方法有：
getX(),getY() 獲取鼠標位置
getModifiers() 獲取鼠標左鍵或者右鍵
getClickCount() 獲取鼠標被點擊的次數
getSource() 獲取鼠標發生的事件源
事件源獲得監視器的方法是addMouseListener()，移去監視器的方法是removeMouseListener()
處理事件源發生的時間的事件的接口是MouseListener 接口中有如下的方法
mousePressed(MouseEvent) 負責處理鼠標按下事件
mouseReleased(MouseEvent) 負責處理鼠標釋放事件
mouseEntered(MouseEvent) 負責處理鼠標進入容器事件
mouseExited(MouseEvent) 負責處理鼠標離開事件
mouseClicked(MouseEvent) 負責處理點擊事件
2、使用MouseMotionListener接口處理鼠標事件
事件源發生的鼠標事件有2種：拖動鼠標和鼠標移動
鼠標事件的類型是MouseEvent
事件源獲得監視器的方法是addMouseMotionListener()
處理事件源發生的事件的接口是MouseMotionListener 接口中有如下的方法
mouseDragged() 負責處理鼠標拖動事件
mouseMoved() 負責處理鼠標移動事件
3、控制鼠標的指針形狀
setCursor(Cursor.getPreddfinedCursor(Cursor.鼠標形狀定義)) 鼠標形狀定義見（書 P 210）
4、鍵盤事件
鍵盤事件源使用addKeyListener 方法獲得監視器
鍵盤事件的接口是KeyListener 接口中有3個方法
public void keyPressed(KeyEvent e) 按下鍵盤按鍵
public void keyReleased(KeyEvent e) 釋放鍵盤按鍵





public class IsChineseOrEnglish {
//  GENERAL_PUNCTUATION 判斷中文的“號
//  CJK_SYMBOLS_AND_PUNCTUATION 判斷中文的。號
//  HALFWIDTH_AND_FULLWIDTH_FORMS 判斷中文的，號
   public static boolean isChinese(char c) {
      Character.UnicodeBlock ub = Character.UnicodeBlock.of(c); 
      if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
        || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
        || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
        || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
        || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
        || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS){
       return true;
      }
      return false;
   }
   public static void isChinese(String strName) {
      char[] ch = strName.toCharArray();
      for (int i = 0; i < ch.length; i++) {
    char c = ch;
    if(isChinese(c)==true){
     System.out.println(isChinese(c));
    return;
   }else{
     System.out.println(isChinese(c));
     return ;
    }
   }
   }

   public static void main(String[] args){

    isChinese("zhongguo");
    isChinese("中國");
  }

}





MD5和一個可逆加密算法相接合的加密和解密程序
比較簡單。
[code={0}]
import java.security.MessageDigest;
/**
*先通過MD5加密之後，再來一次可逆的加密。
*順序可以調整，可以選擇先用可逆加密，然後再用MD5加密
*/
public class MD5andKL{
//MD5加碼。32位
public static String MD5(String inStr) {
MessageDigest md5 = null;
try {
md5 = MessageDigest.getInstance("MD5");
} catch (Exception e) {
System.out.println(e.toString());
e.printStackTrace();
return "";
}
char[] charArray = inStr.toCharArray();
byte[] byteArray = new byte[charArray.length];

for (int i = 0; i < charArray.length; i++)
byteArray = (byte) charArray;

byte[] md5Bytes = md5.digest(byteArray);

StringBuffer hexValue = new StringBuffer();

for (int i = 0; i < md5Bytes.length; i++) {
int val = ((int) md5Bytes) & 0xff;
if (val < 16)
hexValue.append("0");
hexValue.append(Integer.toHexString(val));
}

return hexValue.toString();
}

//可逆的加密算法
public static String KL(String inStr){
//String s = new String(inStr);
char[] a = inStr.toCharArray(); 
  for (int i = 0;i <a.length;i++)  { 
  a = (char)(a^'t'); 
  } 
  String s=new String(a);
  return s; 
}
//加密後解密
public static String JM(String inStr){
char[] a=inStr.toCharArray();
for (int i = 0;i <a.length;i++)  { 
a= (char)(a^'t'); 
  }     
  String k=new String(a);
  return k;
}
//測試主函數
public static void main (String args[]){
String s = new String("admin");
System.out.println("原始："+s);
System.out.println("MD5後："+MD5(s));
System.out.println("MD5後再加密："+KL(MD5(s)));
System.out.println("解密爲MD5後的："+JM(KL(MD5(s))));
}
}
[/code]



/**
* 取得服務器當前的各種具體時間
* 回車：日期時間
*/

import java.util.*;

public class GetNowDate{
    Calendar  calendar = null;

    public GetNowDate(){
        calendar = Calendar.getInstance();
        calendar.setTime(new Date());
    }

    public int getYear(){
        return calendar.get(Calendar.YEAR);
    }

    public int getMonth(){
        return 1 + calendar.get(Calendar.MONTH);
    }

    public int getDay(){
        return calendar.get(Calendar.DAY_OF_MONTH);
    }

    public int getHour(){
        return calendar.get(Calendar.HOUR_OF_DAY);
    }

    public int getMinute(){
        return calendar.get(Calendar.MINUTE);
    }

    public int getSecond(){
        return calendar.get(Calendar.SECOND);
    }

    public String getDate(){
        return getMonth()+"/"+getDay()+"/"+getYear();
    }

    public String getTime(){
        return getHour()+":"+getMinute()+":"+getSecond();
    }

    public String getDate2(){
        String yyyy="0000", mm="00", dd="00";
        yyyy = yyyy + getYear();
        mm   = mm   + getMonth();
        dd   = dd + getDay();
        yyyy = yyyy.substring(yyyy.length()-4);
        mm   = mm.substring(mm.length()-2);
        dd   = dd.substring(dd.length()-2);
        return yyyy + "/" + mm + "/" +  dd;
    }

    public String getTime2(){
        String hh="00", mm="00", ss="00";
        hh = hh + getHour();
        mm = mm + getMinute();
        ss = ss + getSecond();
        hh = hh.substring(hh.length()-2, hh.length());
        mm = mm.substring(mm.length()-2, mm.length());
        ss = ss.substring(ss.length()-2, ss.length());
        return hh + ":" + mm + ":" + ss;
    }
}





/**
* 用半角的特殊符號代替全角的特殊符號
* 防止特殊字符在傳輸參數時出現錯誤
*
*/

public class ReplaceStrE{
    public static String rightToError(String ss){
        String strs;
        String strs1;
        String strs2;
        String strs3;
        String strs4;
        try{
            strs = ss.replace('＃','#');
        }
        catch(Exception ex){
            return ss;
        }

        try{
            strs1 = strs.replace('＂','"');
        }
        catch(Exception ex){
            return strs;
        }

        try{
            strs2 = strs1.replace('  ','&');
        }
        catch(Exception ex){
            return strs1;
        }

        try{
            strs3 = strs2.replace('＋','+');
        }
        catch(Exception ex){
            return strs2;
        }

        try{
            strs4 = strs3.replace('＇','\'');
        }
        catch(Exception ex){
            return ss;
        }
        return strs4;
    }
}




/**
* Big5字與Unicode的互換
* 轉換後的正常字型
*/

import java.io.*;

public class MyUtil{
    public static String big5ToUnicode(String s){
        try{
            return new String(s.getBytes("ISO8859_1"), "Big5");
        }
        catch (UnsupportedEncodingException uee){
            return s;
        }
    }

    public static String UnicodeTobig5(String s){
        try{
            return new String(s.getBytes("Big5"), "ISO8859_1");
        }
        catch (UnsupportedEncodingException uee){
            return s;
        }
    }

    public static String toHexString(String s){
        String str="";
        for (int i=0; i<s.length(); i++){
            int ch=(int)s.charAt(i);
            String s4="0000"+Integer.toHexString(ch);
            str=str+s4.substring(s4.length()-4)+" ";
        }
        return str;
    }
}





import java.io.*;
import java.util.ArrayList;
import java.util.List;
public class FileCopy {
private String message = "";
public String getMessage() {
  return message;
}
public void setMessage(String message) {
  this.message = message;
}
/**
  * 將源文件拷貝到目標文件
  *
  * @param src
  *            寫源文件地址，需文件名
  * @param des
  *            寫目標文件地址，無需文件名
  */
public boolean copyFile(String src, String des) {
  File srcFile = new File(src);
  File desDir = new File(des);
  File desFile = new File(des + "/" + srcFile.getName());
  // 判斷源文件是否存在
  if (!srcFile.exists()) {
   this.setMessage("源文件不存在！");
   return false;
  } else if (!srcFile.isFile()) {
   this.setMessage("源文件格式錯！");
   return false;
  }
  // 判斷源文件是否存在
  if (!desDir.exists()) {
   this.setMessage("目標目錄不存在！");
   return false;
  } else if (!desDir.isDirectory()) {
   this.setMessage("不是有效的目錄！");
   return false;
  }
  BufferedReader reader = null;
  BufferedWriter writer = null;
  String str;
  try {
   reader = new BufferedReader(new FileReader(srcFile));
   writer = new BufferedWriter(new FileWriter(desFile));
   // 判斷目標文件是否存在及其格式，不存在就創建，格式不對先刪除，存在就替代
   if (!desFile.exists() || !desFile.isFile()) {
    if (desFile.exists()) {
     desFile.delete();
    }
    desFile.createNewFile();
   }
   // 從源文件讀取數據，並寫入目標文件
   str = reader.readLine();
   while (str != null) {
    writer.write(str);
    writer.newLine();
    str = reader.readLine();
   }
  } catch (IOException e) {
   this.setMessage(e.getMessage());
   return false;
  } finally {
   if (reader != null) {
    try {
     reader.close();
    } catch (IOException e) {
     this.setMessage(e.getMessage());
    }
   }
   if (writer != null) {
    try {
     writer.close();
    } catch (IOException e) {
     this.setMessage(e.getMessage());
    }
   }
  }
  return true;
}
private List fileList = new ArrayList();

/**
  * 列出所有文件
  * @param srcFile
  */
private void file(File srcFile) {
  if (srcFile.isDirectory()) {
   String[] files = srcFile.list();

   for (int i = 0; i < files.length; i++) {
    File f = new File(srcFile + "/" + files);
    // 如果是文件加入列表，否則遞歸列出
    if (f.isFile()) {
     fileList.add(f);
    } else
     file(f);
   }
  }else this.setMessage(srcFile.getAbsolutePath()+"不是目錄");
}
/**
  * 建立目錄
  * @param des
  * @throws IOException
  */private void mkdir(File des) {
  if (!des.exists() || !des.isDirectory()) {
   mkdir(des.getParentFile());
   if (des.exists()) {
    des.delete();
   }
   des.mkdir();
  }
}
/**
  * 複製目錄  將源目錄下所有文件拷貝到目標目錄下
  * @param src  源目錄
   * @param des  目標目錄
  */
public boolean copyDir(String src, String des) {
  File srcFile = new File(src);
  if (!srcFile.exists()) {
   this.setMessage("源目錄不存在！");
   return false;
  } else if (!srcFile.isDirectory()) {
   this.setMessage(src+"不是有效的目錄！");
   return false;
  }
  file(srcFile);

  for (int i = 0; i < fileList.size(); i++) {
   String srcName = ((File) fileList.get(i)).getPath();
   String desName = srcName.substring(src.length(), srcName.length());
   desName = des + desName;
   File dir=new File(desName).getParentFile();
   mkdir(dir);

   if(!copyFile(srcName, dir.getPath())){
    return false;
   }
  }
  return true;
}
public static void main(String[] args) {

  FileCopy t = new FileCopy();
  System.out.println(t.copyFile("D:/aaa.txt","E:"));
  String src="D:/asdf";
  String des="E:/adf";
  System.out.println(t.copyDir(src, des));
  System.out.println(t.getMessage());
}

}




/**
     * Description: 獲取GMT8時間
     * @return 將當前時間轉換爲GMT8時區後的Date
     */
    public static Date getGMT8Time(){
        Date gmt8 = null;
        try {
            Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+8"),Locale.CHINESE);
            Calendar day = Calendar.getInstance();
            day.set(Calendar.YEAR, cal.get(Calendar.YEAR));
            day.set(Calendar.MONTH, cal.get(Calendar.MONTH));
            day.set(Calendar.DATE, cal.get(Calendar.DATE));
            day.set(Calendar.HOUR_OF_DAY, cal.get(Calendar.HOUR_OF_DAY));
            day.set(Calendar.MINUTE, cal.get(Calendar.MINUTE));
            day.set(Calendar.SECOND, cal.get(Calendar.SECOND));
            gmt8 = day.getTime();
        } catch (Exception e) {
            System.out.println("獲取GMT8時間 getGMT8Time() error !");
            e.printStackTrace();
            gmt8 = null;
        }
        return  gmt8;
    }




import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
/**
* ReadProperties.java
* Description: 讀取操作屬性配置文件
* @author li.b
* @version 2.0
* Jun 26, 2008
*/
public class ReadProperties {

    /**
     * Description: 獲取屬性配置文件
     * @param path 資源文件路徑
     * @return    Properties Object
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static Properties getProperties(String path) throws FileNotFoundException, IOException{
        Properties props = null;
        File file = new File(path);
        if(file.exists() && file.isFile()){
            props = new Properties();
            props.load(new FileInputStream(file));
        }else{
            System.out.println(file.toString() + "不存在！");
        }
        return props;
    }

    /**
     * Description: 從屬性文件獲取值
     * @param props Properties Object
     * @param key
     * @return 通過key匹配到的value
     */
    public static String getValue(Properties props,String key,String encod){
        String result = "";
        String en = "";
        String localEN = System.getProperty("file.encoding");
        if(encod !=null && !encod.equals("") ){
            en = encod;
        }else{
            en = localEN;
        }
        try {
            key = new String(key.getBytes(en),"ISO-8859-1");
            result = props.getProperty(key);
            if(!result.equals("")){
                    result = new String(result.getBytes("ISO-8859-1"),en);               
            }
        } catch (Exception e) {
        }finally{
            if(result == null)result = "";
            return result;
        }
    }

    public static String getValue(Properties props,String key){
        return getValue(props, key, "");
    }

}






import java.lang.reflect.Array;
import java.util.Date;

public class TestCast {

    /**
     * @param args
     */
    //public static void main(String[] args) {
             /** *//**
              *
              * 一般情況下數組和數組是不能直接進行轉換的,例如:
              * Object[] t1={"1","2"};
              * String[] t2=(String[])t1;//這裏會出現轉換錯誤
              *
              * 下面提供了一種方式進行轉換
              */

             //1.0測試一般基礎類
    /*        Object[] t1={"1","2","3","4","5"};
            String[] m1=(String[])TestCast.cast(t1,String.class);
             for(int i=0;i<m1.length;i++)
                 System.out.println(m1);

             //2.0測試複雜對象
            Object[] t2={new Date(1000),new Date(2000)};
            Date[] m2=(Date[])TestCast.cast(t2,Date.class);
             for(int i=0;i<m2.length;i++)
                 System.out.println(m2.toString());*/
    //    }


         /** *//**
          * 將數組array轉換成clss代表的類型後返回
          * @param array 需要轉換的數組
          * @param clss  要轉換成的類型
          * @return  轉換後的數組
          */
         public  static Object cast(Object array,Class clss){
             if(null==clss)
                 throw new IllegalArgumentException("argument clss cannot be null");
             if(null==array)
                 throw new IllegalArgumentException("argument array cannot be null");
             if(false==array.getClass().isArray())
                 throw new IllegalArgumentException("argument array must be array");

             Object[] src=(Object[])array;
             Object[] dest=(Object[])Array.newInstance(clss, src.length);
             System.arraycopy(src, 0, dest, 0, src.length);
             return dest;
         }
}





處理特殊符號的工具類，這個類是從sturts源碼裏挖出來的
/**
* DealingCharacter.java
* Description:
* @author li.b
* @version 2.0
* Jun 27, 2008
*/
public class DealingCharacter {

    /**
     * Description: 轉譯特殊符號標籤
     * @param value 需要處理的字符串
     * @return
     */
     public static String filter(String value)
        {
            if(value == null || value.length() == 0)
                return value;
            StringBuffer result = null;
            String filtered = null;
            for(int i = 0; i < value.length(); i++)
            {
                filtered = null;
                switch(value.charAt(i))
                {
                case 60: // '<'
                    filtered = "&lt;";
                    break;

                case 62: // '>'
                    filtered = "&gt;";
                    break;

                case 38: // '&'
                    filtered = "&amp;";
                    break;

                case 34: // '"'
                    filtered = "&quot;";
                    break;

                case 39: // '\''
                    filtered = "&#39;";
                    break;
                }
                if(result == null)
                {
                    if(filtered != null)
                    {
                        result = new StringBuffer(value.length() + 50);
                        if(i > 0)
                            result.append(value.substring(0, i));
                        result.append(filtered);
                    }
                } else
                if(filtered == null)
                    result.append(value.charAt(i));
                else
                    result.append(filtered);
            }

            return result != null ? result.toString() : value;
        }

     public static void main(String[] args) {
         System.out.println(DealingCharacter.filter("<HTML>sdfasfas</HTML>"));
    }
}





小標籤
import java.io.IOException;
import java.util.List;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;

import com.formcontent.show.ShowFormTypeOperateDb;
import com.forum.hibernatePrj.Space;
public class OutPrintForumType extends TagSupport{
  public int doStartTag() throws JspException
  {
  String printStr="";
  ShowFormTypeOperateDb showtype=new ShowFormTypeOperateDb();
  List list=showtype.getForumType();
if(list!=null&&list.size()>0)
{

  for(int i=0;i <list.size();i++)
  {
  Space space=(Space)list.get(i);
  if(space!=null)
  {
printStr+=" <tr> <td>"+" <div align='left' class='TypeCss'>"+

      space.getSpaceName()+"  "+space.getSpaceDescription()+" <br/>目前登陸總人數:"+i+"    人訪問數:"+i+"人 </div> </td> </tr>"
      +" <tr> <td> </td> </tr>";
  }
    }
}
  try {
pageContext.getOut().write(printStr);
} catch (IOException e) {
e.printStackTrace();
}
    return super.doStartTag();
  }

}






正則表達式用於字符串處理、表單驗證等場合，實用高效。現將一些常用的表達式收集於此，以備不時之需。

匹配中文字符的正則表達式： [\u4e00-\u9fa5]
評註：匹配中文還真是個頭疼的事，有了這個表達式就好辦了

匹配雙字節字符(包括漢字在內)：[^\x00-\xff]
評註：可以用來計算字符串的長度（一個雙字節字符長度計2，ASCII字符計1）

匹配空白行的正則表達式：\n\s*\r
評註：可以用來刪除空白行

匹配HTML標記的正則表達式： <(\S*?)[^>]*>.*? </\1> | <.*? />
評註：網上流傳的版本太糟糕，上面這個也僅僅能匹配部分，對於複雜的嵌套標記依舊無能爲力

匹配首尾空白字符的正則表達式：^\s* |\s*$
評註：可以用來刪除行首行尾的空白字符(包括空格、製表符、換頁符等等)，非常有用的表達式

匹配Email地址的正則表達式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
評註：表單驗證時很實用

匹配網址URL的正則表達式：[a-zA-z]+://[^\s]*
評註：網上流傳的版本功能很有限，上面這個基本可以滿足需求

匹配帳號是否合法(字母開頭，允許5-16字節，允許字母數字下劃線)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
評註：表單驗證時很實用

匹配國內電話號碼：\d{3}-\d{8} |\d{4}-\d{7}
評註：匹配形式如 0511-4405222 或 021-87888822

匹配騰訊QQ號：[1-9][0-9]{4,}
評註：騰訊QQ號從10000開始

匹配中國郵政編碼：[1-9]\d{5}(?!\d)
評註：中國郵政編碼爲6位數字

匹配身份證：\d{15} |\d{18}
評註：中國的身份證爲15位或18位

匹配ip地址：\d+\.\d+\.\d+\.\d+
評註：提取ip地址時有用

匹配特定數字：
^[1-9]\d*$　 　 //匹配正整數
^-[1-9]\d*$ 　 //匹配負整數
^-?[1-9]\d*$　　 //匹配整數
^[1-9]\d* |0$　 //匹配非負整數（正整數 + 0）
^-[1-9]\d* |0$　　 //匹配非正整數（負整數 + 0）
^[1-9]\d*\.\d* |0\.\d*[1-9]\d*$　　 //匹配正浮點數
^-([1-9]\d*\.\d* |0\.\d*[1-9]\d*)$　 //匹配負浮點數
^-?([1-9]\d*\.\d* |0\.\d*[1-9]\d* |0?\.0+ |0)$　 //匹配浮點數
^[1-9]\d*\.\d* |0\.\d*[1-9]\d* |0?\.0+ |0$　　 //匹配非負浮點數（正浮點數 + 0）
^(-([1-9]\d*\.\d* |0\.\d*[1-9]\d*)) |0?\.0+ |0$　　//匹配非正浮點數（負浮點數 + 0）
評註：處理大量數據時有用，具體應用時注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26個英文字母組成的字符串
^[A-Z]+$　　//匹配由26個英文字母的大寫組成的字符串
^[a-z]+$　　//匹配由26個英文字母的小寫組成的字符串
^[A-Za-z0-9]+$　　//匹配由數字和26個英文字母組成的字符串
^\w+$　　//匹配由數字、26個英文字母或者下劃線組成的字符串




/**
     * 將數組轉成字符串 在調試或記錄日誌時用到
     *
     * @param array
     * @return
     */
    public static String byte2string(byte[] array) {
        StringBuilder sb = new StringBuilder();

        sb.append("Length " + array.length + " Content ");

        for (int i = 0; i < leng; i++) {
            sb = sb.append(String.format("%02X", array)).append(":");
        }
        int ind = sb.lastIndexOf(":");
        sb.delete(ind, ind + 1);
        return sb.toString();
    }





import java.util.Arrays;
import java.util.Random;

/**
* <code>RandomUtil</code> - Random Tool Class.
* @author SageZk
* @version 1.0
*/
public class RandomUtil {

    private RandomUtil() {}

    private static Random rnd = null;

    /**
     * 初始化隨機數發生器。
     */
    private static void initRnd() {
        if (rnd == null) rnd = new Random();
    }

    /**
     * 計算並返回無重複值的以 <code>min</code> 爲下限 <code>max</code> 爲上限的隨機整數數組。
     * @param min 隨機整數下限（包含）
     * @param max 隨機整數上限（包含）
     * @param len 結果數組長度
     * @return 結果數組
     */
    public static int[] getLotteryArray(int min, int max, int len) {
        //參數校驗及性能優化
        if (len < 0) return null;  //長度小於 0 的數組不存在
        if (len == 0) return new int[0];  //返回長度爲 0 的數組
        if (min > max) {  //校正參數 min max
            int t = min;
            min = max;
            max = t;
        }
        final int LEN = max - min + 1;  //種子個數
        if (len > LEN) return null;  //如果出現 35 選 36 的情況就返回 null
        //計算無重複值隨機數組
        initRnd();  //初始化隨機數發生器
        int[] seed = new int[LEN];  //種子數組
        for (int i = 0, n = min; i < LEN;) seed[i++] = n++;  //初始化種子數組
        for (int i = 0, j = 0, t = 0; i < len; ++i) {
            j = rnd.nextInt(LEN - i) + i;
            t = seed;
            seed = seed[j];
            seed[j] = t;
        }
        return Arrays.copyOf(seed, len);  //注意：copyOf 需要 JRE1.6
    }

    //Unit Testing
    public static void main(String[] args) {
        final int N = 10000;  //測試次數
        for (int i = 0; i < N; ++i) {
            int[] la = RandomUtil.getLotteryArray(1, 35, 7);
            if (la == null) continue;
            for (int v : la) System.out.printf("%0$02d ", v);
            System.out.println();
        }
    }

}





/*
操作屬性文件，可以爲我們的程序帶來更方便的移植性，下面是一個示例，可以讀、寫、更改屬性
讀採用了兩種方式，一種是採用Properties類，另外一種是採用資源綁定類ResourceBundle類，
下面是源程序，裏面有詳細的註釋：
*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.Properties;
import java.util.ResourceBundle;
/**
*對屬性文件（xx.properties）的操作
*注：屬性文件一定要放在當前工程的根目錄下，也就是放在與src目錄在同一個目錄下（我的JDevelop
*是這樣的）
*/
public class OperatePropertiesFile {
    public OperatePropertiesFile() {
    }
    /**
     *採用Properties類取得屬性文件對應值
     *@parampropertiesFileNameproperties文件名，如a.properties
     *@parampropertyName屬性名
     *@return根據屬性名得到的屬性值，如沒有返回""
     */
    public static String getValueByPropertyName(String propertiesFileName,String propertyName) {
        String s="";
        Properties p=new Properties();//加載屬性文件讀取類
        FileInputStream in;
        try {
            //propertiesFileName如test.properties
            in = new FileInputStream(propertiesFileName);//以流的形式讀入屬性文件
            p.load(in);//屬性文件將該流加入的可被讀取的屬性中
            in.close();//讀完了關閉
            s=p.getProperty(propertyName);//取得對應的屬性值
        } catch (Exception e) {
            e.printStackTrace();
        }
        return s;
    }
    /**
     *採用ResourceBundel類取得屬性文件對應值，這個只能夠讀取，不可以更改及寫新的屬性
     *@parampropertiesFileNameWithoutPostfixproperties文件名，不帶後綴
     *@parampropertyName屬性名
     *@return根據屬性名得到的屬性值，如沒有返回""
     */
    public static String getValueByPropertyName_(String propertiesFileNameWithoutPostfix,String propertyName) {
        String s="";
        //如屬性文件是test.properties，那此時propertiesFileNameWithoutPostfix的值就是test
        ResourceBundle bundel = ResourceBundle.getBundle(propertiesFileNameWithoutPostfix);
        s=bundel.getString(propertyName);
        return s;
    }
    /**
     *更改屬性文件的值，如果對應的屬性不存在，則自動增加該屬性
     *@parampropertiesFileNameproperties文件名，如a.properties
     *@parampropertyName屬性名
     *@parampropertyValue將屬性名更改成該屬性值
     *@return是否操作成功
     */
    public static boolean changeValueByPropertyName(String propertiesFileName,String propertyName,String propertyValue) {
        boolean writeOK=true;
        Properties p=new Properties();
        InputStream in;
        try {

            in = new FileInputStream(propertiesFileName);
            p.load(in);//
            in.close();
            p.setProperty(propertyName,propertyValue);//設置屬性值，如不屬性不存在新建
            //p.setProperty("testProperty","testPropertyValue");
            FileOutputStream out=new FileOutputStream(propertiesFileName);//輸出流
            p.store(out,"");//設置屬性頭，如不想設置，請把後面一個用""替換掉
            out.flush();//清空緩存，寫入磁盤
            out.close();//關閉輸出流
        } catch (Exception e) {
            e.printStackTrace();
        }
        return writeOK;
    }
}




  /**
     * 如果是null，則返回空字符串，如果是非空值則返回該字符串頭尾不爲空白字符的字符串
     *
     * @param str
     */
    public static String toNoNullTrimedString(String str) {
        if (str == null) {
            return "";
        }
        return new String(str.trim());
    }

    /**
     * 如果是null，則返回空字符串，如果是非空值則返回該對象所toString後的字符串
     *
     * @param obj
     */
    public static String toNoNullString(Object obj) {
        if (obj == null)
            return "";
        return obj.toString();
    }

    /**
     * 本方法把一個Throwable的StackTrace作爲一個字符串輸出，以利於對StackTrace的操作。<br />
     * 通常用於把拋出的Exception轉化成字符串進行後續操作。
     */
    public static String exceptionToStackTrace(Throwable throwable) {
        StringBuffer retu = new StringBuffer();
        StackTraceElement[] traces = throwable.getStackTrace();
        for (StackTraceElement ste : traces) {
            retu.append("\n").append(ste.toString());
        }
        return retu.substring(1);
    }





package com.sipgl.eam.utils;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.LinkedHashMap;

/**
* 日期公用處理類
*
* @author SongJun
* @version 1.3
*/
public class DateUtil {
    /**
     * 解析一個日期之間的所有月份
     *
     * @param beginDateStr
     * @param endDateStr
     * @return
     */
    public static ArrayList getMonthList(String beginDateStr, String endDateStr) {
        // 指定要解析的時間格式
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM");
        // 返回的月份列表
        String sRet = "";

        // 定義一些變量
        Date beginDate = null;
        Date endDate = null;

        GregorianCalendar beginGC = null;
        GregorianCalendar endGC = null;
        ArrayList list = new ArrayList();

        try {
            // 將字符串parse成日期
            beginDate = f.parse(beginDateStr);
            endDate = f.parse(endDateStr);

            // 設置日曆
            beginGC = new GregorianCalendar();
            beginGC.setTime(beginDate);

            endGC = new GregorianCalendar();
            endGC.setTime(endDate);

            // 直到兩個時間相同
            while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
                sRet = beginGC.get(Calendar.YEAR) + "-"
                        + (beginGC.get(Calendar.MONTH) + 1);
                list.add(sRet);
                // 以月爲單位，增加時間
                beginGC.add(Calendar.MONTH, 1);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 解析一個日期段之間的所有日期
     *
     * @param beginDateStr
     *            開始日期
     * @param endDateStr
     *            結束日期
     * @return
     */
    public static ArrayList getDayList(String beginDateStr, String endDateStr) {
        // 指定要解析的時間格式
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");

        // 定義一些變量
        Date beginDate = null;
        Date endDate = null;

        Calendar beginGC = null;
        Calendar endGC = null;
        ArrayList list = new ArrayList();

        try {
            // 將字符串parse成日期
            beginDate = f.parse(beginDateStr);
            endDate = f.parse(endDateStr);

            // 設置日曆
            beginGC = Calendar.getInstance();
            beginGC.setTime(beginDate);

            endGC = Calendar.getInstance();
            endGC.setTime(endDate);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

            // 直到兩個時間相同
            while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {

                list.add(sdf.format(beginGC.getTime()));
                // 以日爲單位，增加時間
                beginGC.add(Calendar.DAY_OF_MONTH, 1);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static ArrayList getYearList() {
        ArrayList list = new ArrayList();
        Calendar c = null;
        c = Calendar.getInstance();
        c.setTime(new Date());
        int currYear = Calendar.getInstance().get(Calendar.YEAR);

        int startYear = currYear - 5;
        int endYear = currYear + 10;
        for (int i = startYear; i < endYear; i++) {
            list.add(new Integer(i));
        }
        return list;
    }

    public static int getCurrYear() {
        return Calendar.getInstance().get(Calendar.YEAR);
    }

    /**
     * 得到某一年周的總數
     *
     * @param year
     * @return
     */
    public static LinkedHashMap getWeekList(int year) {
        LinkedHashMap map = new LinkedHashMap();
        Calendar c = new GregorianCalendar();
        c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
        int count = getWeekOfYear(c.getTime());

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String dayOfWeekStart = "";
        String dayOfWeekEnd = "";
        for (int i = 1; i <= count; i++) {
            dayOfWeekStart = sdf.format(getFirstDayOfWeek(year, i));
            dayOfWeekEnd = sdf.format(getLastDayOfWeek(year, i));
            map.put(new Integer(i), "第"+i+"周(從"+dayOfWeekStart + "至" + dayOfWeekEnd+")");
        }
        return map;

    }

    /**
     * 得到一年的總週數
     * @param year
     * @return
     */
    public static int getWeekCountInYear(int year){
        Calendar c = new GregorianCalendar();
        c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
        int count = getWeekOfYear(c.getTime());
        return count;
    }

    /**
     * 取得當前日期是多少周
     *
     * @param date
     * @return
     */
    public static int getWeekOfYear(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setMinimalDaysInFirstWeek(7);
        c.setTime(date);

        return c.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 得到某年某周的第一天
     *
     * @param year
     * @param week
     * @return
     */
    public static Date getFirstDayOfWeek(int year, int week) {
        Calendar c = new GregorianCalendar();
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, Calendar.JANUARY);
        c.set(Calendar.DATE, 1);

        Calendar cal = (GregorianCalendar) c.clone();
        cal.add(Calendar.DATE, week * 7);

        return getFirstDayOfWeek(cal.getTime());
    }

    /**
     * 得到某年某周的最後一天
     *
     * @param year
     * @param week
     * @return
     */
    public static Date getLastDayOfWeek(int year, int week) {
        Calendar c = new GregorianCalendar();
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, Calendar.JANUARY);
        c.set(Calendar.DATE, 1);

        Calendar cal = (GregorianCalendar) c.clone();
        cal.add(Calendar.DATE, week * 7);

        return getLastDayOfWeek(cal.getTime());
    }

    /**
     * 得到某年某月的第一天
     * @param year
     * @param month
     * @return
     */
    public static Date getFirestDayOfMonth(int year,int month){
        month = month-1;
        Calendar   c   =   Calendar.getInstance();  
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, month);

        int day = c.getActualMinimum(c.DAY_OF_MONTH);

        c.set(Calendar.DAY_OF_MONTH, day);
        return c.getTime();

    }

    /**
     * 提到某年某月的最後一天
     * @param year
     * @param month
     * @return
     */
    public static Date getLastDayOfMonth(int year,int month){
        month = month-1;
        Calendar   c   =   Calendar.getInstance();  
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, month);
        int day = c.getActualMaximum(c.DAY_OF_MONTH);
        c.set(Calendar.DAY_OF_MONTH, day);
        return c.getTime();
    }

    /**
     * 取得當前日期所在周的第一天
     *
     * @param date
     * @return
     */
    public static Date getFirstDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
        return c.getTime();
    }

    /**
     * 取得當前日期所在周的最後一天
     *
     * @param date
     * @return
     */
    public static Date getLastDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
        return c.getTime();
    }

}






/**
     * 爲RootPaneContainer組件添加鍵盤事件
     * @param rpc RootPaneContainer組件
     * @param action 需要執行的動作
     * @param keyName 鍵的名稱
     * @param keyCode 鍵的數字代碼
     * @param modifiers 任意修飾符的按位或組合
     */
    public static void registerKeyEvent(RootPaneContainer rpc, Action action, String keyName, int keyCode, int modifiers)
    {
        JRootPane rp = rpc.getRootPane();
        InputMap inputMap = rp.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
        inputMap.put(KeyStroke.getKeyStroke(keyCode, modifiers), keyName);
        rp.getActionMap().put(keyName, action);
    }






// 判斷一個文件是否爲二進制文件
public static boolean isBinary(File file) {
boolean isBinary = false;
try {
FileInputStream fin = new FileInputStream(file);
long len = file.length();
                        for (int j = 0; j < (int) len; j++) {
int t = fin.read();
if (t < 32 && t != 9 && t != 10 && t != 13) {
isBinary = true;
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return isBinary;
}