1

13693261870

2024-11-13 2f55cebbad3dea187a5f91d16ec80a9677dab699

 src/main/java/com/yssh/utils/StringUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,521 @@
package com.yssh.utils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.util.AntPathMatcher;

public class StringUtils extends org.apache.commons.lang3.StringUtils {
   /** ç©ºå­—符串 */
   private static final String NULLSTR = "";

   /** ä¸‹åˆ’线 */
   private static final char SEPARATOR = '_';

   /**
    * èŽ·å–参数不为空值
    *
    * @param value
    *            defaultValue è¦åˆ¤æ–­çš„value
    * @return value è¿”回值
    */
   public static <T> T nvl(T value, T defaultValue) {
      return value != null ? value : defaultValue;
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªCollection是否为空， åŒ…含List，Set，Queue
    *
    * @param coll
    *            è¦åˆ¤æ–­çš„Collection
    * @return true：为空 false：非空
    */
   public static boolean isEmpty(Collection<?> coll) {
      return isNull(coll) || coll.isEmpty();
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªCollection是否非空，包含List，Set，Queue
    *
    * @param coll
    *            è¦åˆ¤æ–­çš„Collection
    * @return true：非空 false：空
    */
   public static boolean isNotEmpty(Collection<?> coll) {
      return !isEmpty(coll);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ•°ç»„是否为空
    *
    * @param objects
    *            è¦åˆ¤æ–­çš„对象数组
    ** @return true：为空 false：非空
    */
   public static boolean isEmpty(Object[] objects) {
      return isNull(objects) || (objects.length == 0);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ•°ç»„是否非空
    *
    * @param objects
    *            è¦åˆ¤æ–­çš„对象数组
    * @return true：非空 false：空
    */
   public static boolean isNotEmpty(Object[] objects) {
      return !isEmpty(objects);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªMap是否为空
    *
    * @param map
    *            è¦åˆ¤æ–­çš„Map
    * @return true：为空 false：非空
    */
   public static boolean isEmpty(Map<?, ?> map) {
      return isNull(map) || map.isEmpty();
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªMap是否为空
    *
    * @param map
    *            è¦åˆ¤æ–­çš„Map
    * @return true：非空 false：空
    */
   public static boolean isNotEmpty(Map<?, ?> map) {
      return !isEmpty(map);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå­—符串是否为空串
    *
    * @param str
    *            String
    * @return true：为空 false：非空
    */
   public static boolean isEmpty(String str) {
      return isNull(str) || NULLSTR.equals(str.trim());
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå­—符串是否为非空串
    *
    * @param str
    *            String
    * @return true：非空串 false：空串
    */
   public static boolean isNotEmpty(String str) {
      return !isEmpty(str);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦ä¸ºç©º
    *
    * @param object
    *            Object
    * @return true：为空 false：非空
    */
   public static boolean isNull(Object object) {
      return object == null;
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦éžç©º
    *
    * @param object
    *            Object
    * @return true：非空 false：空
    */
   public static boolean isNotNull(Object object) {
      return !isNull(object);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦æ˜¯æ•°ç»„类型（Java基本型别的数组）
    *
    * @param object
    *            å¯¹è±¡
    * @return true：是数组 false：不是数组
    */
   public static boolean isArray(Object object) {
      return isNotNull(object) && object.getClass().isArray();
   }

   /**
    * åŽ»ç©ºæ ¼
    */
   public static String trim(String str) {
      return (str == null ? "" : str.trim());
   }

   /**
    * æˆªå–字符串
    *
    * @param str
    *            å­—符串
    * @param start
    *            å¼€å§‹
    * @return ç»“æžœ
    */
   public static String substring(final String str, int start) {
      if (str == null) {
         return NULLSTR;
      }

      if (start < 0) {
         start = str.length() + start;
      }

      if (start < 0) {
         start = 0;
      }
      if (start > str.length()) {
         return NULLSTR;
      }

      return str.substring(start);
   }

   /**
    * æˆªå–字符串
    *
    * @param str
    *            å­—符串
    * @param start
    *            å¼€å§‹
    * @param end
    *            ç»“束
    * @return ç»“æžœ
    */
   public static String substring(final String str, int start, int end) {
      if (str == null) {
         return NULLSTR;
      }

      if (end < 0) {
         end = str.length() + end;
      }
      if (start < 0) {
         start = str.length() + start;
      }

      if (end > str.length()) {
         end = str.length();
      }

      if (start > end) {
         return NULLSTR;
      }

      if (start < 0) {
         start = 0;
      }
      if (end < 0) {
         end = 0;
      }

      return str.substring(start, end);
   }

   /**
    * å­—符串转set
    *
    * @param str
    *            å­—符串
    * @param sep
    *            åˆ†éš”符
    * @return set集合
    */
   public static final Set<String> str2Set(String str, String sep) {
      return new HashSet<String>(str2List(str, sep, true, false));
   }

   /**
    * å­—符串转list
    *
    * @param str
    *            å­—符串
    * @param sep
    *            åˆ†éš”符
    * @param filterBlank
    *            è¿‡æ»¤çº¯ç©ºç™½
    * @param trim
    *            åŽ»æŽ‰é¦–尾空白
    * @return list集合
    */
   public static final List<String> str2List(String str, String sep,
         boolean filterBlank, boolean trim) {
      List<String> list = new ArrayList<String>();
      if (StringUtils.isEmpty(str)) {
         return list;
      }

      // è¿‡æ»¤ç©ºç™½å­—符串
      if (filterBlank && StringUtils.isBlank(str)) {
         return list;
      }
      String[] split = str.split(sep);
      for (String string : split) {
         if (filterBlank && StringUtils.isBlank(string)) {
            continue;
         }
         if (trim) {
            string = string.trim();
         }
         list.add(string);
      }

      return list;
   }

   /**
    * åˆ¤æ–­ç»™å®šçš„set列表中是否包含数组array åˆ¤æ–­ç»™å®šçš„数组array中是否包含给定的元素value
    *
    * @param ç»™å®šçš„集合
    * @param array
    *            ç»™å®šçš„数组
    * @return boolean ç»“æžœ
    */
   public static boolean containsAny(Collection<String> collection,
         String... array) {
      if (isEmpty(collection) || isEmpty(array)) {
         return false;
      } else {
         for (String str : array) {
            if (collection.contains(str)) {
               return true;
            }
         }
         return false;
      }
   }

   /**
    * æŸ¥æ‰¾æŒ‡å®šå­—符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
    *
    * @param cs
    *            æŒ‡å®šå­—符串
    * @param searchCharSequences
    *            éœ€è¦æ£€æŸ¥çš„字符串数组
    * @return æ˜¯å¦åŒ…含任意一个字符串
    */
   public static boolean containsAnyIgnoreCase(CharSequence cs,
         CharSequence... searchCharSequences) {
      if (isEmpty(cs) || isEmpty(searchCharSequences)) {
         return false;
      }
      for (CharSequence testStr : searchCharSequences) {
         if (containsIgnoreCase(cs, testStr)) {
            return true;
         }
      }
      return false;
   }

   /**
    * é©¼å³°è½¬ä¸‹åˆ’线命名
    */
   public static String toUnderScoreCase(String str) {
      if (str == null) {
         return null;
      }
      StringBuilder sb = new StringBuilder();
      // å‰ç½®å­—符是否大写
      boolean preCharIsUpperCase = true;
      // å½“前字符是否大写
      boolean curreCharIsUpperCase = true;
      // ä¸‹ä¸€å­—符是否大写
      boolean nexteCharIsUpperCase = true;
      for (int i = 0; i < str.length(); i++) {
         char c = str.charAt(i);
         if (i > 0) {
            preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
         } else {
            preCharIsUpperCase = false;
         }

         curreCharIsUpperCase = Character.isUpperCase(c);

         if (i < (str.length() - 1)) {
            nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
         }

         if (preCharIsUpperCase && curreCharIsUpperCase
               && !nexteCharIsUpperCase) {
            sb.append(SEPARATOR);
         } else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {
            sb.append(SEPARATOR);
         }
         sb.append(Character.toLowerCase(c));
      }

      return sb.toString();
   }

   /**
    * æ˜¯å¦åŒ…含字符串
    *
    * @param str
    *            éªŒè¯å­—符串
    * @param strs
    *            å­—符串组
    * @return åŒ…含返回true
    */
   public static boolean inStringIgnoreCase(String str, String... strs) {
      if (str != null && strs != null) {
         for (String s : strs) {
            if (str.equalsIgnoreCase(trim(s))) {
               return true;
            }
         }
      }
      return false;
   }

   /**
    * å°†ä¸‹åˆ’线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
    * ä¾‹å¦‚：HELLO_WORLD->HelloWorld
    *
    * @param name
    *            è½¬æ¢å‰çš„下划线大写方式命名的字符串
    * @return è½¬æ¢åŽçš„驼峰式命名的字符串
    */
   public static String convertToCamelCase(String name) {
      StringBuilder result = new StringBuilder();
      // å¿«é€Ÿæ£€æŸ¥
      if (name == null || name.isEmpty()) {
         // æ²¡å¿…要转换
         return "";
      } else if (!name.contains("_")) {
         // ä¸å«ä¸‹åˆ’线，仅将首字母大写
         return name.substring(0, 1).toUpperCase() + name.substring(1);
      }
      // ç”¨ä¸‹åˆ’线将原始字符串分割
      String[] camels = name.split("_");
      for (String camel : camels) {
         // è·³è¿‡åŽŸå§‹å­—符串中开头、结尾的下换线或双重下划线
         if (camel.isEmpty()) {
            continue;
         }
         // é¦–字母大写
         result.append(camel.substring(0, 1).toUpperCase());
         result.append(camel.substring(1).toLowerCase());
      }
      return result.toString();
   }

   /**
    * é©¼å³°å¼å‘½åæ³• ä¾‹å¦‚：user_name->userName
    */
   public static String toCamelCase(String s) {
      if (s == null) {
         return null;
      }
      s = s.toLowerCase();
      StringBuilder sb = new StringBuilder(s.length());
      boolean upperCase = false;
      for (int i = 0; i < s.length(); i++) {
         char c = s.charAt(i);

         if (c == SEPARATOR) {
            upperCase = true;
         } else if (upperCase) {
            sb.append(Character.toUpperCase(c));
            upperCase = false;
         } else {
            sb.append(c);
         }
      }
      return sb.toString();
   }

   /**
    * æŸ¥æ‰¾æŒ‡å®šå­—符串是否匹配指定字符串列表中的任意一个字符串
    *
    * @param str
    *            æŒ‡å®šå­—符串
    * @param strs
    *            éœ€è¦æ£€æŸ¥çš„字符串数组
    * @return æ˜¯å¦åŒ¹é…
    */
   public static boolean matches(String str, List<String> strs) {
      if (isEmpty(str) || isEmpty(strs)) {
         return false;
      }
      for (String pattern : strs) {
         if (isMatch(pattern, str)) {
            return true;
         }
      }
      return false;
   }

   /**
    * åˆ¤æ–­url是否与规则配置: ? è¡¨ç¤ºå•ä¸ªå­—符; * è¡¨ç¤ºä¸€å±‚路径内的任意字符串，不可跨层级; ** è¡¨ç¤ºä»»æ„å±‚路径;
    *
    * @param pattern
    *            åŒ¹é…è§„则
    * @param url
    *            éœ€è¦åŒ¹é…çš„url
    * @return
    */
   public static boolean isMatch(String pattern, String url) {
      AntPathMatcher matcher = new AntPathMatcher();
      return matcher.match(pattern, url);
   }

   @SuppressWarnings("unchecked")
   public static <T> T cast(Object obj) {
      return (T) obj;
   }

   /**
    * æ•°å­—左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 æœ€åŽsize个字符。
    *
    * @param num
    *            æ•°å­—对象
    * @param size
    *            å­—符串指定长度
    * @return è¿”回数字的字符串格式，该字符串为指定长度。
    */
   public static final String padl(final Number num, final int size) {
      return padl(num.toString(), size, '0');
   }

   /**
    * å­—符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
    *
    * @param s
    *            åŽŸå§‹å­—符串
    * @param size
    *            å­—符串指定长度
    * @param c
    *            ç”¨äºŽè¡¥é½çš„字符
    * @return è¿”回指定长度的字符串，由原字符串左补齐或截取得到。
    */
   public static final String padl(final String s, final int size, final char c) {
      final StringBuilder sb = new StringBuilder(size);
      if (s != null) {
         final int len = s.length();
         if (s.length() <= size) {
            for (int i = size - len; i > 0; i--) {
               sb.append(c);
            }
            sb.append(s);
         } else {
            return s.substring(len - size, len);
         }
      } else {
         for (int i = size; i > 0; i--) {
            sb.append(c);
         }
      }
      return sb.toString();
   }
}