如何在 Java 中搜索一串键/值对

Question

我有一个格式如下的字符串：

"key1=value1;key2=value2;key3=value3"

适用于任意数量的键/值对。

我需要检查某个键是否存在（假设它称为“特殊键”）。如果是这样，我想要与之关联的值。如果设置了多个“特殊键”，我只想要第一个。

现在，我正在寻找“specialkey”的索引。我从该索引开始获取一个子字符串，然后查找第一个 = 字符的索引。然后我寻找第一个; 字符的索引。这两个索引之间的子字符串给了我与“specialkey”相关的值。

这不是一个优雅的解决方案，它真的让我很困扰。找到与“specialkey”对应的值的优雅方法是什么？

Answer 1

使用String.split:

String[] kvPairs = "key1=value1;key2=value2;key3=value3".split(";");

这将为您提供一个包含以下元素的数组kvPairs：

key1=value1
key2=value2
key3=value3

遍历这些并拆分它们：

for(String kvPair: kvPairs) {
   String[] kv = kvPair.split("=");
   String key = kv[0];
   String value = kv[1];

   // Now do with key whatever you want with key and value...
   if(key.equals("specialkey")) {
       // Do something with value if the key is "specialvalue"...
   }
}

Answer 2

如果它只是您所追求的一键，您可以使用正则表达式 \bspecialkey=([^;]+)(;|$) 并提取捕获组 1：

Pattern p = Pattern.compile("\\bspecialkey=([^;]+)(;|$)");
Matcher m = p.matcher("key1=value1;key2=value2;key3=value3");

if (m.find()) {
    System.out.println(m.group(1));
}

如果您正在使用其他键做某事，则在循环中拆分 ; 和 = - 不需要正则表达式。

Answer 3

我会将字符串解析为映射，然后只检查键：

String rawValues = "key1=value1;key2=value2;key3=value3";
Map<String,String> map = new HashMap<String,String>();
String[] entries = rawValues.split(";");
for (String entry : entries) {
  String[] keyValue = entry.split("=");
  map.put(keyValue[0],keyValue[1]);
}

if (map.containsKey("myKey")) {
   return map.get("myKey");
}

Answer 4

以防万一有人对纯正则表达式方法感兴趣，以下 sn-p 有效。

Pattern pattern = Pattern.compile("([\\w]+)?=([\\w]+)?;?");
Matcher matcher = pattern.matcher("key1=value1;key2=value2;key3=value3");
while (matcher.find()) {
   System.out.println("Key - " + matcher.group(1) + " Value - " + matcher.group(2);
}

输出将是

Key - key1 Value - value1
Key - key2 Value - value2
Key - key3 Value - value3

但是，正如其他人之前解释的那样，建议在任何一天使用String.split() 来执行此类任务。当有替代方法时，您不应该尝试使用 Regex 使您的生活复杂化。

Answer 5

试试看：(?:(?:A=)([^,]*))

演示：https://regex101.com/r/rziGDz/1

否则，您使用正则表达式和您的列表找到代码以获得答案：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.*;
    
public class Main 
{
    public static void main(String[] args) 
    {
      
    List<Integer> results = new ArrayList();
    Pattern pattern = Pattern.compile("(?:(?:A=)([^,]*))", Pattern.CASE_INSENSITIVE);
    List<String> OriginalList = Arrays.asList(
            "A=1,B=2,C=3",
            "A=11,B=12,C=13,D=15",
            "A=5,B=4,C=9,D=10,E=13",
            "A=19,B=20,C=91,D=40,E=33",
            "A=77,B=27,C=37");
            
        for (int i = 0; i < OriginalList.size(); i++) 
        {
            Matcher matcher = pattern.matcher(OriginalList.get(i));
            boolean matchFound = matcher.find();
            if(matchFound) 
            {
                System.out.println( matcher.group(1) );
                results.add( Integer.parseInt(matcher.group(1)) );
            }
        }
    }
}

Answer 6

使用基本过滤器：使用[A-Z=,]+ 正则表达式进行拆分。选择第二个元素。

public List filter() {
        List<String> originalList = Arrays.asList("A=1,B=2,C=3", "A=11,B=12,C=13,D=15", "A=5,B=4,C=9,D=10,E=13",
                "A=19,B=20,C=91,D=40,E=33", "A=77,B=27,C=37");
        List<Integer> parsedData = new ArrayList();
        
        for(String str: originalList) {
            Integer data = Integer.parseInt(str.split("[A-Z=,]+")[1]);
            parsedData.add(data);
            
        }
        return parsedData;
        
}

Answer 7

试试这个：

List<Integer> results = new ArrayList();

Pattern p = Pattern.compile("(?:(?:A=)([^,]*))");
Matcher m = null;
     
for (String tmp : OriginalList) {
    m = p.matcher(tmp);
    if (m.find()) {
     int r = Integer.parseInt(m.group(0).replace("A=", ""));
        results.add(r);
    }
        
}

Answer 8

有很多方法可以做到这一点。也许最简单的是使用 Streams API（Java 8 及更高版本可用）来处理匹配结果：

List<String> OriginalList = Arrays.asList("A=1,B=2,C=3",
        "A=11,B=12,C=13,D=15", "A=5,B=4,C=9,D=10,E=13",
        "A=19,B=20,C=91,D=40,E=33", "A=77,B=27,C=37");

• 这会流式传输字符串
• 匹配模式并提取整数
• 收集到列表

Pattern p = Pattern.compile("A=(\\d+)");
List<Integer> result = OriginalList.stream().
        flatMap(str->p.matcher(str).results())
        .map(mr->Integer.valueOf(mr.group(1)))
        .collect(Collectors.toList());

System.out.println(result);

打印：

[1, 11, 5, 19, 77]

Answer 9

这可以使用 Stream API 来实现，方法是用逗号和Stream::flatMap简单地分割输入列表中的每个字符串

// assuming A is not always at the beginning
List<String> list = Arrays.asList(
        "A=1,B=2,C=3",
        "A=11,B=12,C=13,D=15",
        "A=5,B=4,C=9,D=10,E=13",
        "B=20,C=91,D=40,E=33",
        "B=27, A=19, C=37, A=77");

List<Integer> aNums = list.stream() // Stream<String>
    .flatMap(
        s -> Arrays.stream(s.split("\\s*,\\s*")) // Stream<String> pairs of letter=digits
                   .filter(pair -> pair.startsWith("A="))
                   .map(pair -> Integer.valueOf(pair.substring(2)))
    )
    .collect(Collectors.toList());
System.out.println(aNums);

输出：

[1, 11, 5, 19, 77]

---

更新
拆分输入字符串并仅保留与A 相关的数字的模式可以应用如下：

Pattern splitByA = Pattern.compile("A\\s*=\\s*|\\s*,\\s*|[^A]\\s*=\\s*\\d+");
List<Integer> aNums2 = list.stream()
    .flatMap(splitByA::splitAsStream) // Stream<String>
    .filter(Predicate.not(String::isEmpty)) // need to remove empty strings
    .map(Integer::valueOf)
    .collect(Collectors.toList());
System.out.println(aNums2);

输出是一样的

[1, 11, 5, 19, 77]