如何使用 Java 中的正则表达式从原始字符串中删除某些字符串

Question

我有一个带分隔符的字符串:它有两个令牌（旧令牌和新令牌）。 我有两种情况 - 我可能会得到

• 仅旧令牌oldToken-NmH0FKDKiITkIDDopLDkDD
• 新旧令牌oldToken-NmH0FKDKiITkIDDokDDsOxMdUU2qPnRxKiY:newToken-IdsfdWeRrrfziTjHNGfyKfK9YCoEsy6nTDI

第 1 步：为了识别新旧令牌，字符串附加了oldToken-和newToken- 。 我正在检查字符串是否同时包含旧令牌和新令牌，如果是，则获取 newToken 值，否则获取 oldtoken 值。 为了获得实际值，我根据条件删除了这个附加的字符串

splitResult[1].replaceAll("newToken-", ""))

第2步：获得令牌值后，检查map中是否存在此令牌，或者通过传递令牌来一一进行外部调用。

我在这里的挑战是我在很多地方都复制了replaceAll ，如何摆脱它。 或者有没有更好的方法来重构下面的代码，对不起，我是 Java 的新手，请见谅

请在下面找到代码：

public class Main {
    public static void main(String[] args) {

        // Scenario 1: This contains both the token
        String myKey = "oldToken-NmH0FKDKiITkIDDokDDsOxMdUU2qPnRxKiY:newToken-IdsfdWeRrrfziTjHNGfyKfK9YCoEsy6nTDI";

        // Scenario 2: This contains only one token
        // String myKey = "oldToken-NmH0FKDKiITkIDDopLDkDD";

        String[] splitResult = myKey.split(":");
        System.out.println(test(splitResult));

    }

    private static String test(String[] splitResult) {

        // Scenario 1: Map with value
        Map<String, String> myMap = new HashMap<>();
        myMap.put("NmH0FKDKiITkIDDokDDsOxMdUU2qPnRxKiY", "user1");
        myMap.put("IdsfdWeRrrfziTjHNGfyKfK9YCoEsy6nTDI", "user2");

        // Scenario 2: Empty Map
        // Map<String, String> myMap = new HashMap<>();

        String cache = null;
        if (splitResult.length >= 2) {
            if (splitResult[1].contains("newToken-") && splitResult[0].contains("oldToken-")) {

                cache = myMap.get(splitResult[1].replaceAll("newToken-", ""));
            }
        } else {
            cache = myMap.get(splitResult[0].replaceAll("oldToken-", ""));
        }

        // If no value in cache, make an external call with both the token
        if (cache == null) {
            String request = null;

            for (String getVal : splitResult) {
                if (getVal.contains("oldToken")) {
                    request = getVal.replaceAll("oldToken-", "");
                    System.out.println("request: " + request);
                    // Make an external call

                } else if (getVal.contains("newToken")) {
                    request = getVal.replaceAll("newToken-", "");
                    System.out.println("request: " + request);
                    // Make an external call
                }
            }
        }

        return cache;
    }

}

Answer 1

您可以通过使用负责从字符串中提取所需令牌的单独function 来减少重复。 请参阅下面示例代码中的getToken 。

您可以使用正则表达式，直到它适用于您的所有字符串，但这是一个示例。 请参阅此处的正则表达式文档。

如图所示，您可以将处理分成两个功能（甚至更多，取决于您还需要什么）。 您可以使用括号表示的正则表达式捕获组。 请注意， (?:...)是一个非捕获组。

编辑您可以将与令牌相关的行为封装到 TokenPair class 中，其中可能会或可能不会定义newToken 。 这样，您可以在处理缓存未命中时访问新令牌和旧令牌（并且还有一个简单的 function tokenInCache ，它只在可用的情况下提供对中的新令牌，以针对缓存进行检查）。

public class Main {
   public static class TokenPair {
        public String oldToken;
        public String newToken;
        public TokenPair(String oldToken, String newToken) {
            this.oldToken = oldToken;
            this.newToken = newToken;
        }
        public TokenPair(String oldToken) {
            this.oldToken = oldToken;
            this.newToken = null;
        }
        public String tokenInCache() {
            if (newToken == null) {
                return oldToken;
            }
            return newToken;
        }
        public static TokenPair getToken(String input){
            Pattern p = Pattern.compile("^oldToken-([A-Za-z0-9]+)(?::newToken-([A-Za-z0-9]+))?");   // the pattern to search for
            Matcher m = p.matcher(input);
            if (m.matches()) {
                if (m.group(2) != null) {
                    return new TokenPair(m.group(1), m.group(2));
                } else {
                    return new TokenPair(m.group(1));
                }
            } else {
                return null;
            }

        }

        @Override
        public String toString() {
            return oldToken + (newToken == null ? "" : ":" + newToken);
        }
    }
    public static void main(String[] args) {
        // Scenario 1: This contains both the tokens
        String myKey1 = "oldToken-NmH0FKDKiITkIDDokDDsOxMdUU2qPnRxKiY:newToken-IdsfdWeRrrfziTjHNGfyKfK9YCoEsy6nTDI";

        // Scenario 2: This contains only one token
        String myKey2 = "oldToken-NmH0FKDKiITkIDDopLDkDD";

        TokenPair token = TokenPair.getToken(myKey1);
        System.out.println(token); // "NmH0FKDKiITkIDDokDDsOxMdUU2qPnRxKiY:IdsfdWeRrrfziTjHNGfyKfK9YCoEsy6nTDI");
        System.out.println(TokenPair.getToken(myKey2)); // "NmH0FKDKiITkIDDopLDkDD");


        // Scenario 1: Map with value
        Map<String, String> myMap = new HashMap<>();
        myMap.put("NmH0FKDKiITkIDDokDDsOxMdUU2qPnRxKiY", "user1");
        myMap.put("IdsfdWeRrrfziTjHNGfyKfK9YCoEsy6nTDI", "user2");

        processToken(myMap, token);
    }
    private static void processToken(Map<String, String> cache, TokenPair tokenPair) {

        String cacheValue = cache.get(tokenPair.tokenInCache());

        if (cacheValue == null) {
            if (tokenPair.newToken != null) {
                // do processing here with tokenPair.newToken;
            }
            // do processing here with tokenPair.oldToken;

        }
    }
}

Answer 2

您可以通过定义获取令牌的函数来使其更简洁。

private static String getOldToken(String myKey) {
    Matcher matcher = Pattern.compile("(?<=\\boldToken-)[^:]*").matcher(myKey);
    return matcher.find() ? matcher.group() : "";
}

private static String getNewToken(String myKey) {
    Matcher matcher = Pattern.compile("(?<=\\bnewToken-)[^:]*").matcher(myKey);
    return matcher.find() ? matcher.group() : "";
}

正则表达式的解释(?<=\bnewToken-)[^:]* ：

• (?<= : Lookbehind assertion的开始。
  • \b ： 单词边界
  • newToken : 字面量， newToken
  • - ：字面量， -
• ) : Lookbehind 断言结束。
• [^:]* ：除:之外的任何字符，任意次数

完整代码：

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {

        // Scenario 1: This contains both the token
        String myKey = "oldToken-NmH0FKDKiITkIDDokDDsOxMdUU2qPnRxKiY:newToken-IdsfdWeRrrfziTjHNGfyKfK9YCoEsy6nTDI";

        // Scenario 2: This contains only one token
        // String myKey = "oldToken-NmH0FKDKiITkIDDopLDkDD";

        System.out.println(test(myKey));
    }

    private static String test(String myKey) {
        Map<String, String> myMap = new HashMap<>();

        String oldToken = getOldToken(myKey);
        String newToken = getNewToken(myKey);

        if (!oldToken.isBlank())
            myMap.put(oldToken, "user1");
        if (!newToken.isBlank())
            myMap.put(newToken, "user2");

        String cache = myMap.get(newToken);

        if (cache == null) {
            String request = oldToken;
            System.out.println("request: " + request);
            // Make an external call
        }

        return cache;
    }

    private static String getOldToken(String myKey) {
        Matcher matcher = Pattern.compile("(?<=\\boldToken-)[^:]*").matcher(myKey);
        return matcher.find() ? matcher.group() : "";
    }

    private static String getNewToken(String myKey) {
        Matcher matcher = Pattern.compile("(?<=\\bnewToken-)[^:]*").matcher(myKey);
        return matcher.find() ? matcher.group() : "";
    }
}