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;
    }
}

此类包含的方法已经在实际项目开发中使用经过，这样把日常开发中常常用到的小功能封装到一个公共类里面，即减小了代码量、提升了代码重用率，又能够很方便的查询、使用，统一修改，提升了劳动率，甚至有些结构功能类似的系统间接口小程序均可以直接保留其余接口的功能框架，只改变其中的业务逻辑就能够了，很是方便。