Code666 (代码贴、代码片段)

[Java] 字符串操作类(人民币转换/全角半角字符/去重字符串/过滤/手机号码/匹配） →→→→→进入此内容的聊天室

来自 , 2020-04-30, 写在 Java, 查看 163 次.
URL http://www.code666.cn/view/ce78d1da
  1. package 字符串类;
  2.  
  3. import java.util.LinkedHashSet;
  4. import java.util.Set;
  5. import java.util.regex.Matcher;
  6. import java.util.regex.Pattern;
  7.  
  8.  
  9. /*字符串操作类(人民币转换/全角半角字符/去重字符串/判断是不是合法手机/字符串匹配的算法)*/
  10. public class 字符串操作 {
  11.     /**
  12.      * 人民币转成大写 hangeToBig
  13.      *
  14.      * @param value
  15.      * @return String
  16.      */
  17.     public static String 人民币转成大写(double value) {
  18.         char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
  19.         char[] vunit = { '万', '亿' }; // 段名表示
  20.         char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
  21.         long midVal = (long) (value * 100); // 转化成整形
  22.         String valStr = String.valueOf(midVal); // 转化成字符串
  23.  
  24.         String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
  25.         String rail = valStr.substring(valStr.length() - 2); // 取小数部分
  26.  
  27.         String prefix = ""; // 整数部分转化的结果
  28.         String suffix = ""; // 小数部分转化的结果
  29.         // 处理小数点后面的数
  30.         if (rail.equals("00")) { // 如果小数部分为0
  31.             suffix = "整";
  32.         } else {
  33.             suffix = digit[rail.charAt(0) - '0'] + "角"
  34.                      + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
  35.         }
  36.         // 处理小数点前面的数
  37.         char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
  38.         char zero = '0'; // 标志'0'表示出现过0
  39.         byte zeroSerNum = 0; // 连续出现0的次数
  40.         for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字
  41.             int idx = (chDig.length - i - 1) % 4; // 取段内位置
  42.             int vidx = (chDig.length - i - 1) / 4; // 取段位置
  43.             if (chDig[i] == '0') { // 如果当前字符是0
  44.                 zeroSerNum++; // 连续0次数递增
  45.                 if (zero == '0') { // 标志
  46.                     zero = digit[0];
  47.                 } else if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
  48.                     prefix += vunit[vidx - 1];
  49.                     zero = '0';
  50.                 }
  51.                 continue;
  52.             }
  53.             zeroSerNum = 0; // 连续0次数清零
  54.             if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的
  55.                 prefix += zero;
  56.                 zero = '0';
  57.             }
  58.             prefix += digit[chDig[i] - '0']; // 转化该数字表示
  59.             if (idx > 0)
  60.                 prefix += hunit[idx - 1];
  61.             if (idx == 0 && vidx > 0) {
  62.                 prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
  63.             }
  64.         }
  65.  
  66.         if (prefix.length() > 0)
  67.             prefix += '圆'; // 如果整数部分存在,则有圆的字样
  68.         return prefix + suffix; // 返回正确表示
  69.     }
  70.  
  71.     /**
  72.      * 全角字符转半角字符 QJToBJChange
  73.      *
  74.      * @param QJStr
  75.      * @return String
  76.      */
  77.     public static final String 全角字符转半角字符(String QJStr) {
  78.         char[] chr = QJStr.toCharArray();
  79.         String str = "";
  80.         for (int i = 0; i < chr.length; i++) {
  81.             chr[i] = (char) ((int) chr[i] - 65248);
  82.             str += chr[i];
  83.         }
  84.         return str;
  85.     }
  86.  
  87.     /**
  88.      * 去掉字符串中重复的子字符串 removeSameString
  89.      *
  90.      * @param str
  91.      * @return String
  92.      */
  93.     public static String 去掉字符串中重复的子字符串(String str) {
  94.         Set<String> mLinkedSet = new LinkedHashSet<String>();
  95.         String[] strArray = str.split(" ");
  96.         StringBuffer sb = new StringBuffer();
  97.  
  98.         for (int i = 0; i < strArray.length; i++) {
  99.             if (!mLinkedSet.contains(strArray[i])) {
  100.                 mLinkedSet.add(strArray[i]);
  101.                 sb.append(strArray[i] + " ");
  102.             }
  103.         }
  104.         System.out.println(mLinkedSet);
  105.         return sb.toString().substring(0, sb.toString().length() - 1);
  106.     }
  107.  
  108.     /**
  109.      * 过滤常见特殊字符
  110.      *
  111.      */
  112.     public static String 过滤常见特殊字符(String src) {
  113.         if (src == null)
  114.             return "";
  115.         StringBuilder result = new StringBuilder();
  116.         if (src != null) {
  117.             src = src.trim();
  118.             for (int pos = 0; pos < src.length(); pos++) {
  119.                 switch (src.charAt(pos)) {
  120.                 case '\"':
  121.                     result.append(""");
  122.                                  break;
  123.                                  case '<':
  124.                                  result.append(" < ");
  125.                                  break;
  126.                                  case '>':
  127.                                  result.append(" > ");
  128.                                  break;
  129.                                  case '\'':
  130.                                  result.append("'");
  131.                                  break;
  132.                                  case ' & ':
  133.                                  result.append("&");
  134.                                  break;
  135.                                  case ' % ':
  136.                                  result.append("&pc;");
  137.                                  break;
  138.                                  case '_':
  139.                                  result.append("&ul;");
  140.                                  break;
  141.                                  case '#':
  142.                                  result.append("&shap;");
  143.                                  break;
  144.                                  case ' ? ':
  145.                                  result.append("&ques;");
  146.                                  break;
  147.                                  default:
  148.                                  result.append(src.charAt(pos));
  149.                                  break;
  150.                              }
  151.                              }
  152.                              }
  153.                                  return result.toString();
  154.                              }
  155.  
  156.                                  /**
  157.                                  * 反过滤特殊字符
  158.                                  */
  159.                                  public static String 反过滤特殊字符(String src) {
  160.                                  if (src == null)
  161.                                  return "";
  162.                                  String result = src;
  163.                                  result = result.replace(""", "\"").replace("'", "\'");
  164.                                  result = result.replace("<", "<").replace(">", ">");
  165.                                  result = result.replace("&", "&");
  166.                                  result = result.replace("&pc;", "%").replace("&ul", "_");
  167.                                  result = result.replace("&shap;", "#").replace("&ques", "?");
  168.                                  return result;
  169.                              }
  170.  
  171.                                  /**
  172.                                  * 判断是不是合法手机 handset 手机号码
  173.                                  */
  174.                                  public static boolean isHandset(String handset) {
  175.                                  try {
  176.                                  if (!handset.substring(0, 1).equals("1")) {
  177.                                  return false;
  178.                              }
  179.                                  if (handset == null || handset.length() != 11) {
  180.                                  return false;
  181.                              }
  182.                                  String check = "^[0123456789]+$";
  183.                                  Pattern regex = Pattern.compile(check);
  184.                                  Matcher matcher = regex.matcher(handset);
  185.                                  boolean isMatched = matcher.matches();
  186.                                  if (isMatched) {
  187.                                  return true;
  188.                              } else {
  189.                                  return false;
  190.                              }
  191.                              } catch (RuntimeException e) {
  192.                                  return false;
  193.                              }
  194.                              }
  195.  
  196.                                  /**
  197.                                  * 字符串匹配的算法.
  198.                                  */
  199.                                  public String getMaxMatch(String a, String b) {
  200.                                  StringBuffer tmp = new StringBuffer();
  201.                                  String maxString = "";
  202.                                  int max = 0;
  203.                                  int len = 0;
  204.                                  char[] aArray = a.toCharArray();
  205.                                  char[] bArray = b.toCharArray();
  206.                                  int posA = 0;
  207.                                  int posB = 0;
  208.                                  while (posA < aArray.length - max) {
  209.                                  posB = 0;
  210.                                  while (posB < (bArray.length - max)) {
  211.                                  if (aArray[posA] == bArray[posB]) {
  212.                                  len = 1;
  213.                                  tmp = new StringBuffer();
  214.                                  tmp.append(aArray[posA]);
  215.                                  while ((posA + len < aArray.length)
  216.                                  && (posB + len < bArray.length)
  217.                                  && (aArray[posA + len] == bArray[posB + len])) {
  218.                                  tmp.append(aArray[posA + len]);
  219.                                  len++;
  220.                              }
  221.                                  if (len > max) {
  222.                                  max = len;
  223.                                  maxString = tmp.toString();
  224.                              }
  225.                              }
  226.                                  posB++;
  227.                              }
  228.                                  posA++;
  229.                              }
  230.                                  return maxString;
  231.                              }
  232.  
  233.                              }

回复 "字符串操作类(人民币转换/全角半角字符/去重字符串/过滤/手机号码/匹配）"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666