在Java中检查一组字符串中的包含

我有一套字符串[]。我想检查此集合是否包含另一个字符串[]

Set<String[]> s  = new HashSet<String[]>();
s.add(new String[] {"lucy", "simon"});
System.out.println(s.contains(new String[] {"lucy", "simon"}));

Set s=newhashset（）；
s、 添加（新字符串[]{“lucy”，“simon”}）；
println（s.contains（新字符串[]{“lucy”，“simon”}））；

但是，打印的是false。我猜这是因为只比较引用，而不是实际字符串。看起来，我唯一的选择是创建一个类，比如说短语，并实现

hashCode（）

和

equals（）

（使用

Arrays.hashCode（…）

）

---

有没有其他方法可以达到我想要的

将

String[]

转换为

List

，应该可以很好地工作

Set<List<String>> s  = new HashSet<List<String>>();
s.add(Arrays.asList("lucy", "simon"));
System.out.println(s.contains(Arrays.asList("lucy", "simon")));

Set s=newhashset（）；
s、 添加（Arrays.asList（“lucy”、“simon”）；
System.out.println（s.contains（Arrays.asList（“lucy”、“simon”））；

您的猜测是正确的：数组（[]）没有实现deep equals方法：如果它们是相同的实例，则它们是相等的

最简单的解决方案是：将

String[]

替换为

List

另一种方法（但我不推荐）是实现您自己的集合，它不是基于

Object.equals

，而是基于

java.util.array.equals（Object[]a，Object[]b）

使用

Set

或

Set

而不是

Set

代码：

List<String> s1=Arrays.asList("1","2"),s2=Arrays.asList("1","2");
System.out.println(s1.equals(s2) + " "+s1.hashCode()+ " "+s2.hashCode());

true 2530 2530

---

听起来你已经回答了你的问题。一个选择是你已经说过的。另一种方法是使用Set>，因为equals（Object）的API说明：

比较指定对象与此集合是否相等

---

我只是循环调用数组。等于：

大概是这样的：

boolean contains(Set<String[]> s, String[] item) {
  for(String[] toCompare: s) {
    if(Arrays.equals(toCompare, item)) {
        return true;
    }
  }
  return false;
}

boolean包含（集合s，字符串[]项）{
for（字符串[]到比较：s）{
if（Arrays.equals（toCompare，item））{
返回true；
}
}
返回false；
}

---

不确定它是否是最快的，但它应该很好地完成这项工作

字符串[]的元素是否可以以不同的顺序排列，并且仍然可以将整个数组视为等同于另一个数组，该数组以另一个顺序包含相同的元素？如果是，那么最好实现一个容器类并重写equals和hashcode

如果不是，并且可以将内部元素存储为列表而不是数组，则可以执行以下操作：

package com.stackoverflow;


import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


public class StringContainment {

  public static void main(final String[] args) {
    final Set<String[]> s = new HashSet<String[]>();
    final Set<List<String>> s2 = new HashSet<List<String>>();

    s.add(new String[] {"lucy", "simon"});
    s2.add(Arrays.asList(new String[] { "lucy", "simon" }));

    System.out.println(s.contains(new String[] {"lucy", "simon"})); // false
    System.out.println(s2.contains(Arrays.asList(new String[] {"lucy", "simon"}))); // true
  }

}

package com.stackoverflow；
导入java.util.array；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
公共类安全壳{
公共静态void main（最终字符串[]args）{
最终集s=新的HashSet（）；
final Set s2=新的HashSet（）；
s、 添加（新字符串[]{“lucy”，“simon”}）；
添加（Arrays.asList（新字符串[]{“lucy”，“simon”}））；
System.out.println（s.contains（新字符串[]{“lucy”，“simon”}））；//false
System.out.println（s2.contains（Arrays.asList（新字符串[]{“lucy”，“simon”}））；//true
}
}

第一个检查将返回false，第二个检查将返回true。 如果您可以使用列表，那么这样做可能会更容易

如果您不能，您仍然可以使用它，只要您不需要经常进行这种比较（从性能角度来看，这绝对不是一个好主意）。

使用流介绍，您可以通过以下方式进行：

Boolean res = s.stream()
  .anyMatch(elm -> elm.equals("lucy") || elm.equals("simon"));