JAVA实用工具类
博客专区 > dmrs 的博客 > 博客详情
JAVA实用工具类
dmrs 发表于2年前
JAVA实用工具类
  • 发表于 2年前
  • 阅读 19
  • 收藏 0
  • 点赞 0
  • 评论 0

腾讯云 新注册用户 域名抢购1元起>>>   

        在开发java项目时,经常都需要频繁处理数据,如果能非常合适、严谨的处理数据,那么将对程序有莫大的好处,例如,提高程序的稳定性,而且有时候数据在使用前是必须处理的,否则就会出错。例如,在操作前对被除数的处理(如果是0怎么办)、字符串转化、编码转换等,针对项目开发中对数据的频繁操作,在我们程序的开发过程中是很有必要对这些处理数据的工具方法进行统一归类使用的,而下面的这个工具类就封装了很多对基础数据的处理操作的方法。因为方法很多,为了方便查询,我先对方法及其实现的功能列了一个清单,如下:

        同时也希望大家能把自己使用的工具类发上来共享,谢谢。

 

一、功能方法目录清单:

1、getString(String sSource)的功能是判断参数是否为空,为空返回"",否则返回其值;

2、getString(int iSource)的功能是判断参数是否为0,为0则返回"",否则返回其值;

3、GBKtoISO(String s)的功能是进行编码转换,由GBK转为 iso-8859-1;

4、ISOtoGBK(String s)的功能是进行编码转换,由iso-8859-1 转为 GBK;

5、getArray(String[] aSource)的功能是判断参数是否为空,为空则返回一个长度为0的字符串数组,否则返回其值;

6、getInt(String sSource)的功能是判断参数是否为空,为空则返回0,不为空则返回其整型值;

7、getIntArray(String[] aSource)的功能是判断参数是否为空,为空则返回一个长度为0的整形数组,否则返回其值;

8、getDouble(String sSource)的功能是判断参数是否为空,为空则返回0,不为空则返回其整型值;

9、isContain(String sSource, String sItem)的功能是查找以逗号分隔的源字符串是否包含给定字符串;

10、isContain(String[] aSource, String sItem)的功能是查找源字符串数组中是否包含给定字符串;

11、delete(String source, String subString)的功能是将指定字符串从源字符串中删除掉,并返回替换后的结果字符串;

12、replace(String source, String oldString, String newString)的功能是用新字符串替换源字符串中的旧字符串;

13、increaseOne(String sSource)的功能是将给定的源字符串加1 例如:“0001” 经本函数转换后返回为“0002”;

14、intToStr(int val, int len)的功能是将给定的整数转化成字符串,结果字符串的长度为给定长度,不足位数的左端补"0";

15、arrayAddSign(String[] aSource, String sChar)的功能是将数组中的每个元素两端加上给定的符号;

16、arrayToString(String[] aSource)的功能是将数组中的元素连成一个以逗号分隔的字符串;

17、arrayToString(int[] aSource)的功能是将数组中的元素连成一个以逗号分隔的字符串;

18、arrayToString(String[] aSource, String sChar)的功能是将数组中的元素连成一个以给定字符分隔的字符串;

19、arrayAppend(String[] array1, String[] array2)的功能是将两个字符串的所有元素连结为一个字符串数组;

20、arrayAppend(Object[] array1, Object[] array2)的功能是将两个对象数组中的所有元素连结为一个对象数组;

21、strToArray(String sSource)的功能是拆分以逗号分隔的字符串,并存入String数组中;

22、strToArray(String sSource, String sChar)的功能是拆分以给定分隔符分隔的字符串,并存入字符串数组中;

23、strToArray(String sSource, char sChar)的功能是拆分以给定分隔符分隔的字符串,并存入整型数组中;

24、addMark(String sSource)的功能是将以逗号分隔的字符串的每个元素加上单引号 如: 1000,1001,1002 --> '1000','1001','1002';

25、deleteFile(String fileName)的功能是删除磁盘上的文件;

26、isNumber(String strInput)的功能是判断字符串是否可转换成数字;

27、isIp(String strIp)的功能是判断输入的字符是否是IP地址的形式;

  1. import java.io.File;
  2. import java.io.Serializable;
  3. import java.math.BigDecimal;
  4. import java.util.Hashtable;
  5. import java.util.Set;
  6. import java.util.StringTokenizer;
  7. import java.util.Vector;
  8. /*******************************************************************************
  9.  * 文件名称:Function.java<br>
  10.  * 功能描述:工具类,封装一些常用的操作<br>
  11.  ******************************************************************************/
  12. public class Function implements Serializable {
  13.     private static final long serialVersionUID = 1L;
  14.     public Function() {
  15.     }
  16.     public static void main(String args[]) {
  17.     }
  18.     /**
  19.      * 判断参数是否为空,为空则返回"",否则返回其值
  20.      * @param sSource 源字符串
  21.      * @return 字符串
  22.      */
  23.     public String getString(String sSource) {
  24.         String sReturn = "";
  25.         if (sSource != null) {
  26.             sReturn = sSource;
  27.         }
  28.         return sReturn;
  29.     }
  30.     /**
  31.      * 判断参数是否为0,为0则返回"",否则返回其值
  32.      * @param iSource 源字符串
  33.      * @return 字符串
  34.      */
  35.     public static String getString(int iSource) {
  36.         if (iSource == 0) {
  37.             return "";
  38.         } else {
  39.             return "" + iSource;
  40.         }
  41.     }
  42.     /**
  43.      * 转码:GBK ----> iso-8859-1
  44.      * @param s 转码字段
  45.      * @return 转码后的字段
  46.      */
  47.     public static String GBKtoISO(String s) {
  48.         try {
  49.             s = new String(s.getBytes("GBK"), "iso-8859-1");
  50.         } catch (Exception e) {
  51.         }
  52.         return s;
  53.     }
  54.     /**
  55.      * 转码:iso-8859-1 ----> GBK
  56.      * @param s 转码字段
  57.      * @return 转码后的字段
  58.      */
  59.     public static String ISOtoGBK(String s) {
  60.         try {
  61.             s = new String(s.getBytes("iso-8859-1"), "GBK");
  62.         } catch (Exception e) {
  63.         }
  64.         return s;
  65.     }
  66.     /**
  67.      * 判断参数是否为空,为空则返回一个长度为0的字符串数组,否则返回其值
  68.      * @param aSource 源字符串数组
  69.      * @return 字符串
  70.      */
  71.     public String[] getArray(String[] aSource) {
  72.         String aReturn[] = new String[0];
  73.         if (aSource != null) {
  74.             aReturn = aSource;
  75.         }
  76.         return aReturn;
  77.     }
  78.     /**
  79.      * 判断参数是否为空,为空则返回0,不为空则返回其整型值
  80.      * @param sSource  源字符串
  81.      * @return 整型数
  82.      */
  83.     public int getInt(String sSource) {
  84.         int iReturn = 0;
  85.         if (sSource != null && !sSource.equals("")) {
  86.             iReturn = Integer.parseInt(sSource);
  87.         }
  88.         return iReturn;
  89.     }
  90.     /**
  91.      * 判断参数是否为空,为空则返回一个长度为0的整形数组,否则返回其值
  92.      * @param aSource 源字符串数组
  93.      * @return 整形数组
  94.      */
  95.     public int[] getIntArray(String[] aSource) {
  96.         int iReturn[] = new int[0];
  97.         if (aSource != null) {
  98.             iReturn = new int[aSource.length];
  99.             for (int i = 0; i < aSource.length; i++) {
  100.                 iReturn[i] = Integer.parseInt(aSource[i]);
  101.             }
  102.         }
  103.         return iReturn;
  104.     }
  105.     /**
  106.      * 判断参数是否为空,为空则返回0,不为空则返回其整型值 
  107.      * @param sSource 源字符串
  108.      * @return Double数
  109.      */
  110.     public double getDouble(String sSource) {
  111.         double dReturn = 0.00;
  112.         if (sSource != null && !sSource.equals("")) {
  113.             dReturn = (new Double(sSource)).doubleValue();
  114.         }
  115.         return dReturn;
  116.     }
  117.     /**
  118.      * 查找以逗号分隔的源字符串是否包含给定字符串
  119.      * @param sSource :源字符串
  120.      * @param sItem :子串
  121.      * @return 是否包含
  122.      */
  123.     public boolean isContain(String sSource, String sItem) {
  124.         boolean isReturn = false;
  125.         StringTokenizer st = null;
  126.         st = new StringTokenizer(sSource, ",");
  127.         while (st.hasMoreTokens()) {
  128.             if (sItem.equals(st.nextToken())) {
  129.                 isReturn = true;
  130.                 break;
  131.             }
  132.         }
  133.         return isReturn;
  134.     }
  135.     /**
  136.      * 查找源字符串数组中是否包含给定字符串
  137.      * @param aSource :源字符串数组
  138.      * @param sItem :子串
  139.      * @return 是否包含
  140.      */
  141.     public boolean isContain(String[] aSource, String sItem) {
  142.         boolean isReturn = false;
  143.         for (int i = 0; i < aSource.length; i++) {
  144.             if (sItem.equals(aSource[i])) {
  145.                 isReturn = true;
  146.                 break;
  147.             }
  148.         }
  149.         return isReturn;
  150.     }
  151.     /**
  152.      * 将指定字符串从源字符串中删除掉,并返回替换后的结果字符串
  153.      * @param source 源字符串
  154.      * @param subString 要删除的字符
  155.      * @return 替换后的字符串
  156.      */
  157.     public String delete(String source, String subString) {
  158.         StringBuffer output = new StringBuffer();
  159.          //源字符串长度
  160.         int lengthOfSource = source.length();
  161.         //开始搜索位置
  162.         int posStart = 0
  163.         //搜索到老字符串的位置
  164.         int pos; 
  165.         while ((pos = source.indexOf(subString, posStart)) >= 0) {
  166.             output.append(source.substring(posStart, pos));
  167.             posStart = pos + 1;
  168.         }
  169.         if (posStart < lengthOfSource) {
  170.             output.append(source.substring(posStart));
  171.         }
  172.         return output.toString();
  173.     }
  174.     /**
  175.      * 此函数有三个输入参数,源字符串(将被操作的字符串),原字符串中被替换的字符串(旧字符串)
  176.      * 替换的字符串(新字符串),函数接收源字符串、旧字符串、新字符串三个值后,
  177.      * 用新字符串代替源字符串中的旧字符串并返回结果
  178.      * @param source 源字符串
  179.      * @param oldString 旧字符串
  180.      * @param newString 新字符串
  181.      * @return 替换后的字符串
  182.      */
  183.     public static String replace(String source, String oldString,
  184.             String newString) {
  185.         StringBuffer output = new StringBuffer();
  186.         int lengthOfSource = source.length(); // 源字符串长度
  187.         int lengthOfOld = oldString.length(); // 老字符串长度
  188.         int posStart = 0// 开始搜索位置
  189.         int pos; // 搜索到老字符串的位置
  190.         while ((pos = source.indexOf(oldString, posStart)) >= 0) {
  191.             output.append(source.substring(posStart, pos));
  192.             output.append(newString);
  193.             posStart = pos + lengthOfOld;
  194.         }
  195.         if (posStart < lengthOfSource) {
  196.             output.append(source.substring(posStart));
  197.         }
  198.         return output.toString();
  199.     }
  200.     /**
  201.      * 将给定的源字符串加1 例如:“0001” 经本函数转换后返回为“0002”
  202.      * @param sSource :源字符串
  203.      * @return 返回字符串
  204.      */
  205.     public String increaseOne(String sSource) {
  206.         String sReturn = null;
  207.         int iSize = 0;
  208.         iSize = sSource.length();
  209.         long l = (new Long(sSource)).longValue();
  210.         l++;
  211.         sReturn = String.valueOf(l);
  212.         for (int i = sReturn.length(); i < iSize; i++) {
  213.             sReturn = "0" + sReturn;
  214.         }
  215.         return sReturn;
  216.     }
  217.     /**
  218.      * 将给定的整数转化成字符串,结果字符串的长度为给定长度,不足位数的左端补"0"
  219.      * 例如val=10,len=5,那么生成的字符串为"00010"
  220.      * @param val 将被转化成字符串的整数
  221.      * @param len 转化后的长度
  222.      * @return String 返回值
  223.      */
  224.     public String intToStr(int val, int len) {
  225.         String sReturn = new String();
  226.         sReturn = String.valueOf(val);
  227.         if (sReturn.length() < len) {
  228.             for (int i = len - sReturn.length(); i > 0; i--) {
  229.                 sReturn = "0" + sReturn;
  230.             }
  231.         }
  232.         return sReturn;
  233.     }
  234.     /**
  235.      * 将数组中的每个元素两端加上给定的符号
  236.      * @param aSource 源数组
  237.      * @param sChar 符号
  238.      * @return 处理后的字符串数组
  239.      */
  240.     public String[] arrayAddSign(String[] aSource, String sChar) {
  241.         String aReturn[] = new String[aSource.length];
  242.         for (int i = 0; i < aSource.length; i++) {
  243.             aReturn[i] = sChar + aSource[i] + sChar;
  244.         }
  245.         return aReturn;
  246.     }
  247.     /**
  248.      * 将数组中的元素连成一个以逗号分隔的字符串
  249.      * @param aSource 源数组
  250.      * @return 字符串
  251.      */
  252.     public String arrayToString(String[] aSource) {
  253.         String sReturn = "";
  254.         for (int i = 0; i < aSource.length; i++) {
  255.             if (i > 0) {
  256.                 sReturn += ",";
  257.             }
  258.             sReturn += aSource[i];
  259.         }
  260.         return sReturn;
  261.     }
  262.     /**
  263.      * 将数组中的元素连成一个以逗号分隔的字符串
  264.      * @param aSource 源数组
  265.      * @return 字符串
  266.      */
  267.     public String arrayToString(int[] aSource) {
  268.         String sReturn = "";
  269.         for (int i = 0; i < aSource.length; i++) {
  270.             if (i > 0) {
  271.                 sReturn += ",";
  272.             }
  273.             sReturn += aSource[i];
  274.         }
  275.         return sReturn;
  276.     }
  277.     /**
  278.      * 将数组中的元素连成一个以给定字符分隔的字符串
  279.      * @param aSource 源数组
  280.      * @param sChar 分隔符
  281.      * @return 字符串
  282.      */
  283.     public String arrayToString(String[] aSource, String sChar) {
  284.         String sReturn = "";
  285.         for (int i = 0; i < aSource.length; i++) {
  286.             if (i > 0) {
  287.                 sReturn += sChar;
  288.             }
  289.             sReturn += aSource[i];
  290.         }
  291.         return sReturn;
  292.     }
  293.     /**
  294.      * 将两个字符串的所有元素连结为一个字符串数组
  295.      * @param array1 源字符串数组1
  296.      * @param array2 源字符串数组2
  297.      * @return String[]
  298.      */
  299.     public String[] arrayAppend(String[] array1, String[] array2) {
  300.         int iLen = 0;
  301.         String aReturn[] = null;
  302.         if (array1 == null) {
  303.             array1 = new String[0];
  304.         }
  305.         if (array2 == null) {
  306.             array2 = new String[0];
  307.         }
  308.         iLen = array1.length;
  309.         aReturn = new String[iLen + array2.length];
  310.         /**
  311.          * 将第一个字符串数组的元素加到结果数组中
  312.          */
  313.         for (int i = 0; i < iLen; i++) {
  314.             aReturn[i] = array1[i];
  315.         }
  316.         /**
  317.          * 将第二个字符串数组的元素加到结果数组中
  318.          */
  319.         for (int i = 0; i < array2.length; i++) {
  320.             aReturn[iLen + i] = array2[i];
  321.         }
  322.         return aReturn;
  323.     }
  324.     /**
  325.      * 将两个对象数组中的所有元素连结为一个对象数组
  326.      * @param array1 源字符串数组1
  327.      * @param array2 源字符串数组2
  328.      * @return Object[]
  329.      */
  330.     public Object[] arrayAppend(Object[] array1, Object[] array2) {
  331.         int iLen = 0;
  332.         Object aReturn[] = null;
  333.         if (array1 == null) {
  334.             array1 = new Object[0];
  335.         }
  336.         if (array2 == null) {
  337.             array2 = new Object[0];
  338.         }
  339.         iLen = array1.length;
  340.         aReturn = new Object[iLen + array2.length];
  341.         /**
  342.          * 将第一个对象数组的元素加到结果数组中
  343.          */
  344.         for (int i = 0; i < iLen; i++) {
  345.             aReturn[i] = array1[i];
  346.         }
  347.         /**
  348.          * 将第二个对象数组的元素加到结果数组中
  349.          */
  350.         for (int i = 0; i < array2.length; i++) {
  351.             aReturn[iLen + i] = array2[i];
  352.         }
  353.         return aReturn;
  354.     }
  355.     /**
  356.      * 拆分以逗号分隔的字符串,并存入String数组中
  357.      * @param sSource 源字符串
  358.      * @return String[]
  359.      */
  360.     public String[] strToArray(String sSource) {
  361.         String aReturn[] = null;
  362.         StringTokenizer st = null;
  363.         st = new StringTokenizer(sSource, ",");
  364.         aReturn = new String[st.countTokens()];
  365.         int i = 0;
  366.         while (st.hasMoreTokens()) {
  367.             aReturn[i] = st.nextToken();
  368.             i++;
  369.         }
  370.         return aReturn;
  371.     }
  372.     /**
  373.      * 拆分以给定分隔符分隔的字符串,并存入字符串数组中
  374.      * @param sSource  源字符串
  375.      * @param sChar 分隔符
  376.      * @return String[]
  377.      */
  378.     public static String[] strToArray(String sSource, String sChar) {
  379.         String aReturn[] = null;
  380.         StringTokenizer st = null;
  381.         st = new StringTokenizer(sSource, sChar);
  382.         int i = 0;
  383.         aReturn = new String[st.countTokens()];
  384.         while (st.hasMoreTokens()) {
  385.             aReturn[i] = st.nextToken();
  386.             i++;
  387.         }
  388.         return aReturn;
  389.     }
  390.     /**
  391.      * 拆分以给定分隔符分隔的字符串,并存入整型数组中
  392.      * @param sSource 源字符串
  393.      * @param sChar 分隔符
  394.      * @return int[]
  395.      */
  396.     public static int[] strToArray(String sSource, char sChar) {
  397.         int aReturn[] = null;
  398.         StringTokenizer st = null;
  399.         st = new StringTokenizer(sSource, String.valueOf(sChar));
  400.         int i = 0;
  401.         aReturn = new int[st.countTokens()];
  402.         while (st.hasMoreTokens()) {
  403.             aReturn[i] = Integer.parseInt(st.nextToken());
  404.             i++;
  405.         }
  406.         return aReturn;
  407.     }
  408.     /**
  409.      * 将以逗号分隔的字符串的每个元素加上单引号 如: 1000,1001,1002 --> '1000','1001','1002'
  410.      * @param sSource 源串
  411.      * @return String
  412.      */
  413.     public String addMark(String sSource) {
  414.         String sReturn = "";
  415.         StringTokenizer st = null;
  416.         st = new StringTokenizer(sSource, ",");
  417.         if (st.hasMoreTokens()) {
  418.             sReturn += "'" + st.nextToken() + "'";
  419.         }
  420.         while (st.hasMoreTokens()) {
  421.             sReturn += "," + "'" + st.nextToken() + "'";
  422.         }
  423.         return sReturn;
  424.     }
  425.     /**
  426.      * 删除磁盘上的文件
  427.      * @param fileName 文件全路径
  428.      * @return boolean
  429.      */
  430.     public boolean deleteFile(String fileName) {
  431.         File file = new File(fileName);
  432.         return file.delete();
  433.     }
  434.     /**
  435.      * 判断字符串是否可转换成数字
  436.      * @param fileName 源串
  437.      * @return boolean
  438.      */
  439.     public static boolean isNumber(String strInput){
  440.         boolean bRs=false;
  441.         int nRs=0;
  442.         try{
  443.             nRs=Integer.parseInt(strInput);
  444.             bRs=true;
  445.         }catch(Exception e){
  446.             bRs=false;
  447.         }
  448.             return bRs;
  449.     }
  450.     /**
  451.      * 判断输入的字符是否是IP地址的形式
  452.      * @param fileName 源串
  453.      * @return boolean
  454.      */
  455.     public static boolean isIp(String strIp){
  456.         boolean bRs=false;
  457.         int nCount=0;
  458.         try{
  459.             String strTmp="";
  460.             StringTokenizer st=new StringTokenizer(strIp,".");
  461.             while (st.hasMoreElements()){
  462.                 nCount++;
  463.                 strTmp=st.nextToken();
  464.                 if(isBigger("1",strTmp) || isBigger(strTmp,"255"))
  465.                     return false;
  466.             }
  467.             if (nCount==4)
  468.                 bRs=true;
  469.         } catch(Exception e){
  470.             bRs=false;
  471.         }
  472.         return bRs;
  473.     }
  474. }

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

        另外,如果大家有什么好的功能函数,希望大家也能够贴上来分享一下^-^

版权声明:本文为博主原创文章,未经博主允许不得转载。

共有 人打赏支持
粉丝 15
博文 107
码字总数 17344
×
dmrs
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: