java字符串处理工具类

最新推荐文章于 2024-08-15 16:46:51 发布
最新推荐文章于 2024-08-15 16:46:51 发布
阅读量936 收藏 1
点赞数
分类专栏： java 文章标签： 字符串 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45878450/article/details/110930354
版权

java字符串处理工具类

import com.function.app.functioncommon.util.lang.Assert;
import com.function.app.functioncommon.util.text.StrBuilder;
import com.function.app.functioncommon.util.text.StrFormatter;
import com.function.app.functioncommon.util.text.StrSpliter;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**

  • 字符串工具类
    /
    public class StringUtils {
    /    *

    • 检查这个字符串是不是空字符串。
    • 如果这个字符串为null或者trim后为空字符串则返回true，否则返回false。
    • @param chkStr 被检查的字符串
    • @return boolean
      */
      @Contract(“null -> true”)
      public static boolean isEmpty(String chkStr) {
      return chkStr == null || chkStr.trim().equals(EMPTY) || chkStr.trim().equalsIgnoreCase(“null”);
      }

    /**

    • 检查这个字符串是不是空字符串。
    • 如果不是空字符串那么返回true，否则返回false。
    • @param chkStr 被检查的字符串
    • @return boolean
      */
      @Contract(“null -> false”)
      public static boolean isNotEmpty(String chkStr) {
      return !isEmpty(chkStr);
      }

    /**

    • 进行tostring操作，如果传入的是null，返回空字符串。
    • StringUtils.toString(null) = “”
    • StringUtils.toString(Boolean.TRUE) = “true”
    • @param obj 源
    • @return String
      */
      public static String toString(Object obj) {
      return obj == null ? EMPTY : obj.toString();
      }

    /**

    • 进行tostring操作，如果传入的是null，返回指定的默认值。
    • StringUtils.toString(null, null) = null
    • StringUtils.toString(null, “null”) = “null”
    • StringUtils.toString(null, “”) = “”
    • StringUtils.toString(Boolean.TRUE, “null”) = “true”
    • @param obj 源
    • @param nullStr 如果obj为null时返回这个指定值
    • @return String
      */
      public static String toString(Object obj, String nullStr) {
      return obj == null ? nullStr : obj.toString();
      }

    /**

    • 将半角的符号转换成全角符号.(即英文字符转中文字符)
    • @param str 源字符串
    • @return String
      /
      @NotNull
      public static String changeToFull(String str) {
      String source = "1234567890!@#$%^&      ()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_=+\|[];:’",<.>/?";
      String[] decode = {“１”, “２”, “３”, “４”, “５”, “６”, “７”, “８”, “９”, “０”,
      “！”, “＠”, “＃”, “＄”, “％”, “︿”, “＆”, “＊”, “（”, “）”, “ａ”, “ｂ”,
      “ｃ”, “ｄ”, “ｅ”, “ｆ”, “ｇ”, “ｈ”, “ｉ”, “ｊ”, “ｋ”, “ｌ”, “ｍ”, “ｎ”,
      “ｏ”, “ｐ”, “ｑ”, “ｒ”, “ｓ”, “ｔ”, “ｕ”, “ｖ”, “ｗ”, “ｘ”, “ｙ”, “ｚ”,
      “Ａ”, “Ｂ”, “Ｃ”, “Ｄ”, “Ｅ”, “Ｆ”, “Ｇ”, “Ｈ”, “Ｉ”, “Ｊ”, “Ｋ”, “Ｌ”,
      “Ｍ”, “Ｎ”, “Ｏ”, “Ｐ”, “Ｑ”, “Ｒ”, “Ｓ”, “Ｔ”, “Ｕ”, “Ｖ”, “Ｗ”, “Ｘ”,
      “Ｙ”, “Ｚ”, “－”, “＿”, “＝”, “＋”, “＼”, “｜”, “【”, “】”, “；”, “：”,
      “’”, “”", “，”, “〈”, “。”, “〉”, “／”, “？”};
      StringBuffer result = new StringBuffer();
      for (int i = 0, len = str.length(); i < len; i++) {
      int po = source.indexOf(str.charAt(i));
      if (po != INDEX_NOT_FOUND) {
      result.append(decode[po]);
      } else {
      result.append(str.charAt(i));
      }
      }
      return result.toString();
      }
      /**
    • 分割字符，从开始到第一个split字符串为止
    • @param src 源字符串
    • @param split 截止字符串
    • @return
      */
      public static String subStr(String src, String split) {
      if (!isEmpty(src)) {
      int index = src.indexOf(split);
      if (index >= 0) {
      return src.substring(0, index);
      }
      }
      return src;
      }

    /**

    • 通过规格切割一个字符返回一个字符数组
    • @param src 要切割的字符
    • @param split 分割的规则
    • @return
      */
      public static String[] subStrArray(String src, String split) {
      String[] str = null;
      if (!isEmpty(src)) {
      str = src.split(split);
      }
      return str;
      }

    /**

    • 去除页面的非法字符检查
    • @param str
    • @return
      */
      @Contract(“null -> null”)
      public static String replaceStr(String str) {
      if (str != null && str.length() > 0) {
      str = str.replaceAll("~", “”);
      str = str.replaceAll(" “, “”);
      str = str.replaceAll(”　“, “”);
      str = str.replaceAll(” “, “”);
      str = str.replaceAll(”", ""); str = str.replaceAll("!", ""); str = str.replaceAll("@", ""); str = str.replaceAll("#", ""); str = str.replaceAll("\\$", ""); str = str.replaceAll("%", ""); str = str.replaceAll("\\^", ""); str = str.replaceAll("&", ""); str = str.replaceAll("\\*", ""); str = str.replaceAll("\\(", ""); str = str.replaceAll("\\)", ""); str = str.replaceAll("-", ""); str = str.replaceAll("_", ""); str = str.replaceAll("=", ""); str = str.replaceAll("\\+", ""); str = str.replaceAll("\\{", ""); str = str.replaceAll("\\[", ""); str = str.replaceAll("\\}", ""); str = str.replaceAll("\\]", ""); str = str.replaceAll("\\|", ""); str = str.replaceAll("\\\\", ""); str = str.replaceAll(";", ""); str = str.replaceAll(":", ""); str = str.replaceAll("'", ""); str = str.replaceAll("\\\"", ""); str = str.replaceAll("<", ""); str = str.replaceAll(">", ""); str = str.replaceAll("\\.", ""); str = str.replaceAll("\\?", ""); str = str.replaceAll("/", ""); str = str.replaceAll("～", ""); str = str.replaceAll("", “”);
      str = str.replaceAll("！", “”);
      str = str.replaceAll("＠", “”);
      str = str.replaceAll("＃", “”);
      str = str.replaceAll(“＄”, “”);
      str = str.replaceAll("％", “”);
      str = str.replaceAll("︿", “”);
      str = str.replaceAll("＆", “”);
      str = str.replaceAll(“×”, “”);
      str = str.replaceAll("（", “”);
      str = str.replaceAll("）", “”);
      str = str.replaceAll("－", “”);
      str = str.replaceAll("＿", “”);
      str = str.replaceAll(“＋”, “”);
      str = str.replaceAll(“＝”, “”);
      str = str.replaceAll("｛", “”);
      str = str.replaceAll("［", “”);
      str = str.replaceAll("｝", “”);
      str = str.replaceAll("］", “”);
      str = str.replaceAll(“｜”, “”);
      str = str.replaceAll("＼", “”);
      str = str.replaceAll("：", “”);
      str = str.replaceAll("；", “”);
      str = str.replaceAll("＂", “”);
      str = str.replaceAll("＇", “”);
      str = str.replaceAll(“＜”, “”);
      str = str.replaceAll("，", “”);
      str = str.replaceAll(“＞”, “”);
      str = str.replaceAll("．", “”);
      str = str.replaceAll("？", “”);
      str = str.replaceAll("／", “”);
      str = str.replaceAll("·", “”);
      str = str.replaceAll(“￥”, “”);
      str = str.replaceAll("……", “”);
      str = str.replaceAll("（", “”);
      str = str.replaceAll("）", “”);
      str = str.replaceAll("——", “”);
      str = str.replaceAll("-", “”);
      str = str.replaceAll("【", “”);
      str = str.replaceAll("】", “”);
      str = str.replaceAll("、", “”);
      str = str.replaceAll("”", “”);
      str = str.replaceAll("’", “”);
      str = str.replaceAll("《", “”);
      str = str.replaceAll("》", “”);
      str = str.replaceAll("“", “”);
      str = str.replaceAll("。", “”);
      }
      return str;
      }

    /**

    • 移除html标签
    • @param htmlstr
    • @return
      /
      public static String removeHtmlTag(String htmlstr) {
      Pattern pat = Pattern.compile("\s      <.?>\s", Pattern.DOTALL | Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
      java.util.regex.Matcher m = pat.matcher(htmlstr);
      String rs = m.replaceAll("");
      rs = rs.replaceAll("&nbsp", " “);
      rs = rs.replaceAll(”<", “<”);
      rs = rs.replaceAll(">", “>”);
      return rs;
      }

    /**

    • 判断两个字符串是否相等 如果等为null 则判断相等，一个为null另一个not null则判断不相等 否则如果s1=s2则相等
    • @param s1
    • @param s2
      */
      public static boolean equals(String s1, String s2) {
      if (isEmpty(s1) && isEmpty(s2)) {
      return true;
      } else if (!isEmpty(s1) && !isEmpty(s2)) {
      return s1.equals(s2);
      }
      return false;
      }

    /**

    • 比较两个字符串是否相等。

    • @param str1 要比较的字符串1

    • @param str2 要比较的字符串2

    • @param ignoreCase 是否忽略大小写

    • @return 如果两个字符串相同，或者都是null，则返回true
      */
      public static boolean equals(CharSequence str1, CharSequence str2, boolean ignoreCase) {
      if (null == str1) {
      // 只有两个都为null才判断相等
      return str2 == null;
      }
      if (null == str2) {
      // 字符串2空，字符串1非空，直接false
      return false;
      }

      if (ignoreCase) {
      return str1.toString().equalsIgnoreCase(str2.toString());
      } else {
      return str1.equals(str2);
      }
      }

    /**

    • 判断一个字符串是否为数字
    • @param src
    • @return
      */
      public static boolean isNumeric(String src) {
      boolean return_value = false;
      if (src != null && src.length() > 0) {
      java.util.regex.Matcher m = numericPattern.matcher(src);
      if (m.find()) {
      return_value = true;
      }
      }
      return return_value;
      }

    /**

    • 把字符串转换为html代码
    • @param str
    • @return
      */
      @Nullable
      public static String replaceHtml(String str) {
      try {
      str = str.trim();
      str = str.replaceAll("&", “&”);
      str = str.replaceAll("<", “<”);
      str = str.replaceAll(">", “>”);
      str = str.replaceAll(" “, " “);
      str = str.replace(”’”, “’”);
      str = str.replaceAll(""", “”");
      str = str.replace("\r\n", “
      ”);
      str = str.replace("\n", “
      ”);
      str = str.replace("\r", “
      ”);
      return str;
      } catch (NullPointerException e) {
      return null;
      }
      }

    /**

    • 转换NULL为""
    • @param src
    • @return
      */
      @Contract(value = “null -> !null”, pure = true)
      public static String changeNull(String src) {
      return src == null || src.equals(“null”) ? “” : src;
      }

    /**

    • 只从源字符串中移除指定开头子字符串.
    • StringUtils.removeStart(null, *) = null
    • StringUtils.removeStart("", *) = “”
    • StringUtils.removeStart(*, null) = *
    • StringUtils.removeStart(“www.baidu.com”, “www.”) = “baidu.com”
    • StringUtils.removeStart(“www.baidu.com”, “domain”) = “www.baidu.com”
    • StringUtils.removeStart(“abc”, “”) = “abc”
    • @param str 源字符串
    • @param remove 将要被移除的子字符串，移除从左向右开始
    • @return String
      */
      public static String removeStart(String str, String remove) {
      if (isEmpty(str) || isEmpty(remove)) {
      return str;
      }
      if (str.startsWith(remove)) {
      return str.substring(remove.length());
      }
      return str;
      }

    /**

    • 只从源字符串中移除指定结尾的子字符串.
    • StringUtils.removeEnd(null, *) = null
    • StringUtils.removeEnd("", *) = “”
    • StringUtils.removeEnd(*, null) = *
    • StringUtils.removeEnd(“www.baidu.com”, “.com.”) = “www.baidu.com”
    • StringUtils.removeEnd(“www.baidu.com”, “.com”) = “www.baidu”
    • StringUtils.removeEnd(“abc”, “”) = “abc”
    • @param str 源字符串
    • @param remove 将要被移除的子字符串,移除从右向左
    • @return String
      */
      public static String removeEnd(String str, String remove) {
      if (isEmpty(str) || isEmpty(remove)) {
      return str;
      }
      if (str.endsWith(remove)) {
      return str.substring(0, str.length() - remove.length());
      }
      return str;
      }

    /**

    • 将一个字符串重复N次
    • StringUtils.repeat(null, 2) = null
    • StringUtils.repeat("", 0) = “”
    • StringUtils.repeat("", 2) = “”
    • StringUtils.repeat(“a”, 3) = “aaa”
    • StringUtils.repeat(“ab”, 2) = “abab”
    • StringUtils.repeat(“a”, -2) = “”
    • @param str 源字符串
    • @param repeat 重复的次数
    • @return String
      /
      @Contract(“null, _ -> null”)
      public static String repeat(String str, int repeat) {
      if (str == null) {
      return null;
      }
      if (repeat <= 0) {
      return EMPTY;
      }
      int inputLength = str.length();
      if (repeat == 1 || inputLength == 0) {
      return str;
      }
      if (inputLength == 1 && repeat <= PAD_LIMIT) {
      return repeat(str.charAt(0), repeat);
      }
      int outputLength = inputLength * repeat;
      switch (inputLength) {
      case 1:
      return repeat(str.charAt(0), repeat);
      case 2:
      char ch0 = str.charAt(0);
      char ch1 = str.charAt(1);
      char[] output2 = new char[outputLength];
      for (int i = repeat * 2 - 2; i >= 0; i–, i–) {
      output2[i] = ch0;
      output2[i + 1] = ch1;
      }
      return new String(output2);
      default:
      StringBuilder buf = new StringBuilder(outputLength);
      for (int i = 0; i < repeat; i++) {
      buf.append(str);
      }
      return buf.toString();
      }
      }
      /      *
    • 将一个字符串重复N次，并且中间加上指定的分隔符
    • StringUtils.repeat(null, null, 2) = null
    • StringUtils.repeat(null, “x”, 2) = null
    • StringUtils.repeat("", null, 0) = “”
    • StringUtils.repeat("", “”, 2) = “”
    • StringUtils.repeat("", “x”, 3) = “xxx”
    • StringUtils.repeat("?", ", ", 3) = “?, ?, ?”
    • @param str 源字符串
    • @param separator 分隔符
    • @param repeat 重复次数
    • @return String
      /
      public static String repeat(String str, String separator, int repeat) {
      if (str == null || separator == null) {
      return repeat(str, repeat);
      } else {
      String result = repeat(str + separator, repeat);
      return removeEnd(result, separator);
      }
      }
      /      *
    • 将某个字符重复N次.
    • @param ch 某个字符
    • @param repeat 重复次数
    • @return String
      */
      @NotNull
      @Contract(pure = true)
      public static String repeat(char ch, int repeat) {
      char[] buf = new char[repeat];
      for (int i = repeat - 1; i >= 0; i–) {
      buf[i] = ch;
      }
      return new String(buf);
      }

    /**

    • 字符串长度达不到指定长度时，在字符串右边补指定的字符.
    • StringUtils.rightPad(null, *, *) = null
    • StringUtils.rightPad("", 3, ‘z’) = “zzz”
    • StringUtils.rightPad(“bat”, 3, ‘z’) = “bat”
    • StringUtils.rightPad(“bat”, 5, ‘z’) = “batzz”
    • StringUtils.rightPad(“bat”, 1, ‘z’) = “bat”
    • StringUtils.rightPad(“bat”, -1, ‘z’) = “bat”
    • @param str 源字符串
    • @param size 指定的总长度
    • @param padChar 进行补充的字符
    • @return String
      */
      @Contract(“null, _, _ -> null”)
      public static String rightPad(String str, int size, char padChar) {
      if (str == null) {
      return null;
      }
      int pads = size - str.length();
      if (pads <= 0) {
      return str;
      }
      if (pads > PAD_LIMIT) {
      return rightPad(str, size, String.valueOf(padChar));
      }
      return str.concat(repeat(padChar, pads));
      }

    /**

    • 扩大字符串长度，从左边补充指定字符
    • StringUtils.rightPad(null, *, *) = null
    • StringUtils.rightPad("", 3, “z”) = “zzz”
    • StringUtils.rightPad(“bat”, 3, “yz”) = “bat”
    • StringUtils.rightPad(“bat”, 5, “yz”) = “batyz”
    • StringUtils.rightPad(“bat”, 8, “yz”) = “batyzyzy”
    • StringUtils.rightPad(“bat”, 1, “yz”) = “bat”
    • StringUtils.rightPad(“bat”, -1, “yz”) = “bat”
    • StringUtils.rightPad(“bat”, 5, null) = "bat "
    • StringUtils.rightPad(“bat”, 5, “”) = "bat "
    • @param str 源字符串
    • @param size 指定的总长度
    • @param padStr 在右边补充的字符串
    • @return String
      /
      @Contract(“null, _, _ -> null”)
      public static String rightPad(String str, int size, String padStr) {
      if (str == null) {
      return null;
      }
      if (isEmpty(padStr)) {
      padStr = " ";
      }
      int padLen = padStr.length();
      int strLen = str.length();
      int pads = size - strLen;
      if (pads <= 0) {
      return str;
      }
      if (padLen == 1 && pads <= PAD_LIMIT) {
      return rightPad(str, size, padStr.charAt(0));
      }
      if (pads == padLen) {
      return str.concat(padStr);
      } else if (pads < padLen) {
      return str.concat(padStr.substring(0, pads));
      } else {
      char[] padding = new char[pads];
      char[] padChars = padStr.toCharArray();
      for (int i = 0; i < pads; i++) {
      padding[i] = padChars[i % padLen];
      }
      return str.concat(new String(padding));
      }
      }
      /      *
    • 扩大字符串长度，从左边补充空格
    • StringUtils.leftPad(null, *) = null
    • StringUtils.leftPad("", 3) = " "
    • StringUtils.leftPad(“bat”, 3) = “bat”
    • StringUtils.leftPad(“bat”, 5) = " bat"
    • StringUtils.leftPad(“bat”, 1) = “bat”
    • StringUtils.leftPad(“bat”, -1) = “bat”
    • @param str 源字符串
    • @param size 指定的总长度
    • @return String
      */
      @Contract(“null, _ -> null”)
      public static String leftPad(String str, int size) {
      return leftPad(str, size, ’ ');
      }

    /**

    • 扩大字符串长度，从左边补充指定的字符
    • StringUtils.leftPad(null, *, *) = null
    • StringUtils.leftPad("", 3, ‘z’) = “zzz”
    • StringUtils.leftPad(“bat”, 3, ‘z’) = “bat”
    • StringUtils.leftPad(“bat”, 5, ‘z’) = “zzbat”
    • StringUtils.leftPad(“bat”, 1, ‘z’) = “bat”
    • StringUtils.leftPad(“bat”, -1, ‘z’) = “bat”
    • @param str 源字符串
    • @param size 扩大后的长度
    • @param padChar 补充的字符
    • @return String
      */
      @Contract(“null, _, _ -> null”)
      public static String leftPad(String str, int size, char padChar) {
      if (str == null) {
      return null;
      }
      int pads = size - str.length();
      if (pads <= 0) {
      return str;
      }
      if (pads > PAD_LIMIT) {
      return leftPad(str, size, String.valueOf(padChar));
      }
      return repeat(padChar, pads).concat(str);
      }

    /**

    • 扩大字符串长度，从左边补充指定的字符
    • StringUtils.leftPad(null, *, *) = null
    • StringUtils.leftPad("", 3, “z”) = “zzz”
    • StringUtils.leftPad(“bat”, 3, “yz”) = “bat”
    • StringUtils.leftPad(“bat”, 5, “yz”) = “yzbat”
    • StringUtils.leftPad(“bat”, 8, “yz”) = “yzyzybat”
    • StringUtils.leftPad(“bat”, 1, “yz”) = “bat”
    • StringUtils.leftPad(“bat”, -1, “yz”) = “bat”
    • StringUtils.leftPad(“bat”, 5, null) = " bat"
    • StringUtils.leftPad(“bat”, 5, “”) = " bat"
    • @param str 源字符串
    • @param size 指定的总长度
    • @param padStr 补充的字符串
    • @return String
      /
      @Contract(“null, _, _ -> null”)
      public static String leftPad(String str, int size, String padStr) {
      if (str == null) {
      return null;
      }
      if (isEmpty(padStr)) {
      padStr = " ";
      }
      int padLen = padStr.length();
      int strLen = str.length();
      int pads = size - strLen;
      if (pads <= 0) {
      return str;
      }
      if (padLen == 1 && pads <= PAD_LIMIT) {
      return leftPad(str, size, padStr.charAt(0));
      }
      if (pads == padLen) {
      return padStr.concat(str);
      } else if (pads < padLen) {
      return padStr.substring(0, pads).concat(str);
      } else {
      char[] padding = new char[pads];
      char[] padChars = padStr.toCharArray();
      for (int i = 0; i < pads; i++) {
      padding[i] = padChars[i % padLen];
      }
      return new String(padding).concat(str);
      }
      }
      /      *
    • 扩大字符串长度并将现在的字符串居中，被扩大部分用空格填充。
    • StringUtils.center(null, *) = null
    • StringUtils.center("", 4) = " "
    • StringUtils.center(“ab”, -1) = “ab”
    • StringUtils.center(“ab”, 4) = " ab "
    • StringUtils.center(“abcd”, 2) = “abcd”
    • StringUtils.center(“a”, 4) = " a "
    • @param str 源字符串
    • @param size 指定后的总长度
    • @return String
      */
      @Contract(“null, _ -> null”)
      public static String center(String str, int size) {
      return center(str, size, ’ ');
      }

    /**

    • 将字符串长度修改为指定长度，并进行居中显示。
    • StringUtils.center(null, *, *) = null
    • StringUtils.center("", 4, ’ ') = " "
    • StringUtils.center(“ab”, -1, ’ ') = “ab”
    • StringUtils.center(“ab”, 4, ’ ') = " ab"
    • StringUtils.center(“abcd”, 2, ’ ') = “abcd”
    • StringUtils.center(“a”, 4, ’ ') = " a "
    • StringUtils.center(“a”, 4, ‘y’) = “yayy”
    • @param str 源字符串
    • @param size 指定的总长度
    • @param padChar 长度不够时补充的字符串
    • @return String
    • @throws IllegalArgumentException 如果被补充字符串为 null或者 empty
      /
      @Contract(“null, _, _ -> null”)
      public static String center(String str, int size, char padChar) {
      if (str == null || size <= 0) {
      return str;
      }
      int strLen = str.length();
      int pads = size - strLen;
      if (pads <= 0) {
      return str;
      }
      str = leftPad(str, strLen + pads / 2, padChar);
      str = rightPad(str, size, padChar);
      return str;
      }
      /      *
    • 将字符串长度修改为指定长度，并进行居中显示。
    • StringUtils.center(null, *, *) = null
    • StringUtils.center("", 4, " ") = " "
    • StringUtils.center(“ab”, -1, " ") = “ab”
    • StringUtils.center(“ab”, 4, " “) = " ab”
    • StringUtils.center(“abcd”, 2, " ") = “abcd”
    • StringUtils.center(“a”, 4, " ") = " a "
    • StringUtils.center(“a”, 4, “yz”) = “yayz”
    • StringUtils.center(“abc”, 7, null) = " abc "
    • StringUtils.center(“abc”, 7, “”) = " abc "
    • @param str 源字符串
    • @param size 指定的长度
    • @param padStr 长度不够时补充的字符串
    • @return String
    • @throws IllegalArgumentException 如果被补充字符串为 null或者 empty
      /
      @Contract(“null, _, _ -> null”)
      public static String center(String str, int size, String padStr) {
      if (str == null || size <= 0) {
      return str;
      }
      if (isEmpty(padStr)) {
      padStr = " ";
      }
      int strLen = str.length();
      int pads = size - strLen;
      if (pads <= 0) {
      return str;
      }
      str = leftPad(str, strLen + pads / 2, padStr);
      str = rightPad(str, size, padStr);
      return str;
      }
      /      *
    • 检查字符串是否全部为小写.
    • StringUtils.isAllLowerCase(null) = false
    • StringUtils.isAllLowerCase("") = false
    • StringUtils.isAllLowerCase(" ") = false
    • StringUtils.isAllLowerCase(“abc”) = true
    • StringUtils.isAllLowerCase(“abC”) = false
    • @param cs 源字符串
    • @return String
      /
      @Contract(“null -> false”)
      public static boolean isAllLowerCase(String cs) {
      if (cs == null || isEmpty(cs)) {
      return false;
      }
      int sz = cs.length();
      for (int i = 0; i < sz; i++) {
      if (Character.isLowerCase(cs.charAt(i)) == false) {
      return false;
      }
      }
      return true;
      }
      /      *
    • 检查是否都是大写.
    • StringUtils.isAllUpperCase(null) = false
    • StringUtils.isAllUpperCase("") = false
    • StringUtils.isAllUpperCase(" ") = false
    • StringUtils.isAllUpperCase(“ABC”) = true
    • StringUtils.isAllUpperCase(“aBC”) = false
    • @param cs 源字符串
    • @return String
      /
      public static boolean isAllUpperCase(String cs) {
      if (isEmpty(cs)) {
      return false;
      }
      int sz = cs.length();
      for (int i = 0; i < sz; i++) {
      if (Character.isUpperCase(cs.charAt(i)) == false) {
      return false;
      }
      }
      return true;
      }
      /      *
    • 反转字符串.
    • StringUtils.reverse(null) = null
    • StringUtils.reverse("") = “”
    • StringUtils.reverse(“bat”) = “tab”
    • @param str 源字符串
    • @return String
      /
      @Nullable
      public static String reverse(String str) {
      if (isEmpty(str)) {
      return null;
      }
      return new StringBuilder(str).reverse().toString();
      }
      /      *
    • 字符串达不到一定长度时在右边补空白.
    • StringUtils.rightPad(null, *) = null
    • StringUtils.rightPad("", 3) = " "
    • StringUtils.rightPad(“bat”, 3) = “bat”
    • StringUtils.rightPad(“bat”, 5) = "bat "
    • StringUtils.rightPad(“bat”, 1) = “bat”
    • StringUtils.rightPad(“bat”, -1) = “bat”
    • @param str 源字符串
    • @param size 指定的长度
    • @return String
      */
      @Contract(“null, _ -> null”)
      public static String rightPad(String str, int size) {
      return rightPad(str, size, ’ ');
      }

    /**

    • 从右边截取字符串.
    • StringUtils.right(null, *) = null
    • StringUtils.right(*, -ve) = “”
    • StringUtils.right("", *) = “”
    • StringUtils.right(“abc”, 0) = “”
    • StringUtils.right(“abc”, 2) = “bc”
    • StringUtils.right(“abc”, 4) = “abc”
    • @param str 源字符串
    • @param len 长度
    • @return String
      /
      @Contract(“null, _ -> null”)
      public static String right(String str, int len) {
      if (str == null) {
      return null;
      }
      if (len < 0) {
      return EMPTY;
      }
      if (str.length() <= len) {
      return str;
      }
      return str.substring(str.length() - len);
      }
      /      *
    • 截取一个字符串的前几个.
    • StringUtils.left(null, *) = null
    • StringUtils.left(*, -ve) = “”
    • StringUtils.left("", *) = “”
    • StringUtils.left(“abc”, 0) = “”
    • StringUtils.left(“abc”, 2) = “ab”
    • StringUtils.left(“abc”, 4) = “abc”
    • @param str 源字符串
    • @param len 截取的长度
    • @return the String
      /
      @Nullable
      public static String left(String str, int len) {
      if (isEmpty(str)) {
      return null;
      }
      if (len < 0) {
      return EMPTY;
      }
      if (str.length() <= len) {
      return str;
      }
      return str.substring(0, len);
      }
      /      *
    • 得到tag字符串中间的子字符串，只返回第一个匹配项。
    • StringUtils.substringBetween(null, *) = null
    • StringUtils.substringBetween("", “”) = “”
    • StringUtils.substringBetween("", “tag”) = null
    • StringUtils.substringBetween(“tagabctag”, null) = null
    • StringUtils.substringBetween(“tagabctag”, “”) = “”
    • StringUtils.substringBetween(“tagabctag”, “tag”) = “abc”
    • @param str 源字符串。
    • @param tag 标识字符串。
    • @return String 子字符串, 如果没有符合要求的，返回{@code null}。
      */
      @Contract(“null, _ -> null; !null, null -> null”)
      public static String substringBetween(String str, String tag) {
      return substringBetween(str, tag, tag);
      }

    /**

    • 得到两个字符串中间的子字符串，只返回第一个匹配项。
    • StringUtils.substringBetween(“wx[b]yz”, “[”, “]”) = “b”
    • StringUtils.substringBetween(null, *, *) = null
    • StringUtils.substringBetween(*, null, *) = null
    • StringUtils.substringBetween(*, *, null) = null
    • StringUtils.substringBetween("", “”, “”) = “”
    • StringUtils.substringBetween("", “”, “]”) = null
    • StringUtils.substringBetween("", “[”, “]”) = null
    • StringUtils.substringBetween(“yabcz”, “”, “”) = “”
    • StringUtils.substringBetween(“yabcz”, “y”, “z”) = “abc”
    • StringUtils.substringBetween(“yabczyabcz”, “y”, “z”) = “abc”
    • @param str 源字符串
    • @param open 起字符串。
    • @param close 末字符串。
    • @return String 子字符串, 如果没有符合要求的，返回{@code null}。
      */
      @Contract(“null, _, _ -> null; !null, null, _ -> null; !null, !null, null -> null”)
      public static String substringBetween(String str, String open, String close) {
      if (str == null || open == null || close == null) {
      return null;
      }
      int start = str.indexOf(open);
      if (start != INDEX_NOT_FOUND) {
      int end = str.indexOf(close, start + open.length());
      if (end != INDEX_NOT_FOUND) {
      return str.substring(start + open.length(), end);
      }
      }
      return null;
      }

    /**

    • 得到两个字符串中间的子字符串，所有匹配项组合为数组并返回。
    • StringUtils.substringsBetween("[a][b][c]", “[”, “]”) = [“a”,“b”,“c”]
    • StringUtils.substringsBetween(null, *, *) = null
    • StringUtils.substringsBetween(*, null, *) = null
    • StringUtils.substringsBetween(*, *, null) = null
    • StringUtils.substringsBetween("", “[”, “]”) = []
    • @param str 源字符串
    • @param open 起字符串。
    • @param close 末字符串。
    • @return String 子字符串数组, 如果没有符合要求的，返回{@code null}。
      /
      @Contract(“null, _, _ -> null”)
      public static String[] substringsBetween(String str, String open, String close) {
      if (str == null || isEmpty(open) || isEmpty(close)) {
      return null;
      }
      int strLen = str.length();
      if (strLen == 0) {
      return new String[0];
      }
      int closeLen = close.length();
      int openLen = open.length();
      List list = new ArrayList();
      int pos = 0;
      while (pos < strLen - closeLen) {
      int start = str.indexOf(open, pos);
      if (start < 0) {
      break;
      }
      start += openLen;
      int end = str.indexOf(close, start);
      if (end < 0) {
      break;
      }
      list.add(str.substring(start, end));
      pos = end + closeLen;
      }
      if (list.isEmpty()) {
      return null;
      }
      return list.toArray(new String[list.size()]);
      }
      /      *
    • 切换字符串中的所有字母为大小写(就是大小写互换)
    • StringUtils.swapCase(null) = null
    • StringUtils.swapCase("") = “”
    • StringUtils.swapCase(“The dog has a BONE”) = “tHE DOG HAS A bone”
    • @param str 源字符串
    • @return String
      /
      public static String swapCase(String str) {
      if (isEmpty(str)) {
      return str;
      }
      char[] buffer = str.toCharArray();
      boolean whitespace = true;
      for (int i = 0; i < buffer.length; i++) {
      char ch = buffer[i];
      if (Character.isUpperCase(ch)) {
      buffer[i] = Character.toLowerCase(ch);
      whitespace = false;
      } else if (Character.isTitleCase(ch)) {
      buffer[i] = Character.toLowerCase(ch);
      whitespace = false;
      } else if (Character.isLowerCase(ch)) {
      if (whitespace) {
      buffer[i] = Character.toTitleCase(ch);
      whitespace = false;
      } else {
      buffer[i] = Character.toUpperCase(ch);
      }
      } else {
      whitespace = Character.isWhitespace(ch);
      }
      }
      return new String(buffer);
      }
      /      *
    • 截取出最后一个标志位之后的字符串
    • 如果sourceStr为empty或者expr为null，直接返回源字符串。
    • 如果expr长度为0，直接返回sourceStr。
    • 如果expr在sourceStr中不存在，直接返回sourceStr。
    • @param sourceStr 被截取的字符串
    • @param expr 分隔符
    • @return String
      /
      public static String substringAfterLast(String sourceStr, String expr) {
      if (isEmpty(sourceStr) || expr == null) {
      return sourceStr;
      }
      if (expr.length() == 0) {
      return sourceStr;
      }
      int pos = sourceStr.lastIndexOf(expr);
      if (pos == INDEX_NOT_FOUND) {
      return sourceStr;
      }
      return sourceStr.substring(pos + expr.length());
      }
      /      *
    • 截取出最后一个标志位之前的字符串
    • 如果sourceStr为empty或者expr为null，直接返回源字符串。
    • 如果expr长度为0，直接返回sourceStr。
    • 如果expr在sourceStr中不存在，直接返回sourceStr。
    • @param sourceStr 被截取的字符串
    • @param expr 分隔符
    • @return String
      /
      public static String substringBeforeLast(String sourceStr, String expr) {
      if (isEmpty(sourceStr) || expr == null) {
      return sourceStr;
      }
      if (expr.length() == 0) {
      return sourceStr;
      }
      int pos = sourceStr.lastIndexOf(expr);
      if (pos == INDEX_NOT_FOUND) {
      return sourceStr;
      }
      return sourceStr.substring(0, pos);
      }
      /      *
    • 截取出第一个标志位之后的字符串
    • 如果sourceStr为empty或者expr为null，直接返回源字符串
    • 如果expr长度为0，直接返回sourceStr。
    • 如果expr在sourceStr中不存在，直接返回sourceStr。
    • @param sourceStr 被截取的字符串
    • @param expr 分隔符
    • @return String
      /
      public static String substringAfter(String sourceStr, String expr) {
      if (isEmpty(sourceStr) || expr == null) {
      return sourceStr;
      }
      if (expr.length() == 0) {
      return sourceStr;
      }
      int pos = sourceStr.indexOf(expr);
      if (pos == INDEX_NOT_FOUND) {
      return sourceStr;
      }
      return sourceStr.substring(pos + expr.length());
      }
      /      *
    • 截取出第一个标志位之前的字符串
    • 如果sourceStr为empty或者expr为null，直接返回源字符串。
    • 如果expr长度为0，直接返回sourceStr。
    • 如果expr在sourceStr中不存在，直接返回sourceStr。
    • 如果expr在sourceStr中存在不止一个，以第一个位置为准。
    • @param sourceStr 被截取的字符串
    • @param expr 分隔符
    • @return String
      /
      public static String substringBefore(String sourceStr, String expr) {
      if (isEmpty(sourceStr) || expr == null) {
      return sourceStr;
      }
      if (expr.length() == 0) {
      return sourceStr;
      }
      int pos = sourceStr.indexOf(expr);
      if (pos == -1) {
      return sourceStr;
      }
      return sourceStr.substring(0, pos);
      }
      /      *
    • 如果字符串没有超过最长显示长度返回原字符串，否则从开头截取指定长度并加…返回。
    • @param str 原字符串
    • @param length 字符串最长显示的长度
    • @return 转换后的字符串
      */
      @Contract(“null, _ -> !null”)
      public static String trimString(String str, int length) {
      if (str == null) {
      return “”;
      } else if (str.length() > length) {
      return str.substring(0, length - 3) + “…”;
      } else {
      return str;
      }
      }

    /**

    • 编码为Unicode，格式 ‘\u0020’.
    • CharUtils.unicodeEscaped(’ ') = “\u0020”
    • CharUtils.unicodeEscaped(‘A’) = “\u0041”
    • @param ch 源字符串
    • @return 转码后的字符串
      /
      @NotNull
      public static String unicodeEscaped(char ch) {
      if (ch < 0x10) {
      return “\u000” + Integer.toHexString(ch);
      } else if (ch < 0x100) {
      return “\u00” + Integer.toHexString(ch);
      } else if (ch < 0x1000) {
      return “\u0” + Integer.toHexString(ch);
      }
      return “\u” + Integer.toHexString(ch);
      }
      /      *
    • 判断对象每个是否都为空，若传入空则抛异常
    • @param obj
    • @return
    • @throws IllegalAccessException
      */
      @Contract(“null -> true”)
      public static boolean checkObjFieldIsNull(Object obj) throws IllegalAccessException {
      boolean flag = false;
      for (Field f : obj.getClass().getDeclaredFields()) {
      f.setAccessible(true);
      if (f.get(obj) == null || f.get(obj).equals("")) {
      flag = true;
      return flag;
      }
      }
      return flag;
      }

    /**

    • 判断对象是否为空
    • @param obj
    • @return
      */
      @Contract(“null -> true”)
      public static boolean isNull(Object obj) {
      return obj == null;
      }

    /**

    • 判断对象是否为空
    • @param obj
    • @return
      */
      @Contract(“null -> false”)
      public static boolean isNotNull(Object obj) {
      return !isNull(obj);
      }

    /**

    • 判断对象是否为空，如集合、数组、所属对象等
    • @param obj
    • @return
      */
      @Contract(“null -> true”)
      public static boolean isEmpty(Object obj) {
      if (obj == null) {
      return true;
      } else if (obj instanceof CharSequence) {
      return ((CharSequence) obj).length() == 0;
      } else if (obj instanceof Collection) {
      return ((Collection) obj).isEmpty();
      } else if (obj instanceof Map) {
      return ((Map) obj).isEmpty();
      } else if (obj.getClass().isArray()) {
      return Array.getLength(obj) == 0;
      }
      return false;
      }

    /**

    • 判断对象是否为空，如集合、数组、所属对象等
    • @param obj
    • @return
      */
      @Contract(“null -> false”)
      public static boolean isNotEmpty(Object obj) {
      return !isEmpty(obj);
      }

    /**

    • 格式化文本, {} 表示占位符
    • 此方法只是简单将占位符 {} 按照顺序替换为参数
    • 如果想输出 {} 使用 \转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\ 即可
    • 例：
    • 通常使用：format(“this is {} for {}”, “a”, “b”) =》 this is a for b
    • 转义{}： format(“this is \{} for {}”, “a”, “b”) =》 this is {} for a
    • 转义\： format(“this is \\{} for {}”, “a”, “b”) =》 this is \a for b
    • @param template 文本模板，被替换的部分用 {} 表示
    • @param params 参数值
    • @return 格式化后的文本
      */
      public static String format(CharSequence template, Object… params) {
      if (null == template) {
      return null;
      }
      if (ArrayUtil.isEmpty(params) || isEmpty(template)) {
      return template.toString();
      }
      return StrFormatter.format(template.toString(), params);
      }

    /**

    • 格式化文本，使用 {varName} 占位

    • map = {a: “aValue”, b: “bValue”} format("{a} and {b}", map) —=》 aValue and bValue

    • @param template 文本模板，被替换的部分用 {key} 表示

    • @param map 参数值对

    • @return 格式化后的文本
      */
      public static String format(CharSequence template, Map<?, ?> map) {
      if (null == template) {
      return null;
      }
      if (null == map || map.isEmpty()) {
      return template.toString();
      }

      String template2 = template.toString();
      for (Map.Entry<?, ?> entry : map.entrySet()) {
      template2 = template2.replace("{" + entry.getKey() + “}”, utf8Str(entry.getValue()));
      }
      return template2;
      }

    /**

    • 将对象转为字符串
    • 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    • @param obj 对象
    • @return 字符串
      */
      public static String utf8Str(Object obj) {
      return str(obj, CharsetUtil.CHARSET_UTF_8);
      }

    /**

    • 将对象转为字符串

    • 1、Byte数组和ByteBuffer会被转换为对应字符串的数组

    • 2、对象数组会调用Arrays.toString方法

    • @param obj 对象

    • @param charset 字符集

    • @return 字符串
      */
      public static String str(Object obj, Charset charset) {
      if (null == obj) {
      return null;
      }
      if (obj instanceof String) {
      return (String) obj;
      } else if (obj instanceof byte[]) {
      return str((byte[]) obj, charset);
      } else if (obj instanceof Byte[]) {
      return str((Byte[]) obj, charset);
      } else if (obj instanceof ByteBuffer) {
      return str((ByteBuffer) obj, charset);
      } else if (ArrayUtil.isArray(obj)) {
      return ArrayUtil.toString(obj);
      }

      return obj.toString();
      }

    /**

    • 解码字节码

    • @param data 字符串

    • @param charset 字符集，如果此字段为空，则解码的结果取决于平台

    • @return 解码后的字符串
      */
      public static String str(byte[] data, Charset charset) {
      if (data == null) {
      return null;
      }

      if (null == charset) {
      return new String(data);
      }
      return new String(data, charset);
      }

    /**

    • 将byte数组转为字符串
    • @param bytes byte数组
    • @param charset 字符集
    • @return 字符串
      */
      public static String str(byte[] bytes, String charset) {
      return str(bytes, isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
      }

    /**

    • {@link CharSequence} 转为字符串，null安全
    • @param cs {@link CharSequence}
    • @return 字符串
      */
      public static String str(CharSequence cs) {
      return null == cs ? null : cs.toString();
      }

    /**

    • 改进JDK subString

    • index从0开始计算，最后一个字符为-1

    • 如果from和to位置一样，返回 “”

    • 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length

    • 如果经过修正的index中from大于to，则互换from和to example:

    • abcdefgh 2 3 =》 c

    • abcdefgh 2 -3 =》 cde

    • @param str String

    • @param fromIndex 开始的index（包括）

    • @param toIndex 结束的index（不包括）

    • @return 字串
      */
      public static String sub(CharSequence str, int fromIndex, int toIndex) {
      if (isEmpty(str)) {
      return str(str);
      }
      int len = str.length();

      if (fromIndex < 0) {
      fromIndex = len + fromIndex;
      if (fromIndex < 0) {
      fromIndex = 0;
      }
      } else if (fromIndex > len) {
      fromIndex = len;
      }

      if (toIndex < 0) {
      toIndex = len + toIndex;
      if (toIndex < 0) {
      toIndex = len;
      }
      } else if (toIndex > len) {
      toIndex = len;
      }
      if (toIndex < fromIndex) {
      int tmp = fromIndex;
      fromIndex = toIndex;
      toIndex = tmp;
      }
      if (fromIndex == toIndex) {
      return EMPTY;
      }
      return str.toString().substring(fromIndex, toIndex);
      }
      /**

    • 切分字符串

    • @param str 被切分的字符串

    • @param separator 分隔符

    • @return 字符串
      /
      public static String[] splits(CharSequence str, CharSequence separator) {
      if (str == null) {
      return new String[]{};
      }
      final String separatorStr = (null == separator) ? null : separator.toString();
      return StrSpliter.splitToArray(str.toString(), separatorStr, 0, false, false);
      }
      /      *

    • 切分字符串，不去除切分后每个元素两边的空白符，不去除空白项

    • @param str 被切分的字符串

    • @param separator 分隔符字符

    • @param limit 限制分片数，-1不限制

    • @return 切分后的集合
      */
      public static List split(CharSequence str, char separator, int limit) {
      return split(str, separator, limit, false, false);
      }

    /**

    • 切分字符串
    • a#b#c =》 [a,b,c]
    • a##b#c =》 [a,"",b,c]
    • @param str 被切分的字符串
    • @param separator 分隔符字符
    • @return 切分后的集合
      */
      public static List split(CharSequence str, char separator) {
      return split(str, separator, 0);
      }

    /**

    • 切分字符串

    • @param str 被切分的字符串

    • @param separator 分隔符

    • @return 字符串
      */
      public static String[] split(CharSequence str, CharSequence separator) {
      if (str == null) {
      return new String[]{};
      }

      final String separatorStr = (null == separator) ? null : separator.toString();
      return StrSpliter.splitToArray(str.toString(), separatorStr, 0, false, false);
      }

    /**

    • 指定范围内反向查找字符串

    • @param str 字符串

    • @param searchStr 需要查找位置的字符串

    • @param fromIndex 起始位置

    • @param ignoreCase 是否忽略大小写

    • @return 位置
      */
      public static int indexOf(final CharSequence str, CharSequence searchStr, int fromIndex, boolean ignoreCase) {
      if (str == null || searchStr == null) {
      return INDEX_NOT_FOUND;
      }
      if (fromIndex < 0) {
      fromIndex = 0;
      }

      final int endLimit = str.length() - searchStr.length() + 1;
      if (fromIndex > endLimit) {
      return INDEX_NOT_FOUND;
      }
      if (searchStr.length() == 0) {
      return fromIndex;
      }

      if (false == ignoreCase) {
      // 不忽略大小写调用JDK方法
      return str.toString().indexOf(searchStr.toString(), fromIndex);
      }

      for (int i = fromIndex; i < endLimit; i++) {
      if (isSubEquals(str, i, searchStr, 0, searchStr.length(), true)) {
      return i;
      }
      }
      return INDEX_NOT_FOUND;
      }
      /**

    • 截取两个字符串的不同部分（长度一致），判断截取的子串是否相同

    • 任意一个字符串为null返回false

    • @param str1 第一个字符串

    • @param start1 第一个字符串开始的位置

    • @param str2 第二个字符串

    • @param start2 第二个字符串开始的位置

    • @param length 截取长度

    • @param ignoreCase 是否忽略大小写

    • @return 子串是否相同
      */
      public static boolean isSubEquals(CharSequence str1, int start1, CharSequence str2, int start2, int length, boolean ignoreCase) {
      if (null == str1 || null == str2) {
      return false;
      }
      return str1.toString().regionMatches(ignoreCase, start1, str2.toString(), start2, length);
      }

    /**

    • 如果字符串是null，则返回指定默认字符串，否则返回字符串本身。
    • nullToDefault(null, "default") = "default"
    • nullToDefault("", "default") = ""
    • nullToDefault(" ", "default") = " "
    • nullToDefault("bat", "default") = "bat"
    •  
    • @param str 要转换的字符串
    • @param defaultStr 默认字符串
    • @return 字符串本身或指定的默认字符串
       */
       public static String nullToDefault(CharSequence str, String defaultStr) {
       return (str == null) ? defaultStr : str.toString();
       }
     
    /**
     
  
    • 当给定字符串为null时，转换为Empty
    • @param str 被转换的字符串
    • @return 转换后的字符串
       */
       public static String nullToEmpty(CharSequence str) {
       return nullToDefault(str, EMPTY);
       }
     
    /**
     
  
    • 包装指定字符串
    • @param str 被包装的字符串
    • @param prefix 前缀
    • @param suffix 后缀
    • @return 包装后的字符串
       */
       public static String wrap(CharSequence str, CharSequence prefix, CharSequence suffix) {
       return nullToEmpty(prefix).concat(nullToEmpty(str)).concat(nullToEmpty(suffix));
       }
     
    /**
     
  
    •  
      去掉指定后缀
       
    •  
      @param str 字符串
       
    •  
      @param suffix 后缀
       
    •  
      @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
       */
       public static String removeSuffix(CharSequence str, CharSequence suffix) {
       if (isEmpty(str) || isEmpty(suffix)) {
       return str(str);
       }
       
      final String str2 = str.toString();
       if (str2.endsWith(suffix.toString())) {
       return subPre(str2, str2.length() - suffix.length());// 截取前半段
       }
       return str2;
       }
       
     
    /**
     
  
    • 限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"…"
    • @param string 字符串
    • @param length 最大长度
    • @return 切割后的剩余的前半部分字符串+"…"
       /
       public static String maxLength(CharSequence string, int length) {
       Assert.isTrue(length > 0);
       if (null == string) {
       return null;
       }
       if (string.length() <= length) {
       return string.toString();
       }
       return sub(string, 0, length) + “…”;
       }
       /      *
    • 切割指定位置之前部分的字符串
    • @param string 字符串
    • @param toIndex 切割到的位置（不包括）
    • @return 切割后的剩余的前半部分字符串
       /
       public static String subPre(CharSequence string, int toIndex) {
       return sub(string, 0, toIndex);
       }
       /      *
    • 切割指定位置之后部分的字符串
    • @param string 字符串
    • @param fromIndex 切割开始的位置（包括）
    • @return 切割后后剩余的后半部分字符串
       /
       public static String subSuf(CharSequence string, int fromIndex) {
       if (isEmpty(string)) {
       return null;
       }
       return sub(string, fromIndex, string.length());
       }
       /      *
    • 大写首字母
    • 例如：str = name, return Name
    • @param str 字符串
    • @return 字符串
       */
       public static String upperFirst(CharSequence str) {
       if (null == str) {
       return null;
       }
       if (str.length() > 0) {
       char firstChar = str.charAt(0);
       if (Character.isLowerCase(firstChar)) {
       return Character.toUpperCase(firstChar) + subSuf(str, 1);
       }
       }
       return str.toString();
       }
     
    /**
     
  
    • 原字符串首字母大写并在其首部添加指定字符串 例如：str=name, preString=get =》 return getName
    • @param str 被处理的字符串
    • @param preString 添加的首部
    • @return 处理后的字符串
       */
       public static String upperFirstAndAddPre(CharSequence str, String preString) {
       if (str == null || preString == null) {
       return null;
       }
       return preString + upperFirst(str);
       }
     
    /**
     
  
    • 将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
    • 例如：hello_world=》helloWorld
    • @param name 转换前的下划线大写方式命名的字符串
    • @return 转换后的驼峰式命名的字符串
       /
       public static String toCamelCase(CharSequence name) {
       if (null == name) {
       return null;
       }
       String name2 = name.toString();
       if (name2.contains(UNDERLINE)) {
       final StringBuilder sb = new StringBuilder(name2.length());
       boolean upperCase = false;
       for (int i = 0; i < name2.length(); i++) {
       char c = name2.charAt(i);
       if (c == CharUtil.UNDERLINE) {
       upperCase = true;
       } else if (upperCase) {
       sb.append(Character.toUpperCase©);
       upperCase = false;
       } else {
       sb.append(Character.toLowerCase©);
       }
       }
       return sb.toString();
       } else {
       return name2;
       }
       }
       /      *
    • 去掉指定前缀-忽略大小写
    • @param str 字符串
    • @param prefix 前缀
    • @return 切掉后的字符串，若前缀不是 preffix， 返回原字符串
       /
       public static String removePrefix(CharSequence str, CharSequence prefix) {
       if (isEmpty(str) || isEmpty(prefix)) {
       return str(str);
       }
       final String str2 = str.toString();
       if (str2.toLowerCase().startsWith(prefix.toString().toLowerCase())) {
       //截取后半段
       return subSuf(str2, prefix.length());
       }
       return str2;
       }
       /      *
    • 指定范围内查找指定字符
    • @param str 字符串
    • @param searchChar 被查找的字符
    • @param start 起始位置，如果小于0，从0开始查找
    • @param end 终止位置，如果超过str.length()则默认查找到字符串末尾
    • @return 位置
       /
       public static int indexOf(final CharSequence str, char searchChar, int start, int end) {
       final int len = str.length();
       if (start < 0 || start > len) {
       start = 0;
       }
       if (end > len || end < 0) {
       end = len;
       }
       for (int i = start; i < end; i++) {
       if (str.charAt(i) == searchChar) {
       return i;
       }
       }
       return -1;
       }
       /      *
    • 指定范围内查找指定字符
    • @param str 字符串
    • @param searchChar 被查找的字符
    • @param start 起始位置，如果小于0，从0开始查找
    • @return 位置
       /
       public static int indexOf(final CharSequence str, char searchChar, int start) {
       if (str instanceof String) {
       return ((String) str).indexOf(searchChar, start);
       } else {
       return indexOf(str, searchChar, start, -1);
       }
       }
       /      *
    • 指定范围内查找指定字符
    • @param str 字符串
    • @param searchChar 被查找的字符
    • @return 位置
       /
       public static int indexOf(final CharSequence str, char searchChar) {
       return indexOf(str, searchChar, 0);
       }
       /      *
    • 指定字符是否在字符串中出现过
    • @param str 字符串
    • @param searchChar 被查找的字符
    • @return 是否包含
       */
       public static boolean contains(CharSequence str, char searchChar) {
       return indexOf(str, searchChar) > -1;
       }
     
    /**
     
  
    • 创建StringBuilder对象
    • @return StringBuilder对象
       */
       public static StringBuilder builder() {
       return new StringBuilder();
       }
     
    /**
     
  
    • 创建StringBuilder对象
    • @param capacity 初始大小
    • @return StringBuilder对象
       */
       public static StringBuilder builder(int capacity) {
       return new StringBuilder(capacity);
       }
     
    /**
     
  
    • 创建StrBuilder对象
    • @return StrBuilder对象
       */
       public static StrBuilder strBuilder() {
       return StrBuilder.create();
       }
     
    /**
     
  
    • 切分字符串
    • @param str 被切分的字符串
    • @param separator 分隔符字符
    • @param limit 限制分片数，-1不限制
    • @param isTrim 是否去除切分字符串后每个元素两边的空格
    • @param ignoreEmpty 是否忽略空串
    • @return 切分后的集合
       */
       public static List split(CharSequence str, char separator, int limit, boolean isTrim, boolean ignoreEmpty) {
       if (null == str) {
       return new ArrayList<>(0);
       }
       return StrSpliter.split(str.toString(), separator, limit, isTrim, ignoreEmpty);
       }
     
    /**
     
  
    • 切分字符串，去除切分后每个元素两边的空白符，去除空白项
    • @param str 被切分的字符串
    • @param separator 分隔符字符
    • @param limit 限制分片数，-1不限制
    • @return 切分后的集合
       */
       public static List splitTrim(CharSequence str, char separator, int limit) {
       return split(str, separator, limit, true, true);
       }
     
    /**
     
  
    • 切分字符串，去除切分后每个元素两边的空白符，去除空白项
    • @param str 被切分的字符串
    • @param separator 分隔符字符
    • @return 切分后的集合
       */
       public static List splitTrim(CharSequence str, char separator) {
       return splitTrim(str, separator, -1);
       }
     
    /**
     
  
    • 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
    • @param str 指定字符串
    • @param testStrs 需要检查的字符串数组
    • @return 被包含的第一个字符串
       */
       public static String getContainsStr(CharSequence str, CharSequence… testStrs) {
       if (isEmpty(str) || ArrayUtil.isEmpty(testStrs)) {
       return null;
       }
       for (CharSequence checkStr : testStrs) {
       if (str.toString().contains(checkStr)) {
       return checkStr.toString();
       }
       }
       return null;
       }
     
    /**
     
  
    • 查找指定字符串是否包含指定字符串列表中的任意一个字符串
    • @param str 指定字符串
    • @param testStrs 需要检查的字符串数组
    • @return 是否包含任意一个字符串
       */
       public static boolean containsAny(CharSequence str, CharSequence… testStrs) {
       return null != getContainsStr(str, testStrs);
       }
     
    /**
     
  
    • 去掉字符包装，如果未被包装则返回原字符串
    • @param str 字符串
    • @param prefix 前置字符
    • @param suffix 后置字符
    • @return 去掉包装字符的字符串
       */
       public static String unWrap(CharSequence str, char prefix, char suffix) {
       if (isEmpty(str)) {
       return str(str);
       }
       if (str.charAt(0) == prefix && str.charAt(str.length() - 1) == suffix) {
       return sub(str, 1, str.length() - 1);
       }
       return str.toString();
       }
     
    /**
     
  
    • 去掉字符包装，如果未被包装则返回原字符串
    • @param str 字符串
    • @param prefixAndSuffix 前置和后置字符
    • @return 去掉包装字符的字符串
       */
       public static String unWrap(CharSequence str, char prefixAndSuffix) {
       return unWrap(str, prefixAndSuffix, prefixAndSuffix);
       }
     
    /**
     
  
    • 将驼峰式命名的字符串转换为使用符号连接方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
    • @param str 转换前的驼峰式命名的字符串，也可以为符号连接形式
    • @param symbol 连接符
    • @return 转换后符号连接方式命名的字符串
       */
       public static String toSymbolCase(CharSequence str, char symbol) {
       if (str == null) {
       return null;
       }
       final int length = str.length();
       final StringBuilder sb = new StringBuilder();
       char c;
       for (int i = 0; i < length; i++) {
       c = str.charAt(i);
       final Character preChar = (i > 0) ? str.charAt(i - 1) : null;
       if (Character.isUpperCase©) {
       //遇到大写字母处理
       final Character nextChar = (i < str.length() - 1) ? str.charAt(i + 1) : null;
       if (null != preChar && Character.isUpperCase(preChar)) {
       //前一个字符为大写，则按照一个词对待
       sb.append©;
       } else if (null != nextChar && Character.isUpperCase(nextChar)) {
       //后一个为大写字母，按照一个词对待
       if (null != preChar && symbol != preChar) {
       //前一个是非大写时按照新词对待，加连接符
       sb.append(symbol);
       }
       sb.append©;
       } else {
       //前后都为非大写按照新词对待
       if (null != preChar && symbol != preChar) {
       //前一个非连接符，补充连接符
       sb.append(symbol);
       }
       sb.append(Character.toLowerCase©);
       }
       } else {
       if (sb.length() > 0 && Character.isUpperCase(sb.charAt(sb.length() - 1)) && symbol != c) {
       //当结果中前一个字母为大写，当前为小写，说明此字符为新词开始（连接符也表示新词）
       sb.append(symbol);
       }
       //小写或符号
       sb.append©;
       }
       }
       return sb.toString();
       }
     
    /**
     
  
    • 将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
    • 例如：
    •  
    • HelloWorld=》hello_world
    • Hello_World=》hello_world
    • HelloWorld_test=》hello_world_test
    •  
    • @param str 转换前的驼峰式命名的字符串，也可以为下划线形式
    • @return 转换后下划线方式命名的字符串
       */
       public static String toUnderlineCase(CharSequence str) {
       return toSymbolCase(str, CharUtil.UNDERLINE);
       }
     
    /**
     
  
    • 除去字符串头尾部的空白符，如果字符串是null，依然返回null。
    • @param str 要处理的字符串
    • @param mode -1表示trimStart，0表示trim全部， 1表示trimEnd
    • @return 除去指定字符后的的字符串，如果原字串为null，则返回null
       /
       public static String trim(CharSequence str, int mode) {
       if (str == null) {
       return null;
       }
       int length = str.length();
       int start = 0;
       int end = length;
       // 扫描字符串头部
       if (mode <= 0) {
       while ((start < end) && (CharUtil.isBlankChar(str.charAt(start)))) {
       start++;
       }
       }
       // 扫描字符串尾部
       if (mode >= 0) {
       while ((start < end) && (CharUtil.isBlankChar(str.charAt(end - 1)))) {
       end–;
       }
       }
       if ((start > 0) || (end < length)) {
       return str.toString().substring(start, end);
       }
       return str.toString();
       }
       /      *
    • 除去字符串头尾部的空白，如果字符串是null，依然返回null。
    •  
       
    •  
       
    • 注意，和String.trim不同，此方法使用NumberUtil.isBlankChar 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。
    •  
    • trim(null) = null
    • trim("") = ""
    • trim(" ") = ""
    • trim("abc") = "abc"
    • trim(" abc ") = "abc"
    •  
    • @param str 要处理的字符串
    • @return 除去头尾空白的字符串，如果原字串为null，则返回null
       */
       public static String trim(CharSequence str) {
       return (null == str) ? null : trim(str, 0);
       }
     
    /**
     
  
    •  
      编码字符串
       
    •  
      @param str 字符串
       
    •  
      @param charset 字符集，如果此字段为空，则解码的结果取决于平台
       
    •  
      @return 编码后的字节码
       */
       public static byte[] bytes(CharSequence str, Charset charset) {
       if (str == null) {
       return null;
       }
       
      if (null == charset) {
       return str.toString().getBytes();
       }
       return str.toString().getBytes(charset);
       }
       
     
    /**
     
  
    • 编码字符串
    • @param str 字符串
    • @param charset 字符集，如果此字段为空，则解码的结果取决于平台
    • @return 编码后的字节码
       */
       public static byte[] bytes(CharSequence str, String charset) {
       return bytes(str, isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
       }
     
    /**
     
  
    •  
      是否包含空字符串
       
    •  
      @param strs 字符串列表
       
    •  
      @return 是否包含空字符串
       */
       public static boolean hasBlank(CharSequence… strs) {
       if (ArrayUtil.isEmpty(strs)) {
       return true;
       }
       
      for (CharSequence str : strs) {
       if (isEmpty(str)) {
       return true;
       }
       }
       return false;
       }
       
     
    /**
     
  
    • 比较两个字符串（大小写不敏感）。
    •  
    • equalsIgnoreCase(null, null) = true
    • equalsIgnoreCase(null, "abc") = false
    • equalsIgnoreCase("abc", null) = false
    • equalsIgnoreCase("abc", "abc") = true
    • equalsIgnoreCase("abc", "ABC") = true
    •  
    • @param str1 要比较的字符串1
    • @param str2 要比较的字符串2
    • @return 如果两个字符串相同，或者都是null，则返回true
       */
       public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2) {
       return equals(str1, str2, true);
       }
     
    /**
     
  
    •  
      是否以指定字符串开头
       
    •  
      如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
       
    •  
      @param str 被监测字符串
       
    •  
      @param prefix 开头字符串
       
    •  
      @param isIgnoreCase 是否忽略大小写
       
    •  
      @return 是否以指定字符串开头
       */
       public static boolean startWith(CharSequence str, CharSequence prefix, boolean isIgnoreCase) {
       if (null == str || null == prefix) {
       if (null == str && null == prefix) {
       return true;
       }
       return false;
       }
       
      if (isIgnoreCase) {
       return str.toString().toLowerCase().startsWith(prefix.toString().toLowerCase());
       } else {
       return str.toString().startsWith(prefix.toString());
       }
       }
       
     
    /**
     
  
    • 字符串是否以给定字符开始
    • @param str 字符串
    • @param c 字符
    • @return 是否开始
       */
       public static boolean startWith(CharSequence str, char c) {
       return c == str.charAt(0);
       }
     
    /**
     
  
    • 移除字符串中所有给定字符串
    • 例：removeAll(“aa-bb-cc-dd”, “-”) =》 aabbccdd
    • @param str 字符串
    • @param strToRemove 被移除的字符串
    • @return 移除后的字符串
       */
       public static String removeAll(CharSequence str, CharSequence strToRemove) {
       if (isEmpty(str)) {
       return str(str);
       }
       return str.toString().replace(strToRemove, EMPTY);
       }
     
    /**
     
  
    • 字符串的每一个字符是否都与定义的匹配器匹配
    • @param value 字符串
    • @param matcher 匹配器
    • @return 是否全部匹配
       /
       public static boolean isAllCharMatch(CharSequence value, com.function.app.functioncommon.util.lang.Matcher matcher) {
       if (StringUtilsApp.isEmpty(value)) {
       return false;
       }
       int len = value.length();
       boolean isAllMatch = true;
       for (int i = 0; i < len; i++) {
       isAllMatch &= matcher.match(value.charAt(i));
       }
       return isAllMatch;
       }
       /      *
    • 除去字符串头尾部的空白，如果字符串是{@code null}，返回""。
    •  
    • StrUtil.trimToNull(null) = null
    • StrUtil.trimToNull("") = null
    • StrUtil.trimToNull(" ") = null
    • StrUtil.trimToNull(“abc”) = “abc”
    • StrUtil.trimToEmpty(" abc ") = “abc”
    •  
    • @param str 字符串
    • @return 去除两边空白符后的字符串, 如果为空返回null
       */
       public static String trimToNull(CharSequence str) {
       final String trimStr = trim(str);
       return EMPTY.equals(trimStr) ? null : trimStr;
       }
     
    /**
     
  
    •  
      替换指定字符串的指定区间内字符为固定字符
       
    •  
      @param str 字符串
       
    •  
      @param startInclude 开始位置（包含）
       
    •  
      @param endExclude 结束位置（不包含）
       
    •  
      @param replacedChar 被替换的字符
       
    •  
      @return 替换后的字符串
       */
       public static String replace(CharSequence str, int startInclude, int endExclude, char replacedChar) {
       if (isEmpty(str)) {
       return str(str);
       }
       final int strLength = str.length();
       if (startInclude > strLength) {
       return str(str);
       }
       if (endExclude > strLength) {
       endExclude = strLength;
       }
       if (startInclude > endExclude) {
       // 如果起始位置大于结束位置，不替换
       return str(str);
       }
       
      final char[] chars = new char[strLength];
       for (int i = 0; i < strLength; i++) {
       if (i >= startInclude && i < endExclude) {
       chars[i] = replacedChar;
       } else {
       chars[i] = str.charAt(i);
       }
       }
       return new String(chars);
       }
       /**
       
    •  
      是否包含特定字符，忽略大小写，如果给定两个参数都为null，返回true
       
    •  
      @param str 被检测字符串
       
    •  
      @param testStr 被测试是否包含的字符串
       
    •  
      @return 是否包含
       */
       public static boolean containsIgnoreCase(CharSequence str, CharSequence testStr) {
       if (null == str) {
       // 如果被监测字符串和
       return null == testStr;
       }
       return str.toString().toLowerCase().contains(testStr.toString().toLowerCase());
       }
       
     
    /**
     
  
    • 下标为 -1
       /
       private static final int INDEX_NOT_FOUND = -1;
       /      *
    • 空字符串
       /
       public static final String EMPTY = “”;
       /      *
    • 填充常量 可以扩展的最大大小
       */
       private static final int PAD_LIMIT = 8192;
     
    /**
     
  
    •  
      清理空白字符
       
    •  
      @param str 被清理的字符串
       
    •  
      @return 清理后的字符串
       */
       public static String cleanBlank(CharSequence str) {
       if (str == null) {
       return null;
       }
       
      int len = str.length();
       final StringBuilder sb = new StringBuilder(len);
       char c;
       for (int i = 0; i < len; i++) {
       c = str.charAt(i);
       if (false == CharUtil.isBlankChar©) {
       sb.append©;
       }
       }
       return sb.toString();
       }
       /**
       
    •  
      截取分隔字符串之后的字符串，不包括分隔字符串
       
    •  
      如果给定的字符串为空串（null或""），返回原字符串
       
    •  
      如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串
       
    •  
       
    •  
      栗子：
       
    •  
    •  
      StrUtil.subAfter(null, *) = null
       
    •  
      StrUtil.subAfter("", *) = “”
       
    •  
      StrUtil.subAfter(*, null) = “”
       
    •  
      StrUtil.subAfter(“abc”, “a”) = “bc”
       
    •  
      StrUtil.subAfter(“abcba”, “b”) = “cba”
       
    •  
      StrUtil.subAfter(“abc”, “c”) = “”
       
    •  
      StrUtil.subAfter(“abc”, “d”) = “”
       
    •  
      StrUtil.subAfter(“abc”, “”) = “abc”
       
    •  
    •  
      @param string 被查找的字符串
       
    •  
      @param separator 分隔字符串（不包括）
       
    •  
      @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
       
    •  
      @return 切割后的字符串
       */
       public static String subAfter(CharSequence string, CharSequence separator, boolean isLastSeparator) {
       if (isEmpty(string)) {
       return null == string ? null : string.toString();
       }
       if (separator == null) {
       return EMPTY;
       }
       final String str = string.toString();
       final String sep = separator.toString();
       final int pos = isLastSeparator ? str.lastIndexOf(sep) : str.indexOf(sep);
       if (pos == INDEX_NOT_FOUND) {
       return EMPTY;
       }
       return str.substring(pos + separator.length());
       }
       
     
    /**
     
  
    • 字符串是否以给定字符结尾
    • @param str 字符串
    • @param c 字符
    • @return 是否结尾
       */
       public static boolean endWith(CharSequence str, char c) {
       return c == str.charAt(str.length() - 1);
       }
     
    /**
     
  
    •  
      给定字符串是否被字符包围
       
    •  
      @param str 字符串
       
    •  
      @param prefix 前缀
       
    •  
      @param suffix 后缀
       
    •  
      @return 是否包围，空串不包围
       /
       public static boolean isSurround(CharSequence str, char prefix, char suffix) {
       if (StringUtilsApp.isEmpty(str)) {
       return false;
       }
       if (str.length() < 2) {
       return false;
       }
       return str.charAt(0) == prefix && str.charAt(str.length() - 1) == suffix;
       }
       /      *
       
    •  
      切分字符串
       
    •  
      @param str 被切分的字符串
       
    •  
      @param separator 分隔符字符
       
    •  
      @param limit 限制分片数
       
    •  
      @return 切分后的数组
       /
       public static String[] splitToArray(CharSequence str, char separator, int limit) {
       if (null == str) {
       return new String[]{};
       }
       return StrSpliter.splitToArray(str.toString(), separator, limit, false, false);
       }
       /      *
       
    •  
      切分字符串
       
    •  
      @param str 被切分的字符串
       
    •  
      @param separator 分隔符字符
       
    •  
      @return 切分后的数组
       /
       public static String[] splitToArray(CharSequence str, char separator) {
       return splitToArray(str, separator, 0);
       }
       /      *
       
    •  
      是否以指定字符串结尾
       
    •  
      如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
       
    •  
      @param str 被监测字符串
       
    •  
      @param suffix 结尾字符串
       
    •  
      @param isIgnoreCase 是否忽略大小写
       
    •  
      @return 是否以指定字符串结尾
       */
       public static boolean endWith(CharSequence str, CharSequence suffix, boolean isIgnoreCase) {
       if (null == str || null == suffix) {
       if (null == str && null == suffix) {
       return true;
       }
       return false;
       }
       
      if (isIgnoreCase) {
       return str.toString().toLowerCase().endsWith(suffix.toString().toLowerCase());
       } else {
       return str.toString().endsWith(suffix.toString());
       }
       }
       
     
    /**
     
  
    • 是否以指定字符串结尾，忽略大小写
    • @param str 被监测字符串
    • @param suffix 结尾字符串
    • @return 是否以指定字符串结尾
       */
       public static boolean endWithIgnoreCase(CharSequence str, CharSequence suffix) {
       return endWith(str, suffix, true);
       }
     
    /**
     
  
    • 指定范围内查找字符串
    • @param str 字符串
    • @param searchStr 需要查找位置的字符串
    • @param fromIndex 起始位置，从后往前计数
    • @param ignoreCase 是否忽略大小写
    • @return 位置
       */
       public static int lastIndexOf(final CharSequence str, final CharSequence searchStr, int fromIndex, boolean ignoreCase) {
       if (str == null || searchStr == null) {
       return INDEX_NOT_FOUND;
       }
       if (fromIndex < 0) {
       fromIndex = 0;
       }
       fromIndex = Math.min(fromIndex, str.length());
       if (searchStr.length() == 0) {
       return fromIndex;
       }
       if (false == ignoreCase) {
       // 不忽略大小写调用JDK方法
       return str.toString().lastIndexOf(searchStr.toString(), fromIndex);
       }
       for (int i = fromIndex; i > 0; i–) {
       if (isSubEquals(str, i, searchStr, 0, searchStr.length(), true)) {
       return i;
       }
       }
       return INDEX_NOT_FOUND;
       }
     
    /**
     
  
    • 指定范围内查找字符串，忽略大小写
    • @param str 字符串
    • @param searchStr 需要查找位置的字符串
    • @param fromIndex 起始位置，从后往前计数
    • @return 位置
       */
       public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int fromIndex) {
       return lastIndexOf(str, searchStr, fromIndex, true);
       }
     
    /**
     
  
    • 指定范围内查找字符串，忽略大小写
    • @param str 字符串
    • @param searchStr 需要查找位置的字符串
    • @return 位置
       /
       public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr) {
       return lastIndexOfIgnoreCase(str, searchStr, str.length());
       }
       /      *
    • 编码字符串，编码为UTF-8
    • @param str 字符串
    • @return 编码后的字节码
       /
       public static byte[] utf8Bytes(CharSequence str) {
       return bytes(str, CharsetUtil.CHARSET_UTF_8);
       }
       /      *
    • 判断是否为数字
       */
       private static Pattern numericPattern = Pattern.compile("1+$");
     
    public static final String UNDERLINE = “_”;
     
 

}
 

 

 
 
  1. 0-9\- ↩︎
     
 


                

                
                
        

        

    

  


    

      

        

            

              
                
                  UPC.血糖
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Java——字符串操作工具类

				
			

			

				

					m0_58596092的博客
				

				

					10-21
					
					940
					
				

			

		

		

			
				
Java-字符串操作工具类：
1.创建StringUtils类，用正则表达式表示数字；
2.判断字符串是否为数字，返回布尔值；
3.判断字符串是否为数字，返回布尔值；
4.获取字符串中的数字；
5.去除字符串开头的指定字符，返回去除后的字符串；
6.Map字符串转换为Map；
7.字符串类的列表转为以逗号分隔的String；
8.list中包含list转字符串；


			
		

	



                

              
                



	

		

			

				
					
Java的replaceAll（）方法

				
			

			

				

					carter_yu的博客
				

				

					06-26
					
					4137
					
				

			

		

		

			
				
replaceAll( )方法实际是采用正则表达式的规则去匹配的。在regex中”\\”表示一个”\”，在java中一个”\”也要用”\\”表示。这样，前一个”\\”代表regex中的”\”，后一个”\\”代表java中的”\”，所以字符串转义一次，正则转义一次，那么一个斜扛要写4个。1、Java的字符串反斜杠(‘\’)转换为(‘/’)string = string.replaceAll("\\\\

			
		

	



                


  
              

                


	

		

			

				
					
Java字符批量替换工具类--Java自学网

				
			

			

				

					
				

				

					01-26
					
					530
					
				

			

		

		

			
				
package com.util;
/**
 * 字符批量替换，相对于java中的replaceAll，效率要高。
 * @author Administrator
 *
 */
public class ReplaceAll {
   /**http://www.javalearns.com/
    * 字符替换函数
    * @param String,String,St

			
		

	





	

		

			

				
					
Java字符串处理工具类

					
最新发布

				
			

			

				

					爪哇菌的博客
				

				

					08-15
					
					1041
					
				

			

		

		

			
				
字符串是在程序开发中最常见的，经过多年不断积累，相关的工具类已经非常庞大，为了方便大家了解，这里根据个人开发经验，进行整理和归类，提供方便、简化的字符串处理方法，以支持大家在应用程序中更轻松地处理字符串。当然，日常开发中一般不会自己去编写工具类，更多是使用已经比较成熟的第三方库中提供的工具类，例如org.apache.commons.lang.StringUtils。

			
		

	



		

			
		



	

		

			

				
					
IDEA各种报错锦集

				
			

			

				

					newchitu的博客
				

				

					02-27
					
					6322
					
				

			

		

		

			
				
目录

1. 编译项目报找不到符号错误

2.Unable to locate Spring NamespaceHandler for XML schema namespace……

1. 编译项目报找不到符号错误

多模块项目相互依赖时，修改其中一个模块，引用该模块的项目编译报错，解决方式如下：

删除本地仓库修改model的文件夹，重新编译并install修改的model，然后再重新再需要引用...

			
		

	





	

		

			

				
					
Java实现循环双链表

				
			

			

				

					weixin_46944732的博客
				

				

					03-08
					
					659
					
				

			

		

		

			
				
使用Java语言实现了一个双链表，可进行数据元素的增、删、查。

代码实现如下：


import org.jetbrains.annotations.NotNull;

import java.util.Iterator;

public class DoubleLink<T> implements Iterable<T> {

    //创建一个双链表类型的结点匿名内部类
    private class Node {
        //数据域，存放T类型的数据
     

			
		

	





	

		

			

				
					
Map集合JAVA

				
			

			

				

					岁月求索
				

				

					01-26
					
					229
					
				

			

		

		

			
				

package com.xy.day15.Map;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.text.html.HTMLDocument;
import java.sql.SQLOutput;
import java.util...

			
		

	





	

		

			

				
					
java字符串基本处理工具类

				
			

			

				

					01-07
				

			

		

		

			
				
java字符串处理的util工具类，也可以同时添加一些其他字符处理的方法，对于项目中特殊字符处理，完成项目中基本的字串符处理。

			
		

	





	

		

			

				
					
java字符串中${}或者{}等的占位符替换工具类

				
			

			

				

					08-26
				

			

		

		

			
				
Java字符串中${}或者{}等占位符替换工具类  Java字符串中${}或者{}等占位符替换工具类是一个功能强大且实用的工具类，它可以将Java字符串中的占位符依次替换为指定的值。该工具类的主要功能是实现占位符的替换，即将...

			
		

	





	

		

			

				
					
Java中字符串生成图片工具类

				
			

			

				

					10-31
				

			

		

		

			
				
Java中字符串生成图片工具类 将字符串转换为BufferedImage对象 将字符串转换为BufferedImage对象字段--自动换行

			
		

	





	

		

			

				
					
Java常用字符串工具类 字符串智能截取（3）

				
			

			

				

					08-30
				

			

		

		

			
				
Java字符串工具类之字符串智能截取  本文主要介绍了Java常用字符串工具类中的字符串智能截取，提供了四种常用的方法来截取字符串，这些方法可以实现正向和反向截取字符串。下面是对该工具类的详细说明：  1. ...

			
		

	





	

		

			

				
					
报错 java: 程序包org.apache.ibatis.annotations不存在

					
热门推荐

				
			

			

				

					qq_1732628250的博客
				

				

					09-07
					
					1万+
					
				

			

		

		

			
				
java:org.apache.ibatis.annotations不存在

			
		

	





	

		

			

				
					
IDEA--如何解决Java:程序包xxxx不存在

				
			

			

				

					m0_60349254的博客
				

				

					06-18
					
					5155
					
				

			

		

		

			
				
有时候我们在导入程序之后，系统会给出错误提示：Java:程序包xxxx不存在，现在我这里有一招，就是使用IDEA自动导入Java程序包，这也是IDEA的一大优点。当出现如题所示的错误时候，不用着急，这是因为配置Java的程序包这块出现了错误，同时可能你还没有设置让IDEA自动加载Jar包，才会报出这种错误的。解决方式如下：
File—>Setting—>Build,Execution,Deployment—>Maven—>Importing
然后如下图配置：
如上图配置好之后，点击apply，然后点击OK，

			
		

	





	

		

			

				
					
Java语言——实现单向链表

				
			

			

				

					weixin_46944732的博客
				

				

					03-07
					
					570
					
				

			

		

		

			
				
单向链表的实现


import org.jetbrains.annotations.NotNull;

import java.util.Iterator;

public class SinglyList<T> implements Iterable<T> {
    //记录头结点
    private Node head;
    //记录链表长度
    private int L;

    //创建一个结点类的匿名内部类
    private class Node.

			
		

	





	

		

			

				
					
机器学习 第一章 Python复习（4）模块、包

				
			

			

				

					huxiaotong_exp的专栏
				

				

					09-12
					
					717
					
				

			

		

		

			
				
1.模块

参考文档 
一个模块就是一个文件 
引用方式1：会将functions.py从上至下执行一次，只会讲functions导入到local()

import functions
functions.函数名（）

引用方式2,会将xxx导入到local()

from functions import xxxx,xxxx

引用方式3,会将functions下所有变量导入到local()
...

			
		

	





	

		

			

				
					
【idea插件开发入门及常见问题】

				
			

			

				

					futuredistant的博客
				

				

					06-26
					
					2919
					
				

			

		

		

			
				
idea插件开发，入门级1.idea，File->右键->new->project

2.选择IDE plugin

其中jdk版本需要11及以上，低版本不支持，这里选择的是jdk17,为了兼容gradle版本。
3.创建完项目后，开始踩坑。
第一个坑：无法创建Java Class
如图：

解决办法：
先点击，file-project Structure

然后，按照箭头顺序点击

第二个坑：
运行时，下载不下来gradle包
解决办法：去官网上手动下载对应版本，然后复制到对应的.gradle文件夹中
第

			
		

	





	

		

			

				
					
Java 注解一

				
			

			

				

					奶糖小松鼠
				

				

					10-11
					
					8517
					
				

			

		

		

			
				
使用 JetBrains 注解库注释你的代码依赖
annotations-java8.jar 
这个包在任何一个 JetBrains IDE 的安装目录里面都有，在 kotlin-runtime.jar 里面也有，在 maven 仓库也有。 
为什么需要它
首先我们知道 Kotlin 解决了一个万年大问题—— null 。 几乎每个代码量超过两千的项目，先做出原型后，前两次运行或单元测试，都死在 N

			
		

	





	

		

			

				
					
IDEA 函数下边出现红色的波浪线，提示报错

				
			

			

				

					咸鱼梦想
				

				

					11-08
					
					931
					
				

			

		

		

			
				
这些注解有助于提前发现潜在的null引用问题，提高代码的可靠性和质量。注解来告诉IDEA忽略这些警告，但要谨慎使用它，确保你的代码不会引入潜在的null引用错误。注解表明，根据这个方法的合同，不管输入参数是什么，该方法都应该返回一个新的非null对象。这些提示是来自IntelliJ IDEA的推断注解，用于静态代码分析和帮助检测潜在的问题。：如果您是方法的调用者，确保您的代码中不会传递null值给这些方法或参数。表示在调用这些方法或使用这些参数时，不应为null。参数时，不会传递null值。

			
		

	





	

		

			

				
					
String的equals()方法源码解析

				
			

			

				

					qq_37014317的博客
				

				

					02-11
					
					1857
					
				

			

		

		

			
				
java源码对equals()注释

java.lang.String @Contract(value = "null -> false", pure = true) 
public boolean equals(@Nullable Object anObject)
将此字符串与指定对象进行比较。 当且仅当参数不为null并且是一个String对象，表示与此对象相同的字符序列时，结果为true 。

覆写：
equals类Object
参数：
anObject –比较此String的对象
返回值：
.

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值