集合removeAll忽略大小写？

Question

好的，这是我的问题。 我必须使用 HashSet，我使用 removeAll 方法从一组中删除存在于另一组中的值。

在调用该方法之前，我显然将值添加到 Set 中。 在添加之前，我对每个 String 调用 .toUpperCase() ，因为两个列表中的值大小写不同。 这个案子没有任何规律或理由。

调用 removeAll 后，我需要取回 Set 中剩余值的原始情况。 有没有一种有效的方法可以做到这一点，而无需运行原始列表并使用CompareToIgnoreCase？

示例：

List1：

"BOB"
"Joe"
"john"
"MARK"
"dave"
"Bill"

List2：

"JOE"
"MARK"
"DAVE"

此后，在 String 上使用 toUpperCase() 为每个 List 创建一个单独的 HashSet。 然后调用removeAll。

Set1.removeAll(set2);

Set1:
    "BOB"
    "JOHN"
    "BILL"

我需要让列表再次看起来像这样：

"BOB"
"john"
"Bill"

任何想法将不胜感激。 我知道它很差，原始列表应该有一个标准，但这不是我可以决定的。

Answer 1

在我原来的答案中，我不假思索地建议使用 Comparator，但这会导致 TreeSet 违反 equalscontract 并且是一个正在等待的错误发生的情况：

// Don't do this:
Set<String> setA = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
setA.add("hello");
setA.add("Hello");
System.out.println(setA);

Set<String> setB = new HashSet<String>();
setB.add("HELLO");
// Bad code; violates symmetry requirement
System.out.println(setB.equals(setA) == setA.equals(setB));

---

最好使用专用类型：

public final class CaselessString {
  private final String string;
  private final String normalized;

  private CaselessString(String string, Locale locale) {
    this.string = string;
    normalized = string.toUpperCase(locale);
  }

  @Override public String toString() { return string; }

  @Override public int hashCode() { return normalized.hashCode(); }

  @Override public boolean equals(Object obj) {
    if (obj instanceof CaselessString) {
      return ((CaselessString) obj).normalized.equals(normalized);
    }
    return false;
  }

  public static CaselessString as(String s, Locale locale) {
    return new CaselessString(s, locale);
  }

  public static CaselessString as(String s) {
    return as(s, Locale.ENGLISH);
  }

  // TODO: probably best to implement CharSequence for convenience
}

此代码不太可能导致错误：

Set<CaselessString> set1 = new HashSet<CaselessString>();
set1.add(CaselessString.as("Hello"));
set1.add(CaselessString.as("HELLO"));

Set<CaselessString> set2 = new HashSet<CaselessString>();
set2.add(CaselessString.as("hello"));

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

不幸的是，这更冗长。

Answer 2

可以通过以下方式完成：

1. 将列表的内容移动到不区分大小写的 TreeSet 中，
2. 然后不区分大小写地删除所有常见的 String，感谢 TreeSet#removeAll( Collection c)
3. 并最终依赖于 ArrayList#retainAll(Collection c) 将迭代列表的元素，并且对于每个元素在提供的集合上调用 contains(Object o) 来了解是否应该保留该值，这里由于集合不区分大小写，我们将只保留 String与我们提供的 TreeSet 实例中的内容不区分大小写地匹配。

相应的代码：

List<String> list1 = new ArrayList<>(
    Arrays.asList("BOB", "Joe", "john", "MARK", "dave", "Bill")
);

List<String> list2 = Arrays.asList("JOE", "MARK", "DAVE");

// Add all values of list1 in a case insensitive collection
Set<String> set1 = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
set1.addAll(list1);
// Add all values of list2 in a case insensitive collection
Set<String> set2 = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
set2.addAll(list2);
// Remove all common Strings ignoring case
set1.removeAll(set2);
// Keep in list1 only the remaining Strings ignoring case
list1.retainAll(set1);

for (String s : list1) {
    System.out.println(s);
}

输出：

BOB
john
Bill

NB 1： 将第二个列表的内容放入 TreeSet 中非常重要，特别是如果我们不这样做的话知道它的大小，因为如果当前集合的大小严格大于当前集合的大小，则 TreeSet#removeAll(Collection c) 的行为取决于两个集合的大小提供的集合，那么它将直接调用当前集合上的 remove(Object o) 来删除每个元素，在这种情况下提供的集合可以是一个列表。 但如果相反，它将在提供的集合上调用 contains(Object o) 来知道是否应该删除给定的元素，因此如果它不是不区分大小写的集合，我们就赢了得不到预期的结果。

注意事项 2：上述方法 ArrayList#retainAll(Collection c) 的行为与方法 默认实现的行为相同我们可以在 AbstractCollection 中找到 >retainAll(Collection c)，这样该方法实际上适用于任何实现了 retainAll(Collection> 的集合。 c) 具有相同的行为。

Answer 3

您可以使用 hashmap 和使用大写集作为映射到混合大小写集的键。

hashmap 的键是唯一的，您可以使用 HashMap.keyset() 获取一组键；

要检索原始大小写，就像 HashMap.get("UPPERCASENAME") 一样简单。

并根据 文档< /a>:

返回按键的集合视图
包含在这张地图中。 该套装是
由地图支持，因此更改为
地图反映在集合中，并且
反之亦然。集合支持元素
删除，这会删除
这张地图上对应的映射，
通过 Iterator.remove、Set.remove，
删除全部、保留全部和清除
运营。 它不支持
添加或添加所有操作。

所以 HashMap.keyset().removeAll 将影响 hashmap :)

编辑：使用 McDowell 的解决方案。 我忽略了一个事实，即您实际上并不需要字母大写：P

Answer 4

使用 google-collections 来解决这个问题将是一个有趣的问题。 您可以有一个像这样的常量谓词：

private static final Function<String, String> TO_UPPER = new Function<String, String>() {
    public String apply(String input) {
       return input.toUpperCase();
}

然后您所追求的可以像这样完成：

Collection<String> toRemove = Collections2.transform(list2, TO_UPPER);

Set<String> kept = Sets.filter(list1, new Predicate<String>() {
    public boolean apply(String input) {
        return !toRemove.contains(input.toUpperCase());
    }
}

即：

• 构建“要丢弃”列表的仅大写版本
• 对原始列表应用过滤器，保留仅那些大写值不在仅大写列表中的项目。

请注意，Collections2.transform 的输出不是一个高效的 Set 实现，因此，如果您正在处理大量数据并且探测该列表的成本将会受到影响您可以改为使用

Set<String> toRemove = Sets.newHashSet(Collections2.transform(list2, TO_UPPER));

它将恢复高效查找，将过滤返回到 O(n) 而不是 O(n^2)。

Answer 5

据我所知，哈希集使用对象的 hashCode 方法来区分它们。
因此，您应该在对象中重写此方法，以便区分不同的情况。

如果您确实使用字符串，则无法重写此方法，因为您无法扩展 String 类。

因此，您需要创建自己的类，其中包含一个字符串作为属性，并用您的内容填充该属性。 您可能需要 getValue() 和 setValue(String) 方法来修改字符串。

然后你可以将你自己的类添加到哈希图中。

这应该可以解决你的问题。

问候