!78 同步dev分支 Merge pull request !78 from 疯狂的狮子Li/dev

疯狂的狮子Li

2021-08-18 0375fd319c9f3b08d255c814cb0f8521d8ec641b

 ruoyi-common/src/main/java/com/ruoyi/common/utils/StringUtils.java

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

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Validator;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.core.util.StrUtil;

import java.util.*;

/**
 * å­—符串工具类
 *
 * @author ruoyi
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {

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

   /**
    * èŽ·å–参数不为空值
    *
    * @param str defaultValue è¦åˆ¤æ–­çš„value
    * @return value è¿”回值
    */
   public static String blankToDefault(String str, String defaultValue) {
      return StrUtil.blankToDefault(str, defaultValue);
   }

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

   /**
    * * åˆ¤æ–­ä¸€ä¸ª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 ArrayUtil.isEmpty(objects);
   }

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

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦ä¸ºç©º
    *
    * @param object è¦åˆ¤æ–­çš„对象数组
    *                * @return true：为空 false：非空
    */
   public static boolean isEmpty(Object object) {
      return ObjectUtil.isEmpty(object);
   }

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

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

   /**
    * * åˆ¤æ–­ä¸€ä¸ª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 StrUtil.isEmpty(str);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå­—符串是否为非空串
    *
    * @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 ObjectUtil.isNull(object);
   }

   /**
    * * åˆ¤æ–­ä¸€ä¸ªå¯¹è±¡æ˜¯å¦éžç©º
    *
    * @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 ArrayUtil.isArray(object);
   }

   /**
    * åŽ»ç©ºæ ¼
    */
   public static String trim(String str) {
      return StrUtil.trim(str);
   }

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

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

   /**
    * æ ¼å¼åŒ–文本, {} è¡¨ç¤ºå ä½ç¬¦<br>
    * æ­¤æ–¹æ³•åªæ˜¯ç®€å•å°†å ä½ç¬¦ {} æŒ‰ç…§é¡ºåºæ›¿æ¢ä¸ºå‚æ•°<br>
    * å¦‚果想输出 {} ä½¿ç”¨ \\转义 { å³å¯ï¼Œå¦‚果想输出 {} ä¹‹å‰çš„ \ ä½¿ç”¨åŒè½¬ä¹‰ç¬¦ \\\\ å³å¯<br>
    * ä¾‹ï¼š<br>
    * é€šå¸¸ä½¿ç”¨ï¼šformat("this is {} for {}", "a", "b") -> this is a for b<br>
    * è½¬ä¹‰{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
    * è½¬ä¹‰\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
    *
    * @param template æ–‡æœ¬æ¨¡æ¿ï¼Œè¢«æ›¿æ¢çš„部分用 {} è¡¨ç¤º
    * @param params   å‚数值
    * @return æ ¼å¼åŒ–后的文本
    */
   public static String format(String template, Object... params) {
      return StrUtil.format(template, params);
   }

   /**
    * æ˜¯å¦ä¸ºhttp(s)://开头
    *
    * @param link é“¾æŽ¥
    * @return ç»“æžœ
    */
   public static boolean ishttp(String link) {
      return Validator.isUrl(link);
   }

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

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

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

      return list;
   }

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

   /**
    * é©¼å³°è½¬ä¸‹åˆ’线命名
    */
   public static String toUnderScoreCase(String str) {
      return StrUtil.toUnderlineCase(str);
   }

   /**
    * æ˜¯å¦åŒ…含字符串
    *
    * @param str  éªŒè¯å­—符串
    * @param strs å­—符串组
    * @return åŒ…含返回true
    */
   public static boolean inStringIgnoreCase(String str, String... strs) {
      return StrUtil.equalsAnyIgnoreCase(str, strs);
   }

   /**
    * å°†ä¸‹åˆ’线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 ä¾‹å¦‚：HELLO_WORLD->HelloWorld
    *
    * @param name è½¬æ¢å‰çš„下划线大写方式命名的字符串
    * @return è½¬æ¢åŽçš„驼峰式命名的字符串
    */
   public static String convertToCamelCase(String name) {
      return StrUtil.upperFirst(StrUtil.toCamelCase(name));
   }

   /**
    * é©¼å³°å¼å‘½åæ³• ä¾‹å¦‚：user_name->userName
    */
   public static String toCamelCase(String s) {
      return StrUtil.toCamelCase(s);
   }

   /**
    * æŸ¥æ‰¾æŒ‡å®šå­—符串是否匹配指定字符串列表中的任意一个字符串
    *
    * @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) {
      return ReUtil.isMatch(pattern, url);
   }

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