Question

我有两个字符串，如下所示：

String str1 = "[0.7419,0.7710,0.2487]";
String str2 = "[\"0.7710\",\"0.7419\",\"0.2487\"]";

我希望比较它们，尽管顺序不同，但它们是平等的......

哪种方法最快最简单？

我应该将每个分成数组并比较两个数组吗？或不？我想我必须删除＆＃34; [＆＃34;，＆＃34;]＆＃34;，＆＃34;＆＃34;＆＃34;字符使它更清晰所以我做了。我也取代了＆＃34;，＆＃34;用＆＃34; ＆＃34;但我不知道这是否有帮助...

提前致谢：）

编辑：我的字符串并不总是一组双打或浮点数。它们也可能是实际的单词或一组字符。

Answer 1

因为您有混合结果类型，所以您需要先将其作为混合输入

处理

这是我如何替换它，特别是对于更长的琴弦。

private Stream<String> parseStream(String in) {
    //we'll skip regex for now and can simply hard-fail bad input later
    //you can also do some sanity checks outside this method
    return Arrays.stream(in.substring(1, in.length() - 1).split(",")) //remove braces
        .map(s -> !s.startsWith("\"") ? s : s.substring(1, s.length() - 1)); //remove quotes
}

接下来，我们现在有一个字符串流，需要将其解析为基元或字符串（因为我假设我们没有一些奇怪的对象序列化形式）： / p>

private Object parse(String in) {
    //attempt to parse as number first. Any number can be parsed as a double/long
    try {
        return in.contains(".") ? Double.parseDouble(in) : Long.parseLong(in);
    } catch (NumberFormatException ex) {
        //it's not a number, so it's either a boolean or unparseable
        Boolean b = Boolean.parseBoolean(in); //if not a boolean, #parseBoolean is false
        b = in.toLowerCase().equals("false") && !b ? b : null; //so we map non-false to null
        return b != null ? b : in; //return either the non-null boolean or the string
    }
}

使用它，我们可以将混合流转换为混合集合：

Set<Object> objs = this.parseStream(str1).map(this::parse).collect(Collectors.toSet());
Set<Object> comp = this.parseStream(str2).map(this::parse).collect(Collectors.toSet());
//we're using sets, keep in mind the nature of different collections and how they compare their elements here
if (objs.equals(comp)) {
    //we have a matching set
}

最后，一些健全性检查的例子是确保输入字符串上的相应大括号等等。尽管其他人说过，我将集合语法学习为{a, b, ...c}，并将系列/列表语法学习为{ {1}}，两者都有不同的比较。

Answer 2

这可以通过下面一个制作一组字符串的方法来完成，该字符串是使用 TreeSet 实现的，因此排序可以是构建的句柄。它只是一个简单的转换，在set字符串和比较使用equals方法。尝试以下代码：

String str1 = "[0.7419,0.7710,0.2487]";
        String str2 = "[\"0.7710\",\"0.7419\",\"0.2487\"]";
        String jsonArray = new JSONArray(str2).toString();
        Set<String> set1 = new TreeSet<String>(Arrays.asList(str1.replace("[", "").replace("]", "").split(",")));
        Set<String> set2 = new TreeSet<String>(Arrays.asList(jsonArray.replace("[", "").replace("]", "").replace("\"", "").split(",")));
        if(set1.equals(set2)){
             System.out.println(" str1 and str2 are equal");
       }

在上面的代码中，我借助 jsonArray 来删除“\”字符。

注意：

但如果一个字符串和其他字符串中的重复元素，这将无效字符串的数量不同，因为set不会保留重复项。

尝试使用列表来保留重复元素并解决您的问题。

String str1 = "[0.7419,0.7710,0.2487]";
            String str2 = "[\"0.7710\",\"0.7419\",\"0.2487\"]";
            String jsonArray = new JSONArray(str2).toString();
            List<String> list1=new ArrayList<String>(Arrays.asList(str1.replace("[", "").replace("]", "").split(",")));
            List<String> list2=new ArrayList<String>(Arrays.asList(jsonArray.replace("[", "").replace("]", "").replace("\"", "").split(",")));
            Collections.sort(list1);
            Collections.sort(list2);
            if(list1.equals(list2)){
                  System.out.println("str1 and str2 are equal");
            }

Answer 3

这是使用HashSet的非常简单的解决方案。

Set的好处： -

它不能包含重复。
元素的插入/删除是O（1）。

比Array快得多。这里保持元素顺序也是不重要，所以没关系。

String str1 = "[0.7419,0.7710,0.2487]";
String str2 = "[\"0.7710\",\"0.7419\",\"0.2487\"]";

Set<String> set1 = new HashSet<>();
Set<String> set2 = new HashSet<>();

String[] split1 = str1.replace("[", "").replace("]", "").split(",");
String[] split2 = str2.replace("[", "").replace("]", "").replace("\"", "").split(",");
set1.addAll(Arrays.asList(split1));
set2.addAll(Arrays.asList(split2));

System.out.println("set1: "+set1);
System.out.println("set2: "+set2);

boolean isEqual = false;
if(set1.size() == set2.size()){
    set1.removeAll(set2);
    if(set1.size() ==0){
        isEqual = true;
    }
}

System.out.println("str1 and str2 "+( isEqual ? "Equal" : "Not Equal") );

输出：

set1: [0.7710, 0.2487, 0.7419]
set2: [0.7710, 0.2487, 0.7419]
str1 and str2 Equal

Answer 4

像这样：

    String[] a1 = str1.replaceAll("^\\[|\\]$", "").split(",", -1);
    String[] a2 = str2.replaceAll("^\\[|\\]$", "").split(",", -1);
    for (int i = 0; i < a2.length; i++)
        a2[i] = a2[i].replaceAll("^\\\"|\\\"$", "");
    Arrays.sort(a1);
    Arrays.sort(a2);
    boolean stringsAreEqual = Arrays.equals(a1, a2);

或者您可以使用功能齐全的方法（可能效率稍低）：

    boolean stringsAreEqual = Arrays.equals(
            Arrays.stream(str1.replaceAll("^\\[|\\]$", "").split(",", -1))
                    .sorted()
                    .toArray(),
            Arrays.stream(str2.replaceAll("^\\[|\\]$", "").split(",", -1))
                    .map(s -> s.replaceAll("^\\\"|\\\"$", ""))
                    .sorted()
                    .toArray()
    );

使用数组而不是使用集合（如其他人所提出的）的优点是数组通常使用较少的内存，并且它们可以保留重复数据。如果您的问题域可以在每个字符串中包含重复元素，则无法使用集合。

Answer 5

Google GSON可以通过将值读作Set<String>来非常巧妙地处理此任务：

    final String str1 = "[0.7419,0.7710,0.2487]";
    final String str2 = "[\"0.7710\",\"0.7419\",\"0.2487\"]";
    final String str3 = "[\"0.3310\",\"0.7419\",\"0.2487\"]";
    final Gson gson = new Gson();
    final Type setOfStrings = new TypeToken<Set<String>>() {}.getType();
    final Set<String> set1 = gson.fromJson(str1, setOfStrings);
    final Set<String> set2 = gson.fromJson(str2, setOfStrings);
    final Set<String> set3 = gson.fromJson(str3, setOfStrings);

    System.out.println("Set #1:" + set1);
    System.out.println("Set #2:" + set2);
    System.out.println("Set #3:" + set3);
    System.out.println("Set #1 is equivalent to Set #2: " + set1.equals(set2));
    System.out.println("Set #1 is equivalent to Set #3: " + set1.equals(set3));

输出结果为：

Set #1:[0.7419, 0.7710, 0.2487]
Set #2:[0.7710, 0.7419, 0.2487]
Set #3:[0.3310, 0.7419, 0.2487]
Set #1 is equivalent to Set #2: true
Set #1 is equivalent to Set #3: false

Java：将字符串与不同顺序的关键字进行比较

5 个答案: