java字符串处理工具类

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 = {“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “0”,
      “!”, “@”, “#”, “$”, “%”, “︿”, “&”, “*”, “(”, “)”, “a”, “b”,
      “c”, “d”, “e”, “f”, “g”, “h”, “i”, “j”, “k”, “l”, “m”, “n”,
      “o”, “p”, “q”, “r”, “s”, “t”, “u”, “v”, “w”, “x”, “y”, “z”,
      “A”, “B”, “C”, “D”, “E”, “F”, “G”, “H”, “I”, “J”, “K”, “L”,
      “M”, “N”, “O”, “P”, “Q”, “R”, “S”, “T”, “U”, “V”, “W”, “X”,
      “Y”, “Z”, “-”, “_”, “=”, “+”, “\”, “|”, “【”, “】”, “;”, “:”,
      “’”, “”", “,”, “〈”, “。”, “〉”, “/”, “?”};
      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\- ↩︎

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值