Fix #1549 (#2648)

* Fix #1549

* Revert changes on ModTranslations.

* Revert changes on StringUtils.

HMCLCore/src/main/java/org/jackhuang/hmcl/mod/curse/CurseForgeRemoteModRepository.java

@@ -112,7 +112,7 @@ public final class CurseForgeRemoteModRepository implements RemoteModRepository
                 .getJson(new TypeToken<Response<List<CurseAddon>>>() {
                 }.getType());
         Stream<RemoteMod> res = response.getData().stream().map(CurseAddon::toMod);
-        if (sortType != SortType.NAME || searchFilter.length() == 0) {
+        if (sortType != SortType.NAME || searchFilter.isEmpty()) {
             return new SearchResult(res, (int)Math.ceil((double)response.pagination.totalCount / pageSize));
         }
 
@@ -123,25 +123,11 @@ public final class CurseForgeRemoteModRepository implements RemoteModRepository
             searchFilterWords.put(s, searchFilterWords.getOrDefault(s, 0) + 1);
         }
 
+        StringUtils.LevCalculator levCalculator = new StringUtils.LevCalculator();
+
         return new SearchResult(res.map(remoteMod -> {
             String lowerCaseResult = remoteMod.getTitle().toLowerCase();
-            int[][] lev = new int[lowerCaseSearchFilter.length() + 1][lowerCaseResult.length() + 1];
-            for (int i = 0; i < lowerCaseResult.length() + 1; i++) {
-                lev[0][i] = i;
-            }
-            for (int i = 0; i < lowerCaseSearchFilter.length() + 1; i++) {
-                lev[i][0] = i;
-            }
-            for (int i = 1; i < lowerCaseSearchFilter.length() + 1; i++) {
-                for (int j = 1; j < lowerCaseResult.length() + 1; j++) {
-                    int countByInsert = lev[i][j - 1] + 1;
-                    int countByDel = lev[i - 1][j] + 1;
-                    int countByReplace = lowerCaseSearchFilter.charAt(i - 1) == lowerCaseResult.charAt(j - 1) ? lev[i - 1][j - 1] : lev[i - 1][j - 1] + 1;
-                    lev[i][j] = Math.min(countByInsert, Math.min(countByDel, countByReplace));
-                }
-            }
-
-            int diff = lev[lowerCaseSearchFilter.length()][lowerCaseResult.length()];
+            int diff = levCalculator.calc(lowerCaseSearchFilter, lowerCaseResult);
 
             for (String s : StringUtils.tokenize(lowerCaseResult)) {
                 if (searchFilterWords.containsKey(s)) {

HMCLCore/src/main/java/org/jackhuang/hmcl/util/StringUtils.java

@@ -357,29 +357,59 @@ public final class StringUtils {
         return true;
     }
 
-    public static class DynamicCommonSubsequence {
-        private LongestCommonSubsequence calculator;
+    public static class LevCalculator {
+        private int[][] lev;
 
-        public DynamicCommonSubsequence(int intLengthA, int intLengthB) {
-            if (intLengthA > intLengthB) {
-                calculator = new LongestCommonSubsequence(intLengthA, intLengthB);
-            } else {
-                calculator = new LongestCommonSubsequence(intLengthB, intLengthA);
+        public LevCalculator() {
+        }
+
+        public LevCalculator(int length1, int length2) {
+            allocate(length1, length2);
+        }
+
+        private void allocate(int length1, int length2) {
+            length1 += 1;
+            length2 += 1;
+            lev = new int[length1][length2];
+            for (int i = 1; i < length1; i++) {
+                lev[i][0] = i;
+            }
+            int[] cache = lev[0];
+            for (int i = 0; i < length2; i++) {
+                cache[i] = i;
             }
         }
 
+        public int getLength1() {
+            return lev.length;
+        }
+
+        public int getLength2() {
+            return lev[0].length;
+        }
+
+        private int min(int a, int b, int c) {
+            return Math.min(a, Math.min(b, c));
+        }
+
         public int calc(CharSequence a, CharSequence b) {
-            if (a.length() < b.length()) {
-                CharSequence t = a;
-                a = b;
-                b = t;
+            if (lev == null || a.length() >= lev.length || b.length() >= lev[0].length) {
+                allocate(a.length(), b.length());
             }
 
-            if (calculator.maxLengthA < a.length() || calculator.maxLengthB < b.length()) {
-                calculator = new LongestCommonSubsequence(a.length(), b.length());
+            int lengthA = a.length() + 1, lengthB = b.length() + 1;
+
+            for (int i = 1; i < lengthA; i++) {
+                for (int j = 1; j < lengthB; j++) {
+                    lev[i][j] = min(
+                            lev[i][j - 1] + 1, // insert
+                            lev[i - 1][j] + 1, // del
+                            a.charAt(i - 1) == b.charAt(j - 1) ? lev[i - 1][j - 1] : lev[i - 1][j - 1] + 1 // replace
+                    );
+                }
             }
 
-            return calculator.calc(a, b);
+            return lev[a.length()][b.length()];
         }
     }