TreeSet pokazuje złe wyniki

Cóż, to mnie zaskoczyło, Nie wiem czy mam rację, ale spójrz na tę implementację w AbstractSet:

public boolean removeAll(Collection<?> c) {
  Objects.requireNonNull(c);
  boolean modified = false;

  if (size() > c.size()) {
    for (Iterator<?> i = c.iterator(); i.hasNext(); )
      modified |= remove(i.next());
  } else {
    for (Iterator<?> i = iterator(); i.hasNext(); ) {
      if (c.contains(i.next())) {
        i.remove();
        modified = true;
      }
    }
  }
  return modified;
}

Zasadniczo w twoim przykładzie rozmiar zestawu jest równy rozmiarowi argumentów, które chcesz usunąć, więc wywoływany jest warunek else. W tym warunku jest sprawdzanie, czy kolekcja argumentów do usunięcia contains bieżącego elementu iteratora, a to sprawdzanie jest wrażliwe na wielkość liter, więc sprawdza, czy c.contains("a") i zwraca false, ponieważ c zawiera "A", a nie "a", więc element nie jest usuwany. Zauważ, że dodanie elementu do zestawu s.addAll(Arrays.asList("a", "b", "d")); działa poprawnie, ponieważ size() > c.size() jest teraz prawdziwe, więc nie ma już contains sprawdzania.

Aby dodać kilka informacji o tym, dlaczego remove z TreeSet faktycznie usuwa wielkość liter w twoim przykładzie (i pod warunkiem, że podążasz ścieżką if (size() > c.size()), Jak wyjaśniono w odpowiedzi przez @ Shadov):

Jest to metoda removew TreeSet:

public boolean remove(Object o) {
        return m.remove(o)==PRESENT;
    }

Wywołuje remove ze swojego wewnętrznego TreeMap:

public V remove(Object key) {
    Entry<K,V> p = getEntry(key);
    if (p == null)
        return null;

    V oldValue = p.value;
    deleteEntry(p);
    return oldValue;
}

Które wywołują getEntry

 final Entry<K,V> getEntry(Object key) {
        // Offload comparator-based version for sake of performance
        if (comparator != null)
            return getEntryUsingComparator(key);
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            Comparable<? super K> k = (Comparable<? super K>) key;
        Entry<K,V> p = root;
        while (p != null) {
            int cmp = k.compareTo(p.key);
            if (cmp < 0)
                p = p.left;
            else if (cmp > 0)
                p = p.right;
            else
                return p;
        }
        return null;
    }

Jeśli istnieje Comparator (jak w twoim przykładzie), wpis jest wyszukiwany na podstawie tego Comparator (odbywa się to przez getEntryUsingComparator), dlatego jest rzeczywiście znalezione (następnie usunięte), mimo różnicy przypadku.

To jest interesujące, więc oto kilka testów z wyjściem:

static void test(String... args) {
    Set<String> s =new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    s.addAll(Arrays.asList( "a","b","c"));
    s.removeAll(Arrays.asList(args));
    System.out.println(s);
}

public static void main(String[] args) {
    test("C");          output: [a, b]
    test("C", "A");     output: [b]
    test("C", "A","B"); output: [a, b, c]
    test("B","C","A");  output: [a, b, c]
    test("K","C");      output: [a, b]
    test("C","K","M");  output: [a, b, c] !!
    test("C","K","A");  output: [a, b, c] !!
}

Teraz bez komparatora działa jak sortowane HashSet<String>():

    static void test(String... args) {
    Set<String> s = new TreeSet<String>();//
    s.addAll(Arrays.asList( "a","b","c"));
    s.removeAll(Arrays.asList(args));
    System.out.println(s);
}

public static void main(String[] args) {
    test("c");          output: [a, b]
    test("c", "a");     output: [b]
    test("c", "a","b"); output: []
    test("b","c","a");  output: []
    test("k","c");      output: [a, b]
    test("c","k","m");  output: [a, b]
    test("c","k","m");  output: [a, b]
}

Teraz z dokumentacji:

Public boolean removeAll (Kolekcja c)

Usuwa z tego zbioru wszystkie jego elementy zawarte w określona kolekcja(operacja opcjonalna). Jeśli określony zbiór jest również zestawem, operacja ta skutecznie modyfikuje ten zestaw tak, aby jego wartość to asymetryczna różnica zestawu dwóch zestawów.

Ta implementacja określa, który jest mniejszy z tego zbioru i określonej kolekcji, wywołując na każdej z nich metodę size. Jeśli to set ma mniej elementów, wtedy implementacja iteruje nad tym set, sprawdzając po kolei każdy element zwracany przez iterator, aby sprawdzić, czy jest on zawarty w określonym zbiorze. Jeśli jest tak zawarta, to jest usuwany z tego zestawu za pomocą metody usuwania iteratora. Jeśli określone zbiór ma mniej elementów, wtedy implementacja iteruje nad określoną kolekcją, usuwając z tego zbioru każdy element zwracany przez iterator, używając metody remove tego zestawu.

Źródło