perf: RegexTools 的缓存改用 guava cache

字符串无法代表一个正则表达式，还需考虑正则表达式的 flag(s)，所以当使用多个正则表达式时，更推荐使用 `Pattern[]`。

src/main/java/xyz/zhouxy/plusone/commons/util/RegexTools.java

@@ -17,26 +17,40 @@
 package xyz.zhouxy.plusone.commons.util;
 
 import java.util.Arrays;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
 /**
- * 封装一些常用的正则操作，并可以缓存 {@link Pattern} 实例以复用（最多缓存大概 256 个）。
+ * 封装一些常用的正则操作，并可以缓存 {@link Pattern} 实例以复用。
  *
  * @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
- *
  */
 public final class RegexTools {
 
-    private static final int DEFAULT_CACHE_INITIAL_CAPACITY = 64;
     private static final int MAX_CACHE_SIZE = 256;
-    private static final Map<String, Pattern> PATTERN_CACHE
-            = new ConcurrentHashMap<>(DEFAULT_CACHE_INITIAL_CAPACITY);
+    private static final int DEFAULT_FLAG = 0;
+    private static final LoadingCache<RegexAndFlags, Pattern> PATTERN_CACHE = CacheBuilder
+            .newBuilder()
+            .maximumSize(MAX_CACHE_SIZE)
+            .build(new CacheLoader<RegexAndFlags, Pattern>() {
+                @SuppressWarnings("null")
+                public Pattern load(@Nonnull RegexAndFlags regexAndFlags) {
+                    return regexAndFlags.compilePattern();
+                }
+            });
+
+    // ================================
+    // #region - getPattern
+    // ================================
 
     /**
      * 获取 {@link Pattern} 实例。
@@ -46,8 +60,20 @@ public final class RegexTools {
      * @return {@link Pattern} 实例
      */
     public static Pattern getPattern(final String pattern, final boolean cachePattern) {
+        return getPattern(pattern, DEFAULT_FLAG, cachePattern);
+    }
+
+    /**
+     * 获取 {@link Pattern} 实例。
+     *
+     * @param pattern      正则表达式
+     * @param flags        正则表达式匹配标识
+     * @param cachePattern 是否缓存 {@link Pattern} 实例
+     * @return {@link Pattern} 实例
+     */
+    public static Pattern getPattern(final String pattern, final int flags, final boolean cachePattern) {
         AssertTools.checkNotNull(pattern);
-        return cachePattern ? cacheAndGetPatternInternal(pattern) : getPatternInternal(pattern);
+        return cachePattern ? cacheAndGetPatternInternal(pattern, flags) : getPatternInternal(pattern, flags);
     }
 
     /**
@@ -57,34 +83,29 @@ public final class RegexTools {
      * @return {@link Pattern} 实例
      */
     public static Pattern getPattern(final String pattern) {
+        return getPattern(pattern, DEFAULT_FLAG);
+    }
+
+    /**
+     * 获取 {@link Pattern} 实例，不缓存。
+     *
+     * @param pattern 正则表达式
+     * @param flags   正则表达式匹配标识
+     * @return {@link Pattern} 实例
+     */
+    @Nonnull
+    public static Pattern getPattern(final String pattern, final int flags) {
         AssertTools.checkNotNull(pattern);
-        return getPatternInternal(pattern);
+        return getPatternInternal(pattern, flags);
     }
 
-    /**
-     * 将各个正则表达式转为 {@link Pattern} 实例。
-     *
-     * @param patterns     正则表达式
-     * @param cachePattern 是否缓存 {@link Pattern} 实例
-     * @return {@link Pattern} 实例数组
-     */
-    public static Pattern[] getPatterns(final String[] patterns, final boolean cachePattern) {
-        AssertTools.checkArgument(ArrayTools.isAllElementsNotNull(patterns));
-        return cachePattern
-                ? cacheAndGetPatternsInternal(patterns)
-                : getPatternsInternal(patterns);
-    }
+    // ================================
+    // #endregion - getPattern
+    // ================================
 
-    /**
-     * 将各个正则表达式转为 {@link Pattern} 实例，不缓存。
-     *
-     * @param patterns 正则表达式
-     * @return {@link Pattern} 实例数组
-     */
-    public static Pattern[] getPatterns(final String[] patterns) {
-        AssertTools.checkArgument(ArrayTools.isAllElementsNotNull(patterns));
-        return getPatternsInternal(patterns);
-    }
+    // ================================
+    // #region - matches
+    // ================================
 
     /**
      * 判断 {@code input} 是否匹配 {@code pattern}。
@@ -132,11 +153,21 @@ public final class RegexTools {
      */
     public static boolean matches(@Nullable final CharSequence input, final String pattern,
             final boolean cachePattern) {
-        AssertTools.checkNotNull(pattern);
-        Pattern p = cachePattern
-                ? cacheAndGetPatternInternal(pattern)
-                : getPatternInternal(pattern);
-        return matchesInternal(input, p);
+        return matches(input, pattern, DEFAULT_FLAG, cachePattern);
+    }
+
+    /**
+     * 判断 {@code input} 是否匹配 {@code pattern}。
+     *
+     * @param input        输入
+     * @param pattern      正则表达式
+     * @param flags        正则表达式匹配标识
+     * @param cachePattern 是否缓存 {@link Pattern} 实例
+     * @return 判断结果
+     */
+    public static boolean matches(@Nullable final CharSequence input, final String pattern, final int flags,
+            final boolean cachePattern) {
+        return matchesInternal(input, getPattern(pattern, flags, cachePattern));
     }
 
     /**
@@ -147,69 +178,29 @@ public final class RegexTools {
      * @return 判断结果
      */
     public static boolean matches(@Nullable final CharSequence input, final String pattern) {
-        AssertTools.checkNotNull(pattern);
-        return matchesInternal(input, getPatternInternal(pattern));
+        return matches(input, pattern, DEFAULT_FLAG);
     }
 
     /**
-     * 判断 {@code input} 是否匹配 {@code patterns} 中的一个。
+     * 判断 {@code input} 是否匹配 {@code pattern}。不缓存 {@link Pattern} 实例。
      *
-     * @param input        输入
-     * @param patterns     正则表达式
-     * @param cachePattern 是否缓存 {@link Pattern} 实例
+     * @param input   输入
+     * @param pattern 正则表达式
+     * @param flags   正则表达式匹配标识
      * @return 判断结果
      */
-    public static boolean matchesOne(@Nullable final CharSequence input, final String[] patterns,
-            final boolean cachePattern) {
-        AssertTools.checkArgument(ArrayTools.isAllElementsNotNull(patterns));
-        final Pattern[] patternSet = cachePattern
-                ? cacheAndGetPatternsInternal(patterns)
-                : getPatternsInternal(patterns);
-        return matchesOneInternal(input, patternSet);
+    public static boolean matches(@Nullable final CharSequence input,
+            final String pattern, final int flags) {
+        return matchesInternal(input, getPattern(pattern, flags));
     }
 
-    /**
-     * 判断 {@code input} 是否匹配 {@code patterns} 中的一个。不缓存 {@link Pattern} 实例。
-     *
-     * @param input    输入
-     * @param patterns 正则表达式
-     * @return 判断结果
-     */
-    public static boolean matchesOne(@Nullable final CharSequence input, final String[] patterns) {
-        AssertTools.checkArgument(ArrayTools.isAllElementsNotNull(patterns));
-        final Pattern[] patternSet = getPatternsInternal(patterns);
-        return matchesOneInternal(input, patternSet);
-    }
+    // ================================
+    // #endregion - matches
+    // ================================
 
-    /**
-     * 判断 {@code input} 是否匹配全部正则。
-     *
-     * @param input        输入
-     * @param patterns     正则表达式
-     * @param cachePattern 是否缓存 {@link Pattern} 实例
-     * @return 判断结果
-     */
-    public static boolean matchesAll(@Nullable final CharSequence input, final String[] patterns,
-            final boolean cachePattern) {
-        AssertTools.checkArgument(ArrayTools.isAllElementsNotNull(patterns));
-        final Pattern[] patternSet = cachePattern
-                ? cacheAndGetPatternsInternal(patterns)
-                : getPatternsInternal(patterns);
-        return matchesAllInternal(input, patternSet);
-    }
-
-    /**
-     * 判断 {@code input} 是否匹配全部正则。不缓存 {@link Pattern} 实例。
-     *
-     * @param input    输入
-     * @param patterns 正则表达式
-     * @return 判断结果
-     */
-    public static boolean matchesAll(@Nullable final CharSequence input, final String[] patterns) {
-        AssertTools.checkArgument(ArrayTools.isAllElementsNotNull(patterns));
-        final Pattern[] patternSet = getPatternsInternal(patterns);
-        return matchesAllInternal(input, patternSet);
-    }
+    // ================================
+    // #region - getMatcher
+    // ================================
 
     /**
      * 生成 Matcher。
@@ -233,12 +224,21 @@ public final class RegexTools {
      * @return 结果
      */
     public static Matcher getMatcher(final CharSequence input, final String pattern, boolean cachePattern) {
-        AssertTools.checkNotNull(input);
-        AssertTools.checkNotNull(pattern);
-        final Pattern p = cachePattern
-                ? cacheAndGetPatternInternal(pattern)
-                : getPatternInternal(pattern);
-        return p.matcher(input);
+        return getMatcher(input, pattern, DEFAULT_FLAG, cachePattern);
+    }
+
+    /**
+     * 生成 Matcher。
+     *
+     * @param input        输入
+     * @param pattern      正则表达式
+     * @param flags        正则表达式匹配标识
+     * @param cachePattern 是否缓存 {@link Pattern} 实例
+     * @return 结果
+     */
+    public static Matcher getMatcher(final CharSequence input,
+            final String pattern, final int flags, boolean cachePattern) {
+        return getMatcher(input, getPattern(pattern, flags, cachePattern));
     }
 
     /**
@@ -249,70 +249,56 @@ public final class RegexTools {
      * @return 结果
      */
     public static Matcher getMatcher(final CharSequence input, final String pattern) {
-        AssertTools.checkNotNull(input);
-        AssertTools.checkNotNull(pattern);
-        return getPatternInternal(pattern).matcher(input);
+        return getMatcher(input, pattern, DEFAULT_FLAG);
     }
 
-    // ========== internal methods ==========
+    /**
+     * 生成 Matcher。不缓存 {@link Pattern} 实例。
+     *
+     * @param input   输入
+     * @param pattern 正则表达式
+     * @param flags   正则表达式匹配标识
+     * @return 结果
+     */
+    public static Matcher getMatcher(final CharSequence input, final String pattern, final int flags) {
+        AssertTools.checkNotNull(input);
+        AssertTools.checkNotNull(pattern);
+        return getPatternInternal(pattern, flags).matcher(input);
+    }
+
+    // ================================
+    // #endregion - getMatcher
+    // ================================
+
+    // ================================
+    // #region - internal methods
+    // ================================
 
     /**
      * 获取 {@link Pattern} 实例。
      *
      * @param pattern      正则表达式
+     * @param flags        正则表达式匹配标识
      * @return {@link Pattern} 实例
      */
     @Nonnull
-    private static Pattern cacheAndGetPatternInternal(final String pattern) {
-        if (PATTERN_CACHE.size() < MAX_CACHE_SIZE) {
-            return PATTERN_CACHE.computeIfAbsent(pattern, Pattern::compile);
-        }
-        Pattern result = PATTERN_CACHE.get(pattern);
-        if (result != null) {
-            return result;
-        }
-        return Pattern.compile(pattern);
+    private static Pattern cacheAndGetPatternInternal(final String pattern, final int flags) {
+        final RegexAndFlags regexAndFlags = new RegexAndFlags(pattern, flags);
+        return PATTERN_CACHE.getUnchecked(regexAndFlags);
     }
 
     /**
      * 获取 {@link Pattern} 实例，不缓存。
      *
      * @param pattern 正则表达式
+     * @param flags   正则表达式匹配标识
      * @return {@link Pattern} 实例
      */
     @Nonnull
-    private static Pattern getPatternInternal(final String pattern) {
-        Pattern result = PATTERN_CACHE.get(pattern);
-        if (result == null) {
-            result = Pattern.compile(pattern);
-        }
-        return result;
-    }
-
-    /**
-     * 将各个正则表达式转为 {@link Pattern} 实例。
-     *
-     * @param patterns 正则表达式
-     * @return {@link Pattern} 实例数组
-     */
-    @Nonnull
-    private static Pattern[] cacheAndGetPatternsInternal(final String[] patterns) {
-        return Arrays.stream(patterns)
-                .map(RegexTools::cacheAndGetPatternInternal)
-                .toArray(Pattern[]::new);
-    }
-
-    /**
-     * 将各个正则表达式转为 {@link Pattern} 实例。
-     *
-     * @param patterns 正则表达式
-     * @return {@link Pattern} 实例数组
-     */
-    @Nonnull
-    private static Pattern[] getPatternsInternal(final String[] patterns) {
-        return Arrays.stream(patterns)
-                .map(RegexTools::getPatternInternal)
-                .toArray(Pattern[]::new);
+    private static Pattern getPatternInternal(final String pattern, final int flags) {
+        final RegexAndFlags regexAndFlags = new RegexAndFlags(pattern, flags);
+        return Optional.ofNullable(PATTERN_CACHE.getIfPresent(regexAndFlags))
+                .orElseGet(regexAndFlags::compilePattern);
     }
 
     /**
@@ -352,8 +338,49 @@ public final class RegexTools {
                         .allMatch(pattern -> pattern.matcher(input).matches());
     }
 
+    // ================================
+    // #endregion - internal methods
+    // ================================
+
     private RegexTools() {
         // 不允许实例化
         throw new IllegalStateException("Utility class");
     }
+
+    // ================================
+    // #region - RegexAndFlags
+    // ================================
+
+    private static final class RegexAndFlags {
+        private final String regex;
+        private final int flags;
+
+        private RegexAndFlags(String regex, int flags) {
+            this.regex = regex;
+            this.flags = flags;
+        }
+
+        private final Pattern compilePattern() {
+            return Pattern.compile(regex, flags);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(regex, flags);
+        }
+
+        @Override
+        public boolean equals(@Nullable Object obj) {
+            if (this == obj)
+                return true;
+            if (!(obj instanceof RegexAndFlags))
+                return false;
+            RegexAndFlags other = (RegexAndFlags) obj;
+            return Objects.equals(regex, other.regex) && flags == other.flags;
+        }
+    }
+
+    // ================================
+    // #endregion - RegexAndFlags
+    // ================================
 }

src/test/java/xyz/zhouxy/plusone/commons/util/RegexToolsTests.java

@@ -33,19 +33,42 @@ public
 class RegexToolsTests {
 
     @Test
-    void getPattern_CachePatternTrue_ReturnsCachedPattern() {
+    void getPattern_SameRegexAndFlag_CachePatternIsTrue_ReturnsCachedPattern() {
         String pattern = "abc";
         Pattern cachedPattern = RegexTools.getPattern(pattern, true);
-        Pattern patternFromCache = RegexTools.getPattern(pattern, true);
+        Pattern patternFromCache = RegexTools.getPattern(pattern);
         assertSame(cachedPattern, patternFromCache, "Pattern should be cached");
+
+        Pattern cachedPatternWithFlag = RegexTools.getPattern(pattern, Pattern.CASE_INSENSITIVE, true);
+        Pattern patternFromCacheWithFlag = RegexTools.getPattern(pattern, Pattern.CASE_INSENSITIVE);
+        assertSame(cachedPatternWithFlag, patternFromCacheWithFlag, "Pattern should be cached");
     }
 
     @Test
-    void getPattern_CachePatternFalse_ReturnsNewPattern() {
-        String pattern = "getPattern_CachePatternFalse_ReturnsNewPattern";
+    void getPattern_SameRegexAndFlag_CachePatternFalse_ReturnsNewPattern() {
+        String pattern = "getPattern_SameRegexAndFlag_CachePatternFalse_ReturnsNewPattern";
         Pattern pattern1 = RegexTools.getPattern(pattern, false);
         Pattern pattern2 = RegexTools.getPattern(pattern, false);
+        Pattern pattern3 = RegexTools.getPattern(pattern);
         assertNotSame(pattern1, pattern2, "Pattern should not be cached");
+        assertNotSame(pattern1, pattern3, "Pattern should not be cached");
+        assertNotSame(pattern2, pattern3, "Pattern should not be cached");
+
+        Pattern pattern1WithFlag = RegexTools.getPattern(pattern, Pattern.CASE_INSENSITIVE, false);
+        Pattern pattern2WithFlag = RegexTools.getPattern(pattern, Pattern.CASE_INSENSITIVE, false);
+        Pattern pattern3WithFlag = RegexTools.getPattern(pattern, Pattern.CASE_INSENSITIVE);
+        assertNotSame(pattern1WithFlag, pattern2WithFlag, "Pattern should not be cached");
+        assertNotSame(pattern1WithFlag, pattern3WithFlag, "Pattern should not be cached");
+        assertNotSame(pattern2WithFlag, pattern3WithFlag, "Pattern should not be cached");
+    }
+
+    @Test
+    void getPattern_SameRegexAndDifferentFlag_ReturnsNewPattern() {
+        String pattern = "getPattern_SameRegexAndDifferentFlag_CachePatternFalse_ReturnsNewPattern";
+
+        Pattern pattern1WithFlag = RegexTools.getPattern(pattern, Pattern.CASE_INSENSITIVE, true);
+        Pattern pattern2WithFlag = RegexTools.getPattern(pattern, 0, true);
+        assertNotSame(pattern1WithFlag, pattern2WithFlag, "Patterns should not be the same");
     }
 
     @Test
@@ -53,52 +76,38 @@ class RegexToolsTests {
         assertThrows(NullPointerException.class, () -> {
             RegexTools.getPattern(null, true);
         });
-    }
-
-    @Test
-    void getPatterns_CachePatternTrue_ReturnsCachedPatterns() {
-        String[] patterns = {"abc", "def"};
-        Pattern[] cachedPatterns = RegexTools.getPatterns(patterns, true);
-        Pattern[] patternsFromCache = RegexTools.getPatterns(patterns, true);
-        assertSame(cachedPatterns[0], patternsFromCache[0]);
-        assertSame(cachedPatterns[1], patternsFromCache[1]);
-    }
-
-    @Test
-    void getPatterns_CachePatternFalse_ReturnsNewPatterns() {
-        String[] patterns = {"getPatterns_CachePatternFalse_ReturnsNewPatterns1", "getPatterns_CachePatternFalse_ReturnsNewPatterns2"};
-        Pattern[] patterns1 = RegexTools.getPatterns(patterns, false);
-        Pattern[] patterns2 = RegexTools.getPatterns(patterns, false);
-        assertNotSame(patterns1[0], patterns2[0]);
-        assertNotSame(patterns1[1], patterns2[1]);
-    }
-
-    @Test
-    void getPatterns_NullPatterns_ThrowsException() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            RegexTools.getPatterns(null, true);
+        assertThrows(NullPointerException.class, () -> {
+            RegexTools.getPattern(null, Pattern.CASE_INSENSITIVE, true);
         });
     }
 
     @Test
     void matches_InputMatchesPattern_ReturnsTrue() {
         String pattern = "abc";
+        assertTrue(RegexTools.matches("abc", pattern), "Input should match pattern");
+        assertFalse(RegexTools.matches("ABC", pattern), "Input should match pattern");
+        assertTrue(RegexTools.matches("ABC", pattern, Pattern.CASE_INSENSITIVE), "Input should match pattern");
+
         Pattern compiledPattern = Pattern.compile(pattern);
         assertTrue(RegexTools.matches("abc", compiledPattern), "Input should match pattern");
+        assertFalse(RegexTools.matches("ABC", compiledPattern), "Input should match pattern");
+
+        assertTrue(RegexTools.matches("abc", pattern, true), "Input should match pattern");
+        Pattern cachedPattern1 = RegexTools.getPattern(pattern);
+        Pattern cachedPattern2 = RegexTools.getPattern(pattern);
+        assertSame(cachedPattern1, cachedPattern2, "Cached pattern should be the same");
     }
 
     @Test
     void matches_InputDoesNotMatchPattern_ReturnsFalse() {
         String pattern = "abc";
-        Pattern compiledPattern = Pattern.compile(pattern);
-        assertFalse(RegexTools.matches("abcd", compiledPattern), "Input should not match pattern");
+        assertFalse(RegexTools.matches("abcd", pattern), "Input should not match pattern");
     }
 
     @Test
     void matches_NullInput_ReturnsFalse() {
         String pattern = "abc";
-        Pattern compiledPattern = Pattern.compile(pattern);
-        assertFalse(RegexTools.matches(null, compiledPattern), "Null input should return false");
+        assertFalse(RegexTools.matches(null, pattern), "Null input should return false");
     }
 
     @Test
@@ -119,6 +128,7 @@ class RegexToolsTests {
             compiledPatterns[i] = Pattern.compile(patterns[i]);
         }
         assertFalse(RegexTools.matchesOne("xyz", compiledPatterns), "Input should not match any pattern");
+        assertFalse(RegexTools.matchesOne(null, compiledPatterns), "Input should not match any pattern");
     }
 
     @Test
@@ -139,30 +149,40 @@ class RegexToolsTests {
             compiledPatterns[i] = Pattern.compile(patterns[i]);
         }
         assertFalse(RegexTools.matchesAll("abc", compiledPatterns), "Input should not match all patterns");
+        assertFalse(RegexTools.matchesAll(null, compiledPatterns), "Input should not match all patterns");
     }
 
     @Test
     void getMatcher_ValidInputAndPattern_ReturnsMatcher() {
         String pattern = "abc";
-        Pattern compiledPattern = Pattern.compile(pattern);
-        Matcher matcher = RegexTools.getMatcher("abc", compiledPattern);
-        assertNotNull(matcher, "Matcher should not be null");
+        Matcher matcher1 = RegexTools.getMatcher("abc", pattern);
+        assertNotNull(matcher1, "Matcher should not be null");
+        assertTrue(matcher1.matches(), "Should be matches");
+
+        Matcher matcher2 = RegexTools.getMatcher("ABC", pattern, true);
+        assertNotNull(matcher2, "Matcher should not be null");
+        assertFalse(matcher2.matches(), "Should be matches");
+
+        Pattern cachedPattern = RegexTools.getPattern(pattern);
+        Pattern patternFromCache = RegexTools.getPattern(pattern);
+        assertSame(cachedPattern, patternFromCache);
     }
 
     @Test
     void getMatcher_NullInput_ThrowsException() {
         String pattern = "abc";
-        Pattern compiledPattern = Pattern.compile(pattern);
         assertThrows(NullPointerException.class, () -> {
-            RegexTools.getMatcher(null, compiledPattern);
+            RegexTools.getMatcher(null, pattern);
         });
     }
 
     @Test
     void getMatcher_NullPattern_ThrowsException() {
-        final Pattern pattern = null;
         assertThrows(NullPointerException.class, () -> {
-            RegexTools.getMatcher("abc", pattern);
+            RegexTools.getMatcher("abc", (String) null);
+        });
+        assertThrows(NullPointerException.class, () -> {
+            RegexTools.getMatcher("abc", (Pattern) null);
         });
     }