Java常用工具类---字符编码工具类、数据类型转换工具类

偏执的太偏执、 2022-01-29 10:07 685阅读 0赞 
  1. package com.jarvis.base.util;
  3. import java.io.UnsupportedEncodingException;
  5. /**
  6.  * <p>
  7.  * Title:字符编码工具类
  8.  * </p>
  9.  * <p>
  10.  * Description:
  11.  * </p>
  12.  * <p>
  13.  * Copyright: Copyright (c) 2007
  14.  * </p>
  15.  * <p>
  16.  * Company:
  17.  * </p>
  18.  * 
  19.  * @author:
  20.  * @version 1.0
  21.  */
  22. public class CharTools {
  24.     /**
  25.      * 转换编码 ISO-8859-1到GB2312
  26.      * 
  27.      * @param text
  28.      * @return
  29.      */
  30.     public static final String ISO2GB(String text) {
  31.         String result = "";
  32.         try {
  33.             result = new String(text.getBytes("ISO-8859-1"), "GB2312");
  34.         } catch (UnsupportedEncodingException ex) {
  35.             result = ex.toString();
  36.         }
  37.         return result;
  38.     }
  40.     /**
  41.      * 转换编码 GB2312到ISO-8859-1
  42.      * 
  43.      * @param text
  44.      * @return
  45.      */
  46.     public static final String GB2ISO(String text) {
  47.         String result = "";
  48.         try {
  49.             result = new String(text.getBytes("GB2312"), "ISO-8859-1");
  50.         } catch (UnsupportedEncodingException ex) {
  51.             ex.printStackTrace();
  52.         }
  53.         return result;
  54.     }
  56.     /**
  57.      * Utf8URL编码
  58.      * 
  59.      * @param s
  60.      * @return
  61.      */
  62.     public static final String Utf8URLencode(String text) {
  63.         StringBuffer result = new StringBuffer();
  65.         for (int i = 0; i < text.length(); i++) {
  67.             char c = text.charAt(i);
  68.             if (c >= 0 && c <= 255) {
  69.                 result.append(c);
  70.             } else {
  72.                 byte[] b = new byte[0];
  73.                 try {
  74.                     b = Character.toString(c).getBytes("UTF-8");
  75.                 } catch (Exception ex) {
  76.                 }
  78.                 for (int j = 0; j < b.length; j++) {
  79.                     int k = b[j];
  80.                     if (k < 0)
  81.                         k += 256;
  82.                     result.append("%" + Integer.toHexString(k).toUpperCase());
  83.                 }
  85.             }
  86.         }
  88.         return result.toString();
  89.     }
  91.     /**
  92.      * Utf8URL解码
  93.      * 
  94.      * @param text
  95.      * @return
  96.      */
  97.     public static final String Utf8URLdecode(String text) {
  98.         String result = "";
  99.         int p = 0;
  101.         if (text != null && text.length() > 0) {
  102.             text = text.toLowerCase();
  103.             p = text.indexOf("%e");
  104.             if (p == -1)
  105.                 return text;
  107.             while (p != -1) {
  108.                 result += text.substring(0, p);
  109.                 text = text.substring(p, text.length());
  110.                 if (text == "" || text.length() < 9)
  111.                     return result;
  113.                 result += CodeToWord(text.substring(0, 9));
  114.                 text = text.substring(9, text.length());
  115.                 p = text.indexOf("%e");
  116.             }
  118.         }
  120.         return result + text;
  121.     }
  123.     /**
  124.      * utf8URL编码转字符
  125.      * 
  126.      * @param text
  127.      * @return
  128.      */
  129.     private static final String CodeToWord(String text) {
  130.         String result;
  132.         if (Utf8codeCheck(text)) {
  133.             byte[] code = new byte[3];
  134.             code[0] = (byte) (Integer.parseInt(text.substring(1, 3), 16) - 256);
  135.             code[1] = (byte) (Integer.parseInt(text.substring(4, 6), 16) - 256);
  136.             code[2] = (byte) (Integer.parseInt(text.substring(7, 9), 16) - 256);
  137.             try {
  138.                 result = new String(code, "UTF-8");
  139.             } catch (UnsupportedEncodingException ex) {
  140.                 result = null;
  141.             }
  142.         } else {
  143.             result = text;
  144.         }
  146.         return result;
  147.     }
  149.     /**
  150.      * 编码是否有效
  151.      * 
  152.      * @param text
  153.      * @return
  154.      */
  155.     @SuppressWarnings("unused")
  156.     private static final boolean Utf8codeCheck(String text) {
  157.         String sign = "";
  158.         if (text.startsWith("%e"))
  159.             for (int i = 0, p = 0; p != -1; i++) {
  160.                 p = text.indexOf("%", p);
  161.                 if (p != -1)
  162.                     p++;
  163.                 sign += p;
  164.             }
  165.         return sign.equals("147-1");
  166.     }
  168.     /**
  169.      * 判断是否Utf8Url编码
  170.      * 
  171.      * @param text
  172.      * @return
  173.      */
  174.     public static final boolean isUtf8Url(String text) {
  175.         text = text.toLowerCase();
  176.         int p = text.indexOf("%");
  177.         if (p != -1 && text.length() - p > 9) {
  178.             text = text.substring(p, p + 9);
  179.         }
  180.         return Utf8codeCheck(text);
  181.     }
  183.     /**
  184.      * 测试
  185.      * 
  186.      * @param args
  187.      */
  188.     public static void main(String[] args) {
  190.         // CharTools charTools = new CharTools();
  192.         String url;
  194.         url = "http://www.google.com/search?hl=zh-CN&newwindow=1&q=%E4%B8%AD%E5%9B%BD%E5%A4%A7%E7%99%BE%E7%A7%91%E5%9C%A8%E7%BA%BF%E5%85%A8%E6%96%87%E6%A3%80%E7%B4%A2&btnG=%E6%90%9C%E7%B4%A2&lr=";
  195.         if (CharTools.isUtf8Url(url)) {
  196.             System.out.println(CharTools.Utf8URLdecode(url));
  197.         } else {
  198.             // System.out.println(URLDecoder.decode(url));
  199.         }
  201.         url = "http://www.baidu.com/baidu?word=%D6%D0%B9%FA%B4%F3%B0%D9%BF%C6%D4%DA%CF%DF%C8%AB%CE%C4%BC%EC%CB%F7&tn=myie2dg";
  202.         if (CharTools.isUtf8Url(url)) {
  203.             System.out.println(CharTools.Utf8URLdecode(url));
  204.         } else {
  205.             // System.out.println(URLDecoder.decode(url));
  206.         }
  208.     }
  210. }
  216. package com.jarvis.base.util;
  218. import java.util.List;
  220. /**   
  221. * @Title: ConvertHelper.java 
  222. * @Package com.jarvis.base.util 
  223. * @Description:数据类型转换
  224. * @version V1.0   
  225. */ 
  226. public class ConvertHelper
  227. {
  228.     /**
  229.      * 把字串转化为整数,若转化失败，则返回0
  230.      *
  231.      * @param str
  232.      *            字串
  233.      * @return
  234.      */
  235.     public static int strToInt(String str) {
  236.         if (str == null) {
  237.             return 0;
  238.         }
  240.         try {
  241.             return Integer.parseInt(str);
  242.         } catch (Exception ex) {
  243.             ex.printStackTrace();
  244.             System.err.println(str + "转换成int类型失败，请检查数据来源");
  245.         }
  246.         return 0;
  247.     }
  249.     /**
  250.      * 把字串转化为长整型数,若转化失败，则返回0
  251.      *
  252.      * @param str
  253.      *            要转化为长整型的字串
  254.      * @return
  255.      */
  256.     public static long strToLong(String str) {
  257.         if (str == null) {
  258.             return 0;
  259.         }
  261.         try {
  262.             return Long.parseLong(str);
  263.         } catch (Exception ex) {
  264.             ex.printStackTrace();
  265.             System.err.println(str + "转换成long类型失败，请检查数据来源");
  266.         }
  267.         return 0;
  268.     }
  270.     /**
  271.      * 把字串转化为Float型数据,若转化失败，则返回0
  272.      *
  273.      * @param str
  274.      *            要转化为Float的字串
  275.      * @return
  276.      */
  277.     public static float strToFloat(String str) {
  278.         if (str == null) {
  279.             return 0;
  280.         }
  281.         try {
  282.             return Float.parseFloat(str);
  283.         } catch (Exception ex) {
  284.             ex.printStackTrace();
  285.             System.err.println(str + "转换成float类型失败，请检查数据来源");
  286.         }
  287.         return 0;
  288.     }
  290.     /**
  291.      * 把字串转化为Double型数据，若转化失败，则返回0
  292.      * 
  293.      * @param str
  294.      *            要转化为Double的字串
  295.      * @return
  296.      */
  297.     public static double strToDouble(String str) {
  298.         if (str == null) {
  299.             return 0;
  300.         }
  301.         try {
  302.             return Double.parseDouble(str);
  303.         } catch (Exception ex) {
  304.             ex.printStackTrace();
  305.             System.err.println(str + "转换成double类型失败，请检查数据来源");
  306.         }
  307.         return 0;
  308.     }
  310.     /**
  311.      * 描述：字符转为一个元素的Object数组
  312.      * 
  313.      * @param str
  314.      * @return
  315.      */
  316.     public static Object[] strToArry(String str) {
  317.         if (str == null) {
  318.             return null;
  319.         } else {
  320.             return new Object[] { str };
  321.         }
  322.     }
  324.     /**
  325.      * 对于一个字符串数组，把字符串数组中的每一个字串转换为整数。 返回一个转换后的整型数组，对于每一个字串若转换失败，则对 应的整型值就为0
  326.      *
  327.      * @param strArray
  328.      *            要转化的数组
  329.      * @return
  330.      */
  331.     public static int[] strArrayToIntArray(String[] strArray) {
  332.         int[] intArray = new int[strArray.length];
  333.         for (int i = 0; i < strArray.length; i++) {
  334.             intArray[i] = strToInt(strArray[i]);
  335.         }
  336.         return intArray;
  337.     }
  339.     /**
  340.      * 描述：数组转换为字符串
  341.      * 
  342.      * @param arg0
  343.      *            数组
  344.      * @return
  345.      */
  346.     public static String arrToString(Object[] arg0) {
  347.         if (arg0 == null) {
  348.             return "";
  349.         }
  350.         return arrToString(arg0, ",");
  351.     }
  353.     /**
  354.      * 描述：数据转换为字符串
  355.      * 
  356.      * @param arg0
  357.      *            数组
  358.      * @param arg1
  359.      *            取数组个数
  360.      * @return
  361.      */
  362.     public static String arrToString(Object[] arg0, int arg1) {
  363.         if (arg0 == null) {
  364.             return "";
  365.         }
  366.         return arrToString(arg0, ",", arg1);
  367.     }
  369.     /**
  370.      * 描述：数据转换为字符串
  371.      * 
  372.      * @param arg0
  373.      *            数组
  374.      * @param arg1
  375.      *            间隔符号
  376.      * @return
  377.      */
  378.     public static String arrToString(Object[] arg0, String arg1) {
  379.         return arrToString(arg0, arg1, 0);
  380.     }
  382.     /**
  383.      * 描述：数据转换为字符串
  384.      * 
  385.      * @param arg0
  386.      *            数组
  387.      * @param arg1
  388.      *            间隔符号
  389.      * @param arg2
  390.      *            取数组个数
  391.      * @return
  392.      */
  393.     public static String arrToString(Object[] arg0, String arg1, int arg2) {
  394.         if (arg0 == null || arg0.length == 0) {
  395.             return "";
  396.         } else {
  397.             StringBuffer sb = new StringBuffer();
  398.             int length = arg0.length;
  399.             if (arg2 != 0) {
  400.                 length = arg2;
  401.             }
  402.             for (int i = 0; i < length; i++) {
  403.                 if (arg1 == null)
  404.                     arg1 = "";
  405.                 sb.append(arg0[i]).append(arg1);
  406.             }
  407.             sb.delete(sb.lastIndexOf(arg1), sb.length());
  408.             return sb.toString();
  409.         }
  410.     }
  412.     /**
  413.      * 描述：List转换为字符串
  414.      * 
  415.      * @param list
  416.      *            List数据
  417.      * @param separation
  418.      *            间隔符
  419.      * @return
  420.      */
  421.     public static String listToString(List<?> list) {
  422.         return listToString(list, ",");
  423.     }
  425.     /**
  426.      * 描述：List转换为字符串
  427.      * 
  428.      * @param list
  429.      *            List数据
  430.      * @param separation
  431.      *            间隔符
  432.      * @return
  433.      */
  434.     public static String listToString(List<?> list, String separation) {
  435.         return arrToString(listToStringArray(list), separation);
  436.     }
  438.     /**
  439.      * 描述：字串数据元素包装
  440.      * 
  441.      * @param sArr
  442.      *            字串数据
  443.      * @param pre
  444.      *            前缀
  445.      * @param aft
  446.      *            后缀
  447.      * @return
  448.      */
  449.     public static String[] strArrDoPack(String[] sArr, String pre, String aft) {
  450.         return strArrDoPack(sArr, pre, aft, 1, 0);
  451.     }
  453.     /**
  454.      * 描述：字串数据元素包装
  455.      * 
  456.      * @param sArr
  457.      *            字串数据
  458.      * @param pre
  459.      *            前缀
  460.      * @param aft
  461.      *            后缀
  462.      * @param num
  463.      *            生成个数
  464.      * @return
  465.      */
  466.     public static String[] strArrDoPack(String[] sArr, String pre, String aft, int num) {
  467.         return strArrDoPack(sArr, pre, aft, num, 0);
  468.     }
  470.     /**
  471.      * 描述：字串数据元素包装
  472.      * 
  473.      * @param sArr
  474.      *            字串数据
  475.      * @param pre
  476.      *            前缀
  477.      * @param aft
  478.      *            后缀
  479.      * @param num
  480.      *            生成个数
  481.      * @param step
  482.      *            数字值1：加，-1：减，0：不变
  483.      * @return
  484.      */
  485.     public static String[] strArrDoPack(String[] sArr, String pre, String aft, int num, int step) {
  486.         String[] arr = null;
  487.         if (sArr != null) {
  488.             boolean isAdd = false;
  489.             if (step > 0) {
  490.                 isAdd = true;
  491.             }
  493.             if (num < 0) {
  494.                 num = 1;
  495.             }
  497.             arr = new String[sArr.length * num];
  498.             int icount = 0;
  499.             for (int i = 0; i < num; i++) {
  500.                 for (int j = 0; j < sArr.length; j++) {
  501.                     if (StringHelper.isNotEmpty(pre)) {
  502.                         arr[icount] = pre + sArr[j];
  503.                     }
  504.                     if (StringHelper.isNotEmpty(aft)) {
  505.                         arr[icount] += aft;
  506.                     }
  507.                     icount++;
  508.                 }
  510.                 boolean b = false;
  511.                 if (step != 0) {
  512.                     pre = stepNumInStr(pre, isAdd);
  513.                     b = true;
  514.                 }
  515.                 if (!b) {
  516.                     if (step != 0) {
  517.                         aft = stepNumInStr(aft, isAdd);
  518.                     }
  519.                 }
  520.             }
  522.         }
  523.         return arr;
  524.     }
  526.     /**
  527.      * 描述：生成字符串
  528.      * 
  529.      * @param arg0
  530.      *            字符串元素
  531.      * @param arg1
  532.      *            生成个数
  533.      * @return
  534.      */
  535.     public static String createStr(String arg0, int arg1) {
  536.         if (arg0 == null) {
  537.             return "";
  538.         }
  539.         return createStr(arg0, arg1, ",");
  540.     }
  542.     /**
  543.      * 描述：生成字符串
  544.      * 
  545.      * @param arg0
  546.      *            字符串元素
  547.      * @param arg1
  548.      *            生成个数
  549.      * @param arg2
  550.      *            间隔符号
  551.      * @return
  552.      */
  553.     public static String createStr(String arg0, int arg1, String arg2) {
  554.         if (arg0 == null) {
  555.             return "";
  556.         } else {
  557.             StringBuffer sb = new StringBuffer();
  558.             for (int i = 0; i < arg1; i++) {
  559.                 if (arg2 == null)
  560.                     arg2 = "";
  561.                 sb.append(arg0).append(arg2);
  562.             }
  563.             if (sb.length() > 0) {
  564.                 sb.delete(sb.lastIndexOf(arg2), sb.length());
  565.             }
  567.             return sb.toString();
  568.         }
  569.     }
  571.     /**
  572.      * 描述：生成字符串数据
  573.      * 
  574.      * @param arg0
  575.      *            字符串元素
  576.      * @param arg1
  577.      *            生成个数
  578.      * @param arg2
  579.      *            间隔符号
  580.      * @return
  581.      */
  582.     public static String[] createStrArr(String arg0, int arg1) {
  583.         if (arg0 == null) {
  584.             return null;
  585.         } else {
  586.             String[] arr = new String[arg1];
  587.             for (int i = 0; i < arg1; i++) {
  588.                 arr[i] = arg0;
  589.             }
  591.             return arr;
  592.         }
  593.     }
  595.     /**
  596.      * 描述：只保留字符串的英文字母和“_”号
  597.      * 
  598.      * @param str
  599.      * @return
  600.      */
  601.     public static String replaceAllSign(String str) {
  602.         if (str != null && str.length() > 0) {
  603.             str = str.replaceAll("[^a-zA-Z_]", "");
  604.         }
  605.         return str;
  606.     }
  608.     /**
  609.      * 描述：字串中的数字值加1
  610.      * 
  611.      * @param str
  612.      *            字串
  613.      * @param isAdd
  614.      *            数字值true：加，false：减
  615.      * @return
  616.      */
  617.     public static String stepNumInStr(String str, boolean isAdd) {
  618.         String sNum = str.replaceAll("[^0-9]", ",").trim();
  619.         if (sNum == null || sNum.length() == 0) {
  620.             return str;
  621.         }
  622.         String[] sNumArr = sNum.split(",");
  624.         for (int i = 0; i < sNumArr.length; i++) {
  625.             if (sNumArr[i] != null && sNumArr[i].length() > 0) {
  626.                 int itemp = Integer.parseInt(sNumArr[i]);
  627.                 if (isAdd) {
  628.                     itemp += 1;
  629.                 } else {
  630.                     itemp -= 1;
  631.                 }
  632.                 str = str.replaceFirst(sNumArr[i], String.valueOf(itemp));
  633.                 break;
  634.             }
  635.         }
  637.         return str;
  638.     }
  640.     /**
  641.      * 描述：list 转换为 String[]
  642.      * 
  643.      * @param list
  644.      * @return
  645.      */
  646.     public static String[] listToStringArray(List<?> list) {
  647.         if (list == null || list.size() == 0) {
  648.             return null;
  649.         }
  650.         return (String[]) list.toArray(new String[list.size()]);
  651.     }
  653. }

发表评论

表情：
评论列表 （有 0 条评论，685人围观）

还没有评论，来说两句吧...

相关阅读