1.  import android.annotation.SuppressLint;
  2.  
  3.  import java.io.UnsupportedEncodingException;
  4.  import java.util.ArrayList;
  5.  import java.util.List;
  6.  import java.util.regex.Matcher;
  7.  import java.util.regex.Pattern;
  8.  
  9.  public class StringUtils {
  10.  
  11.      /**
  12.       * 判断ip合法性
  13.       */
  14.      @SuppressLint("NewApi")
  15.      public static boolean isMacthIp(String ip) {
  16.          if (ip != null && !ip.isEmpty()) {
  17.              // 定义正则表达式
  18.              String regex = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
  19.                      + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
  20.                      + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
  21.                      + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$"; // 判断ip地址是否与正则表达式匹配
  22.              if (ip.matches(regex)) {
  23.                  return true;
  24.              }
  25.          }
  26.          return false;
  27.      }
  28.  
  29.      /**
  30.       * 判断字符串是否为空
  31.       */
  32.      public static boolean isEmpty(String str){
  33.          if (str==null || "".equals(str)){
  34.              return true;
  35.          }
  36.          return false;
  37.      }
  38.  
  39.      /**
  40.       * 判断字符串是否为空(包括对"null")
  41.       */
  42.      public static boolean isNullOrEmpty(String str){
  43.          if (str==null || "".equals(str) || "null".equals(str) ){
  44.              return true;
  45.          }
  46.          return false;
  47.      }
  48.  
  49.      /**
  50.       * 判断字符串是否纯数字
  51.       */
  52.      public static boolean isDigital(String str){
  53.          if (!isEmpty(str))
  54.              return str.matches("[0-9]+");
  55.          return false;
  56.      }
  57.  
  58.      /**
  59.       * 计算含有中文的字符串长度
  60.       * @param value 字符串（支持含中文字符串）
  61.       * @return
  62.       */
  63.      public static int length(String value) {
  64.          int valueLength = 0;
  65.          String chinese = "[\u0391-\uFFE5]";
  66.          /* 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1 */
  67.          for (int i = 0; i < value.length(); i++) {
  68.              /* 获取一个字符 */
  69.              String temp = value.substring(i, i + 1);
  70.              /* 判断是否为中文字符 */
  71.              if (temp.matches(chinese)) {
  72.                  /* 中文字符长度为2 */
  73.                  valueLength += 2;
  74.              } else {
  75.                  /* 其他字符长度为1 */
  76.                  valueLength += 1;
  77.              }
  78.          }
  79.          return valueLength;
  80.      }
  81.  
  82.      /**
  83.       * 字符串数组转换List<String>
  84.       * @param items
  85.       * @return
  86.       */
  87.      public static List<String> stringsToList(String[] items) {
  88.          List<String> lists = new ArrayList<String>();
  89.          for(int i=0; i<items.length; i++){
  90.              lists.add(items[i]);
  91.          }
  92.          return lists;
  93.      }
  94.  
  95.      /**
  96.       * 字符串填充，将sour使用fillStr前补或后补满len长度
  97.       * @param sour 待填充字符串，支持含有中文
  98.       * @param fillStr 填充数据
  99.        * @param len 填充完整字符串长度
  100.       * @param isLeft 是否左补填充数据，否则右补填充数据
  101.       * @return
  102.       */
  103.      public static String fill(String sour, String fillStr, int len, boolean isLeft){
  104.          if (sour == null) {
  105.              sour = "";
  106.          }
  107.          int fillLen = len - length(sour);
  108.          String fill = "";
  109.          for (int i=0; i<fillLen; i++) {
  110.              fill = fill + fillStr;
  111.          }
  112.          if (isLeft) {
  113.              return fill + sour;
  114.          } else {
  115.              return sour + fill;
  116.          }
  117.      }
  118.  
  119.      /**
  120.       * 字符串填充，中间填充
  121.       * @param sour 左侧待填充字符串，支持含有中文
  122.       * @param space 填充的数据，一般为* 、空格、——
  123.       * @param lengh 填充完整字符串长度
  124.       * @param modelparams 右侧待填充字符串，支持含有中文
  125.       * @return
  126.       */
  127.      public static String fillMiddle(String sour, String space, int lengh, String modelparams){
  128.          String s, ss = null;
  129.          int lenS = sour.length();
  130.          int lenM = modelparams.length();
  131.          //做非空处理
  132.          if(sour == null) {
  133.              sour = "";
  134.          }
  135.          if(modelparams == null) {
  136.              modelparams = "";
  137.          }
  138.          if (space == "") {
  139.              space = " ";
  140.          }
  141.          //若输入为汉字，则长度取2倍
  142.          if (sour.matches("[\u4e00-\u9fa5]+")) {
  143.              lenS = lenS*2;
  144.          }
  145.          if (modelparams.matches("[\u4e00-\u9fa5]+")) {
  146.              lenM = lenM*2;
  147.          }
  148.          //若输入有数字则，总长度加3
  149.          if (sour.matches("[0-9]") && modelparams.matches("[0-9]")) {
  150.              lengh = lengh + 4;
  151.          }
  152.          //长度保护
  153.          if (lengh < (lenS + lenM)) {
  154.              new Exception("哥们，长度设置太小了");
  155.          }
  156.  
  157.          s = fill(modelparams, space, lengh - lenS-lenM, true);
  158.          ss = sour + s +"\n";
  159.  
  160.          return ss;
  161.      }
  162.  
  163.      /**
  164.       * 字符串填充
  165.       *
  166.       * @param strData 待填充字符串，不支持含有中文
  167.       * @param nLen
  168.       * @param
  169.       * @param nOption
  170.       *            0:左侧填充; 1:右侧填充; 2:两边填充
  171.       * @return
  172.       */
  173.      public static String paddingString(String strData, int nLen, String subStr,
  174.                                         int nOption) {
  175.          int i, addCharLen;
  176.  
  177.          String strHead = "";
  178.          String strEnd = "";
  179.  
  180.          i = strData.length();
  181.          if (i >= nLen) {
  182.              return strData;
  183.          }
  184.  
  185.          switch (nOption) {
  186.          case 0:
  187.              addCharLen = (nLen - i) / subStr.length();
  188.              for (i = 0; i < addCharLen; i++) {
  189.                  strHead += subStr;
  190.              }
  191.              return strHead + strData;
  192.          case 1:
  193.              addCharLen = (nLen - i) / subStr.length();
  194.              for (i = 0; i < addCharLen; i++) {
  195.                  strEnd += subStr;
  196.              }
  197.              return strData + strEnd;
  198.          case 2:
  199.              addCharLen = (nLen - i) / (subStr.length() * 2);
  200.              for (i = 0; i < addCharLen; i++) {
  201.                  strHead += subStr;
  202.                  strEnd += subStr;
  203.              }
  204.              return strHead + strData + strEnd;
  205.          default:
  206.              return strData;
  207.          }
  208.      }
  209.  
  210.      /**
  211.       * 整形转换成BCD型的字符串
  212.       * 9转换成后将变成09,00 09
  213.       * 19转换后将变成19, 00 19
  214.       * @param value
  215.       * @param bytesNum
  216.       *            BCD字节个数
  217.       * @return
  218.       */
  219.      public static String intToBcd(int value, int bytesNum) {
  220.          switch(bytesNum){
  221.          case 1:
  222.              if (value >= 0  && value <= 99){
  223.                  return paddingString(String.valueOf(value),2,"0",0);
  224.              }
  225.              break;
  226.          case 2:
  227.              if (value >= 0  && value <= 999) {
  228.                  return paddingString(String.valueOf(value),4,"0",0);
  229.              }
  230.              break;
  231.  
  232.          case 3:
  233.              if (value >= 0  && value <= 999) {
  234.                  return paddingString(String.valueOf(value),3,"0",0);
  235.              }
  236.              break;
  237.          }
  238.  
  239.          return "";
  240.      }
  241.  
  242.      /**
  243.       * Hex数据转换成字符串
  244.       *
  245.       * @param value
  246.       * @return
  247.       * @throws UnsupportedEncodingException
  248.       */
  249.      public static String hexToStr(String value) throws UnsupportedEncodingException {
  250.          return new String(BytesUtils.hexToBytes(value),"GBK");
  251.      }
  252.      /**
  253.       * Hex数据转换成字符串
  254.       * encoding 为编码
  255.       * @param value
  256.       * @return
  257.       * @throws UnsupportedEncodingException
  258.       */
  259.      public static String hexToStr(String value, String encoding) throws UnsupportedEncodingException {
  260.          return new String(BytesUtils.hexToBytes(value),encoding);
  261.      }
  262.  
  263.      /**
  264.       * 字符串转换成Hex
  265.       *
  266.       * @param value
  267.       * @return
  268.       */
  269.      public static String strToHex(String value) {
  270.          return BytesUtils.bytesToHex(BytesUtils.getBytes(value));
  271.      }
  272.  
  273.      /**
  274.       * 往value中填充一个字符0 ,当数据长度正好为2的整数倍时，不填充
  275.       *
  276.       * @param value
  277.       * @param option
  278.       *            0:往后填充 ;1:往前填充
  279.       * @return
  280.       */
  281.      public static String paddingZeroToHexStr(String value, int option) {
  282.  
  283.          if (value.length() % 2 == 0){
  284.              return value;
  285.          }
  286.  
  287.          if (option == 0){
  288.              return "0" + value;
  289.          }
  290.          else if (option == 1){
  291.              return value + "0";
  292.          }
  293.          else{
  294.              return value;
  295.          }
  296.      }
  297.  
  298.      /**
  299.       * 判断是否是Hex格式数据
  300.       *
  301.       * @param value
  302.       * @return
  303.       */
  304.      public static boolean checkHexStr(String value) {
  305.          int i;
  306.          int len;
  307.  
  308.          if (value == null) return false;
  309.  
  310.          len = value.length();
  311.          if (len == 0) return false;
  312.  
  313.        for (i= 0;i<len;i++){
  314.            if (!((value.charAt(i) >= '0' && value.charAt(i) <= '9')||
  315.                    (value.charAt(i) >= 'a' && value.charAt(i) <= 'f') ||
  316.                    (value.charAt(i) >= 'A' && value.charAt(i) <= 'F'))){
  317.                return false;
  318.            }
  319.        }
  320.        return true;
  321.      }
  322.  
  323.      /**
  324.       * 判断字符串是否是数字0-9
  325.       *
  326.       * @param value
  327.       * @return
  328.       */
  329.  /*    public static boolean checkDigitStr(String value) {
  330.          int i;
  331.          int len;
  332.  
  333.          if (value == null) return false;
  334.  
  335.          len = value.length();
  336.          if (len == 0) return false;
  337.  
  338.        for (i= 0;i<len;i++){
  339.            if (value.charAt(i) < '0' || value.charAt(i) > '9') {
  340.                return false;
  341.            }
  342.        }
  343.        return true;
  344.      }*/
  345.  
  346.      /**
  347.       * Binary数据转换成Hex
  348.       *
  349.       * @param value
  350.       * @return
  351.       */
  352.      public static String binaryToHex(String value) {
  353.          int i,j,len;
  354.          String result ="";
  355.          char[] hexVocable = { '0', '1', '2', '3',
  356.                  '4', '5', '6','7',
  357.                  '8', '9', 'A', 'B',
  358.                  'C', 'D', 'E', 'F' };
  359.          String[] binString  = {"0000", "0001", "0010", "0011",
  360.                  "0100", "0101", "0110", "0111",
  361.                  "1000", "1001", "1010", "1011",
  362.                  "1100", "1101", "1110", "1111"};
  363.          //System.out.println("value: " + value);
  364.  
  365.          len = value.length();
  366.          for(i=0; i<len; i += 4){
  367.              for(j=0; j<16; j++){
  368.                  if(binString[j].equals(value.substring(i, i+4))){
  369.                      result += hexVocable[j];
  370.                      break;
  371.                  }
  372.              }
  373.          }
  374.          //System.out.println("result: " + result);
  375.          return result;
  376.      }
  377.  
  378.      /**
  379.       * Hex数据转换成Binary
  380.       *
  381.       * @param value
  382.       * @return
  383.       */
  384.      public static String hexToBinary(String value) {
  385.          int i,j,len;
  386.          String result ="";
  387.          char[] hexVocable = { '0', '1', '2', '3',
  388.                  '4', '5', '6','7',
  389.                  '8', '9', 'A', 'B',
  390.                  'C', 'D', 'E', 'F' };
  391.          String[] binString  = {"0000", "0001", "0010", "0011",
  392.                  "0100", "0101", "0110", "0111",
  393.                  "1000", "1001", "1010", "1011",
  394.                  "1100", "1101", "1110", "1111"};
  395.  
  396.          len = value.length();
  397.          for(i=0; i<len; i++){
  398.              for(j=0; j<16; j++){
  399.                  if(value.charAt(i) == hexVocable[j]){
  400.                      result += binString[j];
  401.                      break;
  402.                  }
  403.              }
  404.          }
  405.          //System.out.println("result: " + result);
  406.          return result;
  407.      }
  408.  
  409.      /**
  410.       * 获取二进制字符串
  411.       * 0x00 0x01 0x00 0x01 0x01转换成"01011"
  412.       * @param value
  413.       * @return
  414.       */
  415.      public static String getBinaryString(byte[] value) {
  416.          int len;
  417.          String result ="";
  418.  
  419.          len = value.length;
  420.  
  421.          for(int i=0;i<len;i++) {
  422.              result += String.valueOf(value[i]);
  423.          }
  424.  
  425.          return result;
  426.      }
  427.      /**
  428.       * mmdd日期格式
  429.       * @param date
  430.       * @return
  431.       */
  432.      public static boolean isMatchDate(String date){
  433.          if(date.length()!=4||date==null){
  434.              return false;
  435.          }
  436.          String eL="(((0[13578]|1[02])(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)(0[1-9]|[12][0-9]|30))|(02(0[1-9]|[1][0-9]|2[0-9])))";
  437.             Pattern p = Pattern.compile(eL);
  438.              Matcher m = p.matcher(date);
  439.              boolean b = m.matches();
  440.              return b;
  441.      }
  442.  
  443.      /**
  444.       * 删除字符串左侧所有字符ch
  445.       * @param
  446.       * @return
  447.       */
  448.      public static String deleteLeftChar(String data, char ch){
  449.          int flag = 0;
  450.          for(int i = 0;i<data.length();i++){
  451.              if(data.charAt(i) == ch){
  452.                  flag = i;
  453.              }else{
  454.                  break;
  455.              }
  456.          }
  457.          flag = flag+1;
  458.          data = data.substring(flag);
  459.          return data;
  460.      }
  461.  
  462.      /**
  463.       * 删除字符串右侧所有字符ch
  464.       * @param
  465.       * @return
  466.       */
  467.      public static String deleteRightChar(String data, char ch){
  468.  
  469.          int flag = data.length();
  470.          for(int i = data.length()-1;i>=0;i--){
  471.              if(data.charAt(i) == ch){
  472.                  flag = i;
  473.              }else{
  474.                  break;
  475.              }
  476.          }
  477.  
  478.          data = data.substring(0,flag);
  479.          return data;
  480.      }
  481.  
  482.          /**
  483.       * 将显示金额的字符串（带原点），转化为没有原点的字符串
  484.       *
  485.       * 示例：123.32 --->  12332
  486.       *       2.  ----> 200
  487.       *       2.3  ----> 230
  488.       *       0.12 --->  12
  489.       *       0.02 --->   2
  490.       * @param str
  491.       * @return
  492.       */
  493.      public static String decimalWipeDot(String str){
  494.  
  495.          //拿到字符串
  496.          if (str.contains(".")) {
  497.  
  498.              //判断点后还有几位
  499.              int indexOf = str.indexOf(".");
  500.              //用索引和长度进行判断
  501.              int length = str.length();
  502.              int cha = length - indexOf;
  503.              char charAt = str.charAt(indexOf - 1);
  504.  
  505.              switch (cha) {
  506.              case 1:
  507.                  //小数后有0位--先去掉点，在加个00   eg: 2. --> 200   0.-->0
  508.                  if (charAt == '0') {
  509.                      str= "0";
  510.                  }else {
  511.                      str = str.replace(".", "");
  512.                      str= str+"00";
  513.                  }
  514.                  break;
  515.              case 2:
  516.                  //小数后有1位--先去掉点，在加个0  eg: 2.3 -->  230  0.1 -->10
  517.                  if (charAt == '0') {
  518.                      str= str.charAt(indexOf + 1)+"0";
  519.                  }else {
  520.                      str = str.replace(".", "");
  521.                      str= str+"0";
  522.                  }
  523.  
  524.                  break;
  525.              case 3:
  526.                  //小数后有2位--直接去掉点   eg:   2.03 --> 203   0.12-->12  0.02 --> 2
  527.                  char charAt2 = str.charAt(indexOf + 1);
  528.                  if (str.length() == 4) {
  529.  
  530.                      if (charAt == '0') {
  531.                          if (charAt2 == '0') {
  532.                              str= str.substring(length - 1,length);
  533.                          }else {
  534.  
  535.                              str= str.substring(indexOf + 1,length);
  536.                          }
  537.                      }else {
  538.                          str = str.replace(".", "");
  539.                      }
  540.                  }else {
  541.                      str = str.replace(".", "");
  542.                  }
  543.  
  544.                  break;
  545.              default:
  546.                  break;
  547.              }
  548.          }else {
  549.              //没有点， 直接加00  eg:  23 ---> 2300   0--->0   0000023--->  2300    00000--->0
  550.              //去掉前面多余的0 ，在判断这个数是否为0
  551.              if (str.equals("")) {
  552.                  str = "0";
  553.              }
  554.              int int1 = Integer.parseInt(str);
  555.              str = String.valueOf(int1);
  556.  
  557.              if (int1 != 0){
  558.                  str = str+"00";
  559.              }else {
  560.                  str = "0";
  561.              }
  562.          }
  563.          return str;
  564.      }
  565.  
  566.      /**
  567.       * 将金额的字符串(不带点)  转化为带点的金额字符串
  568.       * 示例       12332 ---> 123.32
  569.       *       200   --->  2
  570.       *       230   ----> 2.3
  571.       *        12 ---> 0.12
  572.       *         2  ---> 0.02
  573.       *
  574.       *
  575.       * @param str
  576.       * @return
  577.       */
  578.      public static String decimalAddDot(String str){
  579.          boolean isNegative = false;
  580.          str = str.replace(" ","");
  581.  
  582.          if (str == null || str == "") {
  583.              return "0.00";
  584.          }
  585.          //截取字符第一个字符
  586.           String sign = str.substring(0,1);
  587.          if (sign.equals("-")) {
  588.              isNegative = true;//标记为负数
  589.              str = str.substring(1,str.length());
  590.          }else{
  591.              //正数不作处理
  592.          }
  593.  
  594.          int length = str.length();
  595.          if (length >= 3) {  //200-->2.00
  596.              str = str.substring(0, length-2)+"."+str.substring(length-2, length);
  597.          }else {
  598.              switch (length) {
  599.              case 2:// 20-->0.20   23 --> 0.23
  600.                  str = "0."+str;
  601.                  break;
  602.              case 1://  2-->0.02
  603.                  str = "0.0"+str;
  604.                  break;
  605.              case 0:
  606.                  //说明没有    0.00
  607.                  str = "0.00";
  608.                  break;
  609.              default:
  610.                  break;
  611.              }
  612.          }
  613.  
  614.          if (isNegative) {
  615.              return "-"+str;
  616.          }else{
  617.              return str;
  618.          }
  619.  
  620.      }
  621.  }

【Java】字符串工具类的更多相关文章

  1. 自用java字符串工具类

    不断封装一些常用的字符串操作加到这个工具类里,不断积累: package com.netease.lede.qa.util; import java.text.ParseException; impo ...

  2. Java字符串工具类

    import java.io.ByteArrayOutputStream;import java.io.UnsupportedEncodingException;import java.lang.re ...

  3. Java Properties工具类详解

    1.Java Properties工具类位于java.util.Properties,该工具类的使用极其简单方便.首先该类是继承自 Hashtable<Object,Object> 这就奠 ...

  4. StringUtils 字符串工具类

    package com.thinkgem.jeesite.common.utils; import java.io.File; import java.io.IOException; import j ...

  5. Java json工具类，jackson工具类，ObjectMapper工具类

    Java json工具类,jackson工具类,ObjectMapper工具类 >>>>>>>>>>>>>>> ...

  6. JAVA String 工具类

    java StringUtil 字符串工具类 import java.util.ArrayList; import java.util.LinkedHashSet; import java.util. ...

  7. Java日期工具类，Java时间工具类，Java时间格式化

    Java日期工具类,Java时间工具类,Java时间格式化 >>>>>>>>>>>>>>>>>&g ...

  8. Jsoup请求http或https返回json字符串工具类

    Jsoup请求http或https返回json字符串工具类 所需要的jar包如下: jsoup-1.8.1.jar 依赖jar包如下: httpclient-4.5.4.jar; httpclient ...

  9. java日期工具类DateUtil-续一

    上篇文章中,我为大家分享了下DateUtil第一版源码,但就如同文章中所说,我发现了还存在不完善的地方,所以我又做了优化和扩展. 更新日志: 1.修正当字符串日期风格为MM-dd或yyyy-MM时,若 ...

  10. java日期工具类DateUtil-续二

    该版本是一次较大的升级,农历相比公历复杂太多(真佩服古人的智慧),虽然有规律,但涉及到的取舍.近似的感念太多,况且本身的概念就已经很多了,我在网上也是查阅了很多的资料,虽然找到一些计算的方法,但都有些 ...

随机推荐

  1. JS(JavaScript）的初了解2（更新中···）

    1.parseInt()    整数型 字符串中的数字取整 遇到第一个是非数字的字节就结束了. 2.parseFloat 浮点型 字符中的数字取整数和小数,有两个小数点的话第二个小数点无效第二个小数点 ...

  2. 《温故而知新》JAVA基础一

    一:基本环境 种类 javaSE(核心语法)+javaME(移动设备)+Java EE(JSP/服务等) JVM(java虚拟机) abc.java(源文件)--编译器--abc.class 字节码文 ...

  3. ios外包公司——技术分享：手机应用开发步骤

    1. 确定你的创意 您的创意是否有人做过,如果有类似的app,那就要多多考虑,争取超越并且有一些独特的优化设计在其中 2. 定位应用 通过苹果的人机界面指南(Human Interface Guide ...

  4. VirtualBox运行出现“0x00000000指令引用的0x00000000内存。该内存不能为written” ，错误解决

    win7 64位系统,运行virtual box 出现如下错误 错误原因:由于系统主题被破解导致的 解决办法: 1.管理员身份运行UniversalThemePatcher_1.5.22 x64,点击 ...

  5. Robot Framework问题记录

    robotframework运行时后台报错UnicodeDecodeError UnicodeDecodeError :'utf-8' codec can't decode byte 0xb2 in ...

  6. MDK C++编程说明

    1.汇编启动文件的[WEAK]声明仅对C文件符号有效,所以我们编写外设中断服务方法时应该写在C文件中,或者在CPP文件中使用exetrn "C" { }修饰符. 2.C编译器不能直 ...

  7. RabbitMQ(3) Spring boot集成RabbitMQ

    springboot集成RabbitMQ非常简单,如果只是简单的使用配置非常少,springboot提供了spring-boot-starter-amqp项目对消息各种支持. 资源代码:练习用的代码. ...

  8. linux软件管理之rpm管理rpm包

    使用RPM工具管理RPM包 ====================================================================================需要 ...

  9. hbase大规模数据写入的优化历程 ，ZZ

    http://blog.csdn.net/zbc1090549839/article/details/51582817

  10. linux中执行shell命令的几种常用方法

    1 切换到shell脚本所在目录执行shell脚本: cd /test/shell ./test.sh 2 以绝对路径的方式执行shell脚本: /test/shell/test.sh 3 直接使用b ...