13 Temmuz 2018 Cuma

Collections Sınıfı

Giriş
Şu satırı dahil ederiz.
import java.util.Collections;
addAll metodu
İkinci diziyi birinci diziye ekler.

binarySearch metodu
Arrays.binarySearch ile aynıdır. Metodun imzası şöyle
Collections.binarySearch(List<? extends Comparable<? super T>> list, T key)

disjoint metodu
İki dizinin birbirleriyle kesişimi yoksa, true döner.
Örnek
Şöyle yaparız.
List<Foo> list1 = ...;
List<Foo> list2;
boolean result = Collections.disjoint(list1, list2);
Örnek
Kesişim olduğunu bulmak için şöyle yaparız.
return !Collections.disjoint(list1, list2);
Örnek
Aslında dizilerin sıralı olduğunu biliyorsak şöyle yapabiliriz.
public static final <T extends Comparable<? super T>> 
boolean disjoint2(List<? extends T> list1, List<? extends T>list2){
  for(T x: list1){
    if(Collections.binarySearch(list2, x)>=0){
      return false;
    }
  }   
  return true;
}
emptyMap metodu
Açıklaması şöyle. Bu metod ile Map.of() benzer iş yaparlar. Fark olarak bu metod null key alabilirken, diğeri alamaz.
Returns an empty map (immutable). This map is serializable.
frequency metodu
Birinci parametre içinde arama yapılacak olan liste, ikinci parametre aranılan nesnedir.  p nesnesinin equals metodunu gerçekleştiriyor olması gerekir.  Şöyle yaparız. Aslında bu metodun frequency yerine count() olarak adlandırılması daha iyi olurdu.
int count = Collections.frequency (list, foo);
max metodu
Şöyle yaparız.
List<Tuple<Integer, String>> list = ...;
Tuple<Integer, String> largestTuple = Collections.max(list, 
 Comparator.comparingInt(t -> t.x));
nCopies metodu
Açıklaması şöyle. Aynı nesneden n tane doldurulmuş bir liste döner.
Returns an immutable list consisting of n copies of the specified object.
Şöyle yaparız
Collections.nCopies (100, Boolean.FALSE).stream()...
Listeye yeni bir nesne daha eklemek istiyorsak şöyle yaparız.
List<String> mutable = new ArrayList<>(Collections.nCopies(10, "Hi"));
newSetFromMap metodu
Şöyle yaparız.
Set<String> set = Collections.newSetFromMap(new LinkedHashMap<>(16, 0.75f, true));
reverse metodu
Verilen diziyi tersine çevirir.
Örnek
Şöyle yaparız.
List<String> list = new ArrayList<String>();
list2.addAll(...);
...
Collections.reverse(list);
Örnek
Şöyle yaparız.
Stack<Character> stack = ...
Collections.reverse (stack);
reverseOrder metodu
Sıralamayı terse çeviren bir comparator döndürür.
Map<Float, String> mylist = new HashMap<>();
...
SortedSet<Float> orderlist = new TreeSet<Float>(Collections.reverseOrder());
orderList.addAll(mylist.keySet());
shuffle metodu
Şöyle yaparız.
List<Tuple<Integer, String>> list = ...;
Collections.shuffle(list);
singleton metodu
Bir set döndürür. Metodun içi şöyle.
public static <T> Set<T> singleton(T o) {
  return new SingletonSet<>(o);
}
Şöyle yaparız.
public Iterable<Board> solution() {
  return Collections.singleton(board);
}
singletonMap metodu
Metodu için şöyle.
public static <K,V> Map<K,V> singletonMap(K key, V value) {
  return new SingletonMap<>(key, value);
}
Açıklaması şöyle.
Returns an immutable map, mapping only the specified key to the specified value. The returned map is serializable.
Örnek
Map'i güncellemeye çaılışınca exception fırlatılır. Şu kod hatalı
Collections.singletonMap("k", "v").computeIfAbsent("k", k -> "v" ); 
sort metodu - List
Not 1: Bazı veri yapılarının kendi sort metodları var. Örneğin Arrays.sort() veya list.sort() şöyle yaparız
list.sort(Comparator.comparing(Item::getName));
Not 2: Java 8 ile gelen paralel sort bir seçenek olarak düşünülebilir.
List<Point> pixels = ...

// Java 7 sorting
Collections.sort(pixels, comparator);

// Java 8 sorting
pixels = pixels.stream().parallel().
         sorted(comparator).collect(Collectors.toList());
Metodun imzası şöyle.
public static <T extends Comparable<? super T>> void sort(List<T> list) 
1. Comparable Kullanarak 
Nesne Comparable arayüzünü gerçekleştirsin.
public class Foo implements Comparable<Foo> {

  @Override
  public int compareTo(Foo f) {
    return ...
  }
  ...
}
Şöyle yaparız.
List<Foo> list = ...;
Collections.sort (list); 
sort metodu - List + Comparator
Açıklaması şöyle.
This implementation defers to the List.sort(Comparator) method using the specified list and comparator.
Metodun içi şöyle.
public static <T> void  sort(List<T> list, Comparator<? super T> c) {
  list.sort(c);
}
1. Lambda Kullanarak 
Elimizdeki nesneleri isimlerine göre sıralamak istiyor olalım. Lambda ile şöyle yaparız.
Collections.sort(list,(a1,a2) -> (a1.getName().compareTo(a2.getName())));
2. Comparator Kullanarak 
Eğer Comparator kullanmak istersek şöyle yaparız.
Collections.sort(list, Comparator.comparing(Item::getName));
swap metodu
Belirtilen konumlardaki elemanları yer değiştirir. İmzası şöyledir.
swap(List<?> list, int i, int j) 
Metodun içi şuna benzer.
public static void swap(List<?> list, int i, int j) {
    final List l = list;
    l.set(i, l.set(j, l.get(i)));
}
Şöyle yaparız.
List<String> listOfStrings = new ArrayList<>();
listOfStrings.add("a");
listOfStrings.add("b");
listOfStrings.add("c");
listOfStrings.add("d");

Collections.swap(listOfStrings, 0, 1);
synchronizedCollection metodu
Metodun imzası şöyle
public static <T> Collection<T> synchronizedCollection(Collection<T> c) {
    return new SynchronizedCollection<T>(c);
}
Şöyle kullanırız.
List<Date> lst = ...
Collection<Date> synchedLst = Collections.syncrhonizedCollection(lst);
Bu metod sayesinde nesnemizi syncronized blokları içine almak zorunda kalmayız.
List lst = LinkedList();
synchronized (lst) {
  lst.add... // do some work  lst.set...  lst.remove...}
synchronizedList metodu
Metodun içi şöyle
public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
        new SynchronizedRandomAccessList<T>(list) :
        new SynchronizedList<T>(list));
}
SynchronizedList tüm public metodlarında bir kilit kullanır.

synchronizedMap metodu
Şöyle yaparız.
Map<K, V> view = Collections.synchronizedMap (...);
Kendi içindeki private static SynchronizedMap sınıfını döner. Metodun içi şöyle
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
    return new SynchronizedMap<>(m);
}
SynhronizedMap sınıfının constructor metodları şöyle.
SynchronizedMap(Map<K,V> m) {
  this.m = Objects.requireNonNull(m);
  mutex = this;
}

SynchronizedMap(Map<K,V> m, Object mutex) {
  this.m = m;
  this.mutex = mutex;
}
SynchronizedMap nesnenin tüm public metodlarında bir kilit kullanılır. Örneğin toString metodu şöyle.
public String toString() {
    synchronized (mutex) {return m.toString();}
}
unmodifiableList metodu
Belirtilen list'e değiştirilemez bir view sağlar. İlk liste değişirse unmodifiable list değişiklikleri yansıtır.
List<Person> intList = ...;
List<Person> unModifybale = Collections.unmodifiableList(intList);
//Adding element to parentList
intList.add(p4);        

// Here unModifyble List also gets element after added in parent list
System.out.println("\n unModifyble"+ unModifybale);



Hiç yorum yok:

Yorum Gönder