Java使用工具類

 在開發java項目時，常常都須要頻繁處理數據，若是能很是合適、嚴謹的處理數據，那麼將對程序有莫大的好處，例如，提升程序的穩定性，並且有時候數據在使用前是必須處理的，不然就會出錯。例如，在操做前對被除數的處理（若是是0怎麼辦）、字符串轉化、編碼轉換等，針對項目開發中對數據的頻繁操做，在咱們程序的開發過程當中是頗有必要對這些處理數據的工具方法進行統一歸類使用的，而下面的這個工具類就封裝了不少對基礎數據的處理操做的方法。由於方法不少，爲了方便查詢，我先對方法及其實現的功能列了一個清單，以下：

1、功能方法目錄清單：

一、getString(String sSource)的功能是判斷參數是否爲空，爲空返回""，不然返回其值；

二、getString(int iSource)的功能是判斷參數是否爲0，爲0則返回""，不然返回其值；

三、GBKtoISO(String s)的功能是進行編碼轉換，由GBK轉爲 iso-8859-1；

四、ISOtoGBK(String s)的功能是進行編碼轉換，由iso-8859-1 轉爲 GBK；

五、getArray(String[] aSource)的功能是判斷參數是否爲空，爲空則返回一個長度爲0的字符串數組，不然返回其值；

六、getInt(String sSource)的功能是判斷參數是否爲空，爲空則返回0,不爲空則返回其整型值；

七、getIntArray(String[] aSource)的功能是判斷參數是否爲空，爲空則返回一個長度爲0的整形數組，不然返回其值；

八、getDouble(String sSource)的功能是判斷參數是否爲空，爲空則返回0,不爲空則返回其整型值；

九、isContain(String sSource, String sItem)的功能是查找以逗號分隔的源字符串是否包含給定字符串；

十、isContain(String[] aSource, String sItem)的功能是查找源字符串數組中是否包含給定字符串；

十一、delete(String source, String subString)的功能是將指定字符串從源字符串中刪除掉，並返回替換後的結果字符串；

十二、replace(String source, String oldString, String newString)的功能是用新字符串替換源字符串中的舊字符串；

1三、increaseOne(String sSource)的功能是將給定的源字符串加1 例如：「0001」 經本函數轉換後返回爲「0002」；

1四、intToStr(int val, int len)的功能是將給定的整數轉化成字符串，結果字符串的長度爲給定長度,不足位數的左端補"0"；

1五、arrayAddSign(String[] aSource, String sChar)的功能是將數組中的每一個元素兩端加上給定的符號；

1六、arrayToString(String[] aSource)的功能是將數組中的元素連成一個以逗號分隔的字符串；

1七、arrayToString(int[] aSource)的功能是將數組中的元素連成一個以逗號分隔的字符串；

1八、arrayToString(String[] aSource, String sChar)的功能是將數組中的元素連成一個以給定字符分隔的字符串；

1九、arrayAppend(String[] array1, String[] array2)的功能是將兩個字符串的全部元素連結爲一個字符串數組；

20、arrayAppend(Object[] array1, Object[] array2)的功能是將兩個對象數組中的全部元素連結爲一個對象數組；

2一、strToArray(String sSource)的功能是拆分以逗號分隔的字符串,並存入String數組中；

2二、strToArray(String sSource, String sChar)的功能是拆分以給定分隔符分隔的字符串,並存入字符串數組中；

2三、strToArray(String sSource, char sChar)的功能是拆分以給定分隔符分隔的字符串,並存入整型數組中；

2四、addMark(String sSource)的功能是將以逗號分隔的字符串的每一個元素加上單引號 如： 1000,1001,1002 --> '1000','1001','1002'；

2五、deleteFile(String fileName)的功能是刪除磁盤上的文件；

2六、isNumber(String strInput)的功能是判斷字符串是否可轉換成數字；

2七、isIp(String strIp)的功能是判斷輸入的字符是不是IP地址的形式；

import java.io.File;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Hashtable;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;
/*******************************************************************************
 * 文件名稱：Function.java<br>
 * 功能描述：工具類,封裝一些經常使用的操做<br>
 ******************************************************************************/
public class Function implements Serializable {
    private static final long serialVersionUID = 1L;
    public Function() {
    }
    public static void main(String args[]) {
    }
    /**
     * 判斷參數是否爲空，爲空則返回""，不然返回其值
     * @param sSource 源字符串
     * @return 字符串
     */
    public String getString(String sSource) {
        String sReturn = "";
        if (sSource != null) {
            sReturn = sSource;
        }
        return sReturn;
    }
    /**
     * 判斷參數是否爲0，爲0則返回""，不然返回其值
     * @param iSource 源字符串
     * @return 字符串
     */
    public static String getString(int iSource) {
        if (iSource == 0) {
            return "";
        } else {
            return "" + iSource;
        }
    }
    /**
     * 轉碼：GBK ----> iso-8859-1
     * @param s 轉碼字段
     * @return 轉碼後的字段
     */
    public static String GBKtoISO(String s) {
        try {
            s = new String(s.getBytes("GBK"), "iso-8859-1");
        } catch (Exception e) {
        }
        return s;
    }
    /**
     * 轉碼：iso-8859-1 ----> GBK
     * @param s 轉碼字段
     * @return 轉碼後的字段
     */
    public static String ISOtoGBK(String s) {
        try {
            s = new String(s.getBytes("iso-8859-1"), "GBK");
        } catch (Exception e) {
        }
        return s;
    }
    /**
     * 判斷參數是否爲空，爲空則返回一個長度爲0的字符串數組，不然返回其值
     * @param aSource 源字符串數組
     * @return 字符串
     */
    public String[] getArray(String[] aSource) {
        String aReturn[] = new String[0];
        if (aSource != null) {
            aReturn = aSource;
        }
        return aReturn;
    }
    /**
     * 判斷參數是否爲空，爲空則返回0,不爲空則返回其整型值
     * @param sSource  源字符串
     * @return 整型數
     */
    public int getInt(String sSource) {
        int iReturn = 0;
        if (sSource != null && !sSource.equals("")) {
            iReturn = Integer.parseInt(sSource);
        }
        return iReturn;
    }
    /**
     * 判斷參數是否爲空，爲空則返回一個長度爲0的整形數組，不然返回其值
     * @param aSource 源字符串數組
     * @return 整形數組
     */
    public int[] getIntArray(String[] aSource) {
        int iReturn[] = new int[0];
        if (aSource != null) {
            iReturn = new int[aSource.length];
            for (int i = 0; i < aSource.length; i++) {
                iReturn[i] = Integer.parseInt(aSource[i]);
            }
        }
        return iReturn;
    }
    /**
     * 判斷參數是否爲空，爲空則返回0,不爲空則返回其整型值 
     * @param sSource 源字符串
     * @return Double數
     */
    public double getDouble(String sSource) {
        double dReturn = 0.00;
        if (sSource != null && !sSource.equals("")) {
            dReturn = (new Double(sSource)).doubleValue();
        }
        return dReturn;
    }
    /**
     * 查找以逗號分隔的源字符串是否包含給定字符串
     * @param sSource :源字符串
     * @param sItem :子串
     * @return 是否包含
     */
    public boolean isContain(String sSource, String sItem) {
        boolean isReturn = false;
        StringTokenizer st = null;
        st = new StringTokenizer(sSource, ",");
        while (st.hasMoreTokens()) {
            if (sItem.equals(st.nextToken())) {
                isReturn = true;
                break;
            }
        }
        return isReturn;
    }
    /**
     * 查找源字符串數組中是否包含給定字符串
     * @param aSource :源字符串數組
     * @param sItem :子串
     * @return 是否包含
     */
    public boolean isContain(String[] aSource, String sItem) {
        boolean isReturn = false;
        for (int i = 0; i < aSource.length; i++) {
            if (sItem.equals(aSource[i])) {
                isReturn = true;
                break;
            }
        }
        return isReturn;
    }
    /**
     * 將指定字符串從源字符串中刪除掉，並返回替換後的結果字符串
     * @param source 源字符串
     * @param subString 要刪除的字符
     * @return 替換後的字符串
     */
    public String delete(String source, String subString) {
        StringBuffer output = new StringBuffer();
         //源字符串長度
        int lengthOfSource = source.length();
        //開始搜索位置
        int posStart = 0; 
        //搜索到老字符串的位置
        int pos; 
        while ((pos = source.indexOf(subString, posStart)) >= 0) {
            output.append(source.substring(posStart, pos));
            posStart = pos + 1;
        }
        if (posStart < lengthOfSource) {
            output.append(source.substring(posStart));
        }
        return output.toString();
    }
    /**
     * 此函數有三個輸入參數，源字符串(將被操做的字符串),原字符串中被替換的字符串(舊字符串)
     * 替換的字符串(新字符串)，函數接收源字符串、舊字符串、新字符串三個值後，
     * 用新字符串代替源字符串中的舊字符串並返回結果
     * @param source 源字符串
     * @param oldString 舊字符串
     * @param newString 新字符串
     * @return 替換後的字符串
     */
    public static String replace(String source, String oldString,
            String newString) {
        StringBuffer output = new StringBuffer();
        int lengthOfSource = source.length(); // 源字符串長度
        int lengthOfOld = oldString.length(); // 老字符串長度
        int posStart = 0; // 開始搜索位置
        int pos; // 搜索到老字符串的位置
        while ((pos = source.indexOf(oldString, posStart)) >= 0) {
            output.append(source.substring(posStart, pos));
            output.append(newString);
            posStart = pos + lengthOfOld;
        }
        if (posStart < lengthOfSource) {
            output.append(source.substring(posStart));
        }
        return output.toString();
    }
    /**
     * 將給定的源字符串加1 例如：「0001」 經本函數轉換後返回爲「0002」
     * @param sSource :源字符串
     * @return 返回字符串
     */
    public String increaseOne(String sSource) {
        String sReturn = null;
        int iSize = 0;
        iSize = sSource.length();
        long l = (new Long(sSource)).longValue();
        l++;
        sReturn = String.valueOf(l);
        for (int i = sReturn.length(); i < iSize; i++) {
            sReturn = "0" + sReturn;
        }
        return sReturn;
    }
    /**
     * 將給定的整數轉化成字符串，結果字符串的長度爲給定長度,不足位數的左端補"0"
     * 例如val=10，len=5，那麼生成的字符串爲"00010"
     * @param val 將被轉化成字符串的整數
     * @param len 轉化後的長度
     * @return String 返回值
     */
    public String intToStr(int val, int len) {
        String sReturn = new String();
        sReturn = String.valueOf(val);
        if (sReturn.length() < len) {
            for (int i = len - sReturn.length(); i > 0; i--) {
                sReturn = "0" + sReturn;
            }
        }
        return sReturn;
    }
    /**
     * 將數組中的每一個元素兩端加上給定的符號
     * @param aSource 源數組
     * @param sChar 符號
     * @return 處理後的字符串數組
     */
    public String[] arrayAddSign(String[] aSource, String sChar) {
        String aReturn[] = new String[aSource.length];
        for (int i = 0; i < aSource.length; i++) {
            aReturn[i] = sChar + aSource[i] + sChar;
        }
        return aReturn;
    }
    /**
     * 將數組中的元素連成一個以逗號分隔的字符串
     * @param aSource 源數組
     * @return 字符串
     */
    public String arrayToString(String[] aSource) {
        String sReturn = "";
        for (int i = 0; i < aSource.length; i++) {
            if (i > 0) {
                sReturn += ",";
            }
            sReturn += aSource[i];
        }
        return sReturn;
    }
    /**
     * 將數組中的元素連成一個以逗號分隔的字符串
     * @param aSource 源數組
     * @return 字符串
     */
    public String arrayToString(int[] aSource) {
        String sReturn = "";
        for (int i = 0; i < aSource.length; i++) {
            if (i > 0) {
                sReturn += ",";
            }
            sReturn += aSource[i];
        }
        return sReturn;
    }
    /**
     * 將數組中的元素連成一個以給定字符分隔的字符串
     * @param aSource 源數組
     * @param sChar 分隔符
     * @return 字符串
     */
    public String arrayToString(String[] aSource, String sChar) {
        String sReturn = "";
        for (int i = 0; i < aSource.length; i++) {
            if (i > 0) {
                sReturn += sChar;
            }
            sReturn += aSource[i];
        }
        return sReturn;
    }
    /**
     * 將兩個字符串的全部元素連結爲一個字符串數組
     * @param array1 源字符串數組1
     * @param array2 源字符串數組2
     * @return String[]
     */
    public String[] arrayAppend(String[] array1, String[] array2) {
        int iLen = 0;
        String aReturn[] = null;
        if (array1 == null) {
            array1 = new String[0];
        }
        if (array2 == null) {
            array2 = new String[0];
        }
        iLen = array1.length;
        aReturn = new String[iLen + array2.length];
        /**
         * 將第一個字符串數組的元素加到結果數組中
         */
        for (int i = 0; i < iLen; i++) {
            aReturn[i] = array1[i];
        }
        /**
         * 將第二個字符串數組的元素加到結果數組中
         */
        for (int i = 0; i < array2.length; i++) {
            aReturn[iLen + i] = array2[i];
        }
        return aReturn;
    }
    /**
     * 將兩個對象數組中的全部元素連結爲一個對象數組
     * @param array1 源字符串數組1
     * @param array2 源字符串數組2
     * @return Object[]
     */
    public Object[] arrayAppend(Object[] array1, Object[] array2) {
        int iLen = 0;
        Object aReturn[] = null;
        if (array1 == null) {
            array1 = new Object[0];
        }
        if (array2 == null) {
            array2 = new Object[0];
        }
        iLen = array1.length;
        aReturn = new Object[iLen + array2.length];
        /**
         * 將第一個對象數組的元素加到結果數組中
         */
        for (int i = 0; i < iLen; i++) {
            aReturn[i] = array1[i];
        }
        /**
         * 將第二個對象數組的元素加到結果數組中
         */
        for (int i = 0; i < array2.length; i++) {
            aReturn[iLen + i] = array2[i];
        }
        return aReturn;
    }
    /**
     * 拆分以逗號分隔的字符串,並存入String數組中
     * @param sSource 源字符串
     * @return String[]
     */
    public String[] strToArray(String sSource) {
        String aReturn[] = null;
        StringTokenizer st = null;
        st = new StringTokenizer(sSource, ",");
        aReturn = new String[st.countTokens()];
        int i = 0;
        while (st.hasMoreTokens()) {
            aReturn[i] = st.nextToken();
            i++;
        }
        return aReturn;
    }
    /**
     * 拆分以給定分隔符分隔的字符串,並存入字符串數組中
     * @param sSource  源字符串
     * @param sChar 分隔符
     * @return String[]
     */
    public static String[] strToArray(String sSource, String sChar) {
        String aReturn[] = null;
        StringTokenizer st = null;
        st = new StringTokenizer(sSource, sChar);
        int i = 0;
        aReturn = new String[st.countTokens()];
        while (st.hasMoreTokens()) {
            aReturn[i] = st.nextToken();
            i++;
        }
        return aReturn;
    }
    /**
     * 拆分以給定分隔符分隔的字符串,並存入整型數組中
     * @param sSource 源字符串
     * @param sChar 分隔符
     * @return int[]
     */
    public static int[] strToArray(String sSource, char sChar) {
        int aReturn[] = null;
        StringTokenizer st = null;
        st = new StringTokenizer(sSource, String.valueOf(sChar));
        int i = 0;
        aReturn = new int[st.countTokens()];
        while (st.hasMoreTokens()) {
            aReturn[i] = Integer.parseInt(st.nextToken());
            i++;
        }
        return aReturn;
    }
    /**
     * 將以逗號分隔的字符串的每一個元素加上單引號 如： 1000,1001,1002 --> '1000','1001','1002'
     * @param sSource 源串
     * @return String
     */
    public String addMark(String sSource) {
        String sReturn = "";
        StringTokenizer st = null;
        st = new StringTokenizer(sSource, ",");
        if (st.hasMoreTokens()) {
            sReturn += "'" + st.nextToken() + "'";
        }
        while (st.hasMoreTokens()) {
            sReturn += "," + "'" + st.nextToken() + "'";
        }
        return sReturn;
    }
    /**
     * 刪除磁盤上的文件
     * @param fileName 文件全路徑
     * @return boolean
     */
    public boolean deleteFile(String fileName) {
        File file = new File(fileName);
        return file.delete();
    }
    /**
     * 判斷字符串是否可轉換成數字
     * @param fileName 源串
     * @return boolean
     */
    public static boolean isNumber(String strInput){
        boolean bRs=false;
        int nRs=0;
        try{
            nRs=Integer.parseInt(strInput);
            bRs=true;
        }catch(Exception e){
            bRs=false;
        }
            return bRs;
    }
    /**
     * 判斷輸入的字符是不是IP地址的形式
     * @param fileName 源串
     * @return boolean
     */
    public static boolean isIp(String strIp){
        boolean bRs=false;
        int nCount=0;
        try{
            String strTmp="";
            StringTokenizer st=new StringTokenizer(strIp,".");
            while (st.hasMoreElements()){
                nCount++;
                strTmp=st.nextToken();
                if(isBigger("1",strTmp) || isBigger(strTmp,"255"))
                    return false;
            }
            if (nCount==4)
                bRs=true;
        } catch(Exception e){
            bRs=false;
        }
        return bRs;
    }
}

此類包含的方法已經在實際項目開發中使用經過，這樣把日常開發中常常用到的小功能封裝到一個公共類裏面，即減小了代碼量、提升了代碼重用率，又能夠很方便的查詢、使用，統一修改，提升了勞動率，甚至有些結構功能類似的系統間接口小程序均可以直接保留其餘接口的功能框架，只改變其中的業務邏輯就能夠了，很是方便。