TreeSet Sınıfı

Giriş
Şu satırları dahil ederiz.

import java.util.SortedSet;
import java.util.TreeSet;

TreeSet altta TreeMap sınıfını kullanır. Açıklaması şöyle. Ekleme ve silme işlemleri sonucu ağacın dengesi bozulmasın diye düz binary tree yerine red-black tree tercih edilmiş.

TreeSet, which stores its elements in a red-black tree, orders its elements based on their values;

SortedSet Ata Sınıfı
TreeSet aynı zamanda SortedSet olduğu için şöyle yapabiliriz.

SortedSet<Integer> sortedSet = new TreeSet<Integer>();

Diamond operator ile şöyle yaparız.

SortedSet<Integer> sortedSet = new TreeSet<>();

constructor - default
İmzası şöyledir.

public class TreeSet<E>

Şöyle yaparız.

TreeSet<MyClass> ts = new TreeSet<>();

constructor - Collection
Şöyle yaparız.

LinkedList<Integer> linkedList = new LinkedList<Integer>();
...
SortedSet<Integer> sortedSet = new TreeSet<Integer>(linkedList);

constructor - Comparator
TreeSet normalde eklenen nesnelerin Comparable olmasını ister. Eğer nesnemiz Comparable değilse, kendi  Comparator gerçekleştirimimiz belirtebiliriz Açıklaması şöyle.

TreeSet(Comparator comparator)
Constructs a new, empty tree set, sorted according to the specified comparator.

İmzası şöyle. Burada E ve E'nin atası comparator ile kullanılabiliyor

public TreeSet(Comparator<? super E> comparator) {...}

Açıklaması şöyle

Let's consider three classes: Drink, Juice extends Drink, and OrangeJuice extends Juice.

If I want a TreeSet<Juice>, I need a comparator that will compare any two juices. Of course a Comparator<Juice> will do this.

A Comparator<Drink> will also do this, because it is able to compare any two drinks, and thus any two juices.

A Comparator<OrangeJuice> will not do this. If I wanted to add an AppleJuice to my set of juices, that is not compatible with this comparator as it can only compare orange juices.

Örnek
Şöyle yaparız.

Set<Foo> s = new TreeSet<>(new Comparator<Foo>() {
  @Override
  public int compare(Foo o1, Foo o2) {
    ...
  }
});

Örnek
X alanına göre sıralamak için şöyle yaparız.

SortedSet<Point> points = new TreeSet<>(Comparator.comparing(Point::getX));

Örnek
Id alanına göre sıralamak için şöyle yaparız.

TreeSet <Foos> s = new TreeSet<>(
  Comparator.nullsFirst( Comparator.comparing ( Foo::getId ) )
);

Örnek
String sıralamak için şöyle yaparız.

Set<String> languages = new TreeSet<>(String::compareToIgnoreCase);

Örnek

Sadece uzunluğa göre sıralamak için şöyle yaparız. Burada b nesnesini ekleyemedik çünkü aynı uzunlukta a elemanı vardı 

Set<String> treeSet = new TreeSet<>(Comparator.comparing(String::length));
treeSet.add("a");
treeSet.add("b");
treeSet.add("aa");
treeSet.add("abc");

System.out.println(treeSet);

// [a, aa, abc]

add metodu
Eğer TreeSet eklenecek elemanın Comparable olmasını gerektirecek şekilde tanımlanmışsa ve E tipinden değilse

java.lang.ClassCastException

atar. Boolean döner. Şöyle yaparız.

if (ts.add(new MyClass()) {...}

addAll metodu
Örnek
Şöyle yaparız.

Collection c = ...;
ts.addAll(c);

Örnek
Şöyle yaparız

public static <T> Set<T> distinct(
        Collection<? extends T> list,
        Comparator<? super T> comparator) {

  Set<T> set = new TreeSet<>(comparator);
  set.addAll(list);
  return set;
}

clear metodu

Şöyle yaparız.

ts.clear();

contains metodu
Şöyle yaparız.

boolean result = ts.contains(element);

first metodu
Şöyle yaparız.

int num = ...;
if (num > ts.first()) {...}

remove metodu

Belirtilen elemanı silmek için şöyle yaparız.

int num = ...;
boolean removed = ts.remove (num);

İlk elemanı silmek için şöyle yaparız.

ts.remove (ts.first());

removeAll metodu - Comparator Kullanan TreeSet İçin Tehlikeli Bir Metod
Açıklaması şöyle.

This implementation determines which is the smaller of this set and the specified collection, by invoking the size method on each. If this set has fewer elements, then the implementation iterates over this set, checking each element returned by the iterator in turn to see if it is contained in the specified collection. If it is so contained, it is removed from this set with the iterator's remove method. If the specified collection has fewer elements, then the implementation iterates over the specified collection, removing from this set each element returned by the iterator, using this set's remove method.

Örnek
Elimizde şöyle bir kod olsun.

final Set<String> languages = new TreeSet<>(String::compareToIgnoreCase);
languages.add("java");
languages.add("c++");
languages.add("python");

System.out.println(languages);                 // [c++, java, python]

Bu koda silinmek üzere bir liste verelim. Listenin uzunluğu TreeSet'in uzunluğundan <= olduğu için silme işlemi TreeSet dolaşılarak yapılır. Bu durumda String::compareToIgnoreCase() kullanılır

languages.removeAll(Arrays.asList("PYTHON", "C++"));

System.out.println(languages);                 // [java]

Ancak bu sefer elimizde şöyle bir kod olsun. Listenin uzunluğu TreeSet'in uzunluğundan > olduğu için silme işlemi Liste dolaşılarak yapılır. Bu durumda String::equals() kullanılır. Büyük ve küçük harf string'ler farklı oldukları için silme işlemi gerçekleşmez.

languages.removeAll(Arrays.asList("PYTHON", "C++", "LISP"));

System.out.println(languages);                 // [c++, java, python]

size metodu
Şöyle yaparız.

int size = ts.size();