java - Java 集平等忽略大小写

Question

我想通过忽略字母的大小写来检查两组字符串的所有元素是否相等。

Set<String> set1 ;
Set<String> set2 ;
.
.
.
if(set1.equals(set2)){ //all elements of set1 are equal to set2 
 //dosomething
}
else{
 //do something else
}

但是，这种相等性检查不会忽略字符串的大小写。还有其他方法吗？

Answer 1

或者，您可以使用TreeSet.

public static void main(String[] args){
    Set<String> s1 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    s1.addAll(Arrays.asList(new String[] {"a", "b", "c"}));

    Set<String> s2 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    s2.addAll(Arrays.asList(new String[] {"A", "B", "C"}));

    System.out.println(s1.equals(s2));
}

Answer 2

不幸的是，Java 不允许您提供外部“相等比较器”：当您使用字符串时，HashSet仅使用内置的hashCodeand equals。

您可以通过使用转换为特定（即大写或小写）大小写的字符串填充辅助来解决此问题HashSet<String>，然后检查其是否相等，如下所示：

boolean eq = set1.size() == set2.size();
if (eq) {
    Set<String> aux = new HashSet<String>();
    for (String s : set1) {
        aux.add(s.toUpperCase());
    }
    for (String s : set2) {
        if (!aux.contains(s.toUpperCase())) {
            eq = false;
            break;
        }
    }
}
if (eq) {
    // The sets are equal ignoring the case
}

Answer 3

未经测试，但这是一般的想法：

public boolean setEqualsIgnoreCase(Set<String> a, Set<String>b)
{
    if (a.size() != b.size()) return false;
    Iterator<String> ai = a.iterator();
    Iterator<String> bi = b.iterator();
    while(ai.hasNext())
    {
         if (!ai.next().equalsIgnoreCase(bi.next())) return false;
    }
    return true;
}

Answer 4

从来没听说过。

我能看到的最好的解决方案，尽管过度设计，将是创建你的自定义持有者类来保存一个String实例字段（String是final并且不能被继承）。

然后，您可以覆盖equals/hashCode其中两个实例中的两个String属性，将返回并且s 将相等。equalsIgnoreCaseequalstruehashCode

这意味着：

• hashCode根据小写（或大写）属性的散列码返回散列码。

• equals是基于equalsIgnoreCase

  class MyString {
      String s;
  
      MyString(String s) {
          this.s = s;
      }
      @Override
      public int hashCode() {
          final int prime = 31;
          int result = 1;
          result = prime * result + ((s == null) ? 0 : s.toLowerCase().hashCode());
          return result;
      }
  
      @Override
      public boolean equals(Object obj) {
          if (this == obj)
              return true;
          if (obj == null)
              return false;
          if (getClass() != obj.getClass())
              return false;
          MyString other = (MyString) obj;
          if (s == null) {
              if (other.s != null)
                  return false;
          }
          else if (!s.equalsIgnoreCase(other.s))
              return false;
          return true;
      }
  
  }
  public static void main(String[] args) {
          Set<MyString> set0 = new HashSet<MyString>(
              Arrays.asList(new MyString[]
                  {
                      new MyString("FOO"), new MyString("BAR")
                  }
              )
          );
          Set<MyString> set1 = new HashSet<MyString>(
              Arrays.asList(new MyString[]
                  {
                      new MyString("foo"), new MyString("bar")
                  }
              )
          );
          System.out.println(set0.equals(set1));
   }
  

输出

true

...如前所述，过度设计（但工作）。

Answer 5

我会构建这样的东西（以某种形式的 Java 伪代码）：

Set<String> set1;
Set<String> set2;

if (set1.size() != set2.size()) {
  return NOT_EQUAL;
} else {
  Set<String> set3 = new HashSet<String>();
  for (String s: set1) set3.add(s.toUpperCase());
  for (String s: set2) set3.add(s.toUpperCase());
  return set1.size() == set3.size() ? EQUAL : NOT_EQUAL;
}

Answer 6

您可以使用循环和 equalsIgnoreCase

testString.equalsIgnoreCase()