31 Ekim 2016 Pazartesi

Collectors Sınıfı

Giriş
Şu satırı dahil ederiz.
import java.util.stream.Collectors;
Sınıf hazır tanımlı Collector nesneleri için factory gibi çalışır.

collectingAndThen metodu
Şu satırı dahil edebiliriz.
import static java.util.stream.Collectors.collectingAndThen;
Elimizde bir liste olsun.
List<File> files = ...
Bu listeyi ImageEntity listesine çevirip sonra tek bir listeye çevirmek için şöyle yaparız. Önce list alan bir constructor yazarız.
public ImageList(List<ImageEntity> list) {
  this.list = list;
}
Daha sonra şöyle yaparız.
ImageList imgList = files.stream()
  .map(file -> return new ImageEntity(file.getName())),     
  .collect(collectingAndThen(toList(), ImageList::new));
counting metodu
Stream'in uzunluğunu verir.

Elimizde bir sözcük listesi olsun. Listedeki sözcüklerin frekans tablosunu çıkarıp belli bir değerin üzerinde olan sözcüklerin sayısını şöyle buluruz.
int countThreshold = 2;
long sum =
    words.stream()
          .collect(Collectors.groupingBy(Function.identity(),
                                         Collectors.counting()))
          .values()
          .stream()
          .filter(x -> x >= countThreshold)
          .reduce(0L, Long::sum);
İki setin kesişimi kaç tane elemandan oluşur diye bulmak isteyelim. Şöyle yaparız.
Set<String> sOne = ...; Set<String> sTwo = ...;
long numFound = sOne.parallelStream()
                    .filter(segment -> sTwo.contains(segment))
                    .collect(Collectors.counting());

joining metodu
Şöyle yaparız.
var strings = stream.collect(Collectors.joining(", "));
groupingBy metodu
Şu satırı dahil ederiz.
import static java.util.stream.Collectors.groupingBy;
Metodun imzası şöyledir.
groupingBy(classifier, downstream)

Metod bir Map döner. Map nesnesinin key alanı classifier'ın döndürdüğü tip, Value alanı ise downstream'in döndürdüğü tiptir.

Classifier key değerini döner. Böylece nesneler key değerlerine göre gruplanır. Aynı key değerine sahip nesneleri downStream'e verilir. Aynı departmanda çalışan kişi sayısı şöyle bulunur.
Map<Department, Long> map =
    list.stream()
    .collect(Collectors.groupingBy(Employee::getDep, Collectors.counting()));
Şöyle bir çıktı alabiliriz.
Personnel: 4
Accounting: 3 
Production: 3
groupingBy metodu groupingBy
İç içe gruplamayı sağlar. İlk groupingBy Map<String,...> yapısını oluşturur. İkinci groupingBy içteki Map<String,...> yapısını oluşturur
Map<String, Map<String, List<Student>>> map= studs.collect(Collectors.groupingBy(
Student::getName,Collectors.groupingBy(Student::getLocation)));
groupingBy metodu+ collectionAndThen
Stream'deki nesneleri bir Map içine gruplar. Daha sonra Map'teki her bir elemanı bir kere daha dönüştürme imkanı tanır.

Elimizde bir Task ve Task'lara ait Job nesneleri olsun.
public class Task { int taskId; List<Job> jobList; }
Her Job ise bir agent tarafından çalıştırılabiliyor olsun.
// in class Job
int getAgentId() { // return the "agent" who is responsible for @param job }
Her agent'a düşen task'ları şöyle gruplamak isteyelim
// in class Partition; `Integer` for "agent" id
Map<Integer, Task> partition(Task task) { }
Şöyle yaparız.
task.getJobList().stream()
    .collect(
        groupingBy(
             Job::getAgentId,//agentID -> Job map
             collectingAndThen(toList(), jobs -> new Task(id, jobs))));
mapping metodu
Şu satırı dahil ederiz.
import static java.util.stream.Collectors.mapping;
reduce metodu
Stream Sınıfı Terminal Operations yazısına taşıdım.

toCollection metodu
Döndürülen nesne List veya Map değil daha özel bir sınıf olsun istersek şöyle yaparız.
ArrayList<SomeClass> list =
  inputStrings.stream()
    .map(SomeClass::doSomthing)
    .filter((someClazz)->{return someClazz!=null;})
    .collect(Collectors.toCollection(ArrayList::new));
Şöyle yaparız.
CopyOnWriteArrayList<Foo> list =
  fields.stream()
    .distinct()
    .collect(toCollection(CopyOnWriteArrayList::new));
toList metodu
Collectors toList metodu yazısına taşıdım.

toMap metodu
Yeni bir Map döndürür. Nesne için çağrılacak key fonksiyonunu ve value fonksiyonunu tanımlarız. Object sınıfının metodunu kullandık.
Set<Foo> set = ...;
Map<Integer, Foo> map = set.stream()
                           .collect( Collectors.toMap( Object::hashCode, 
                                                       element -> element )
                                   );
Elimizde şöyle bir stream olsun
Map<String, String> input = new HashMap<>();
Bu map'i Map<String,Integer> yapmak isteyelim ve tek sayıları silelim istiyoruz. Şöyle yaparız. Mevcut değerleri kullanmak için Map.Entry sınıfının metodlarını getter olarak kullandık.
Map<String, Integer> output =
input.entrySet().
stream().
map(e -> new AbstractMap.SimpleEntry<>(e.getKey(), Integer.valueOf(e.getValue())))
.filter(e -> e.getValue() % 2 == 0)
.collect(Collectors.toMap(
             Map.Entry::getKey,
             Map.Entry::getValue
         ));
toMap metodu - Merge Function
Elimizde şöyle bir liste olsun.
List<A>{
 name = "abc"
 List<B>{1,2}

 name= "xyz"
 List<B>{3,4}

 name = "abc"
 List<B>{3,5}
}
İsmi aynı olan numaraları birleştirmek isteylim. Yani şöyle bir sonuç istiyoruz.
List<A>{
 name = "abc"
 List<B>{1,2,3,5}

 name="xyz"
 List<B>{3,4}
}
Bunun için toMap metodunun 3 parametreli keyMapper, valueMapper, mergeFunction halini kullanırız. keyMapper name değerini döner. valueMapper a nesnesini döner. mergeFunction aynı name değerine sahip bir nesne bulununca çağrılır. a , b  valueMapper'in döndürdüğü nesne tipindendir. a nesnesinin numaralarına b nesnesinin numaraları eklenir. Şöyle yaparız.
Collection<A> result = list.stream()
         .collect(Collectors.toMap(a -> a.name, a -> a, 
                      (a, b) -> {a.numbers.addAll(b.numbers); return a;}))
         .values();
toSet metodu
Elimizde bir Map olsun
Map<Key, Value> map = ...;
Tüm value nesnelerini bir Set'e doldurmak istersek şöyle yaparız.
Set<Key> keys = map.entrySet().stream()
  .filter(entry -> entry.getValue() == value)
  .map(entry -> entry.getKey())
  .collect(Collectors.toSet());



29 Ekim 2016 Cumartesi

JList Sınıfı

Giriş
Şu satırı dahil ederiz.
import javax.swing.JList;
Liste şeklindeki ekran bileşenidir. Ekranda göstermek için şöyle yaparız.
JList list = ...;
JScrollPane scroll = new JScrollPane (list);
constructor - default
Şöyle yaparız.
JList<String> list = new JList<String>();  
constructor - DefaultListModel
Şöyle yaparız.
DefaultListModel model = new DefaultListModel<String>();
JListString> list = new JList<String>(model);
addListSelectionListener metodu
Şu satırları dahil ederiz.
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
Şöyle yaparız.
list.addListSelectionListener (new ListSelectionListener() {
  public void valueChanged(ListSelectionEvent arg0) { 
    System.out.println("You selected " + list.getSelectedValue());
  }
});
setModel metodu
Şöyle yaparız.
DefaultListModel model = ...;
list.setModel(model);
setPreferredSize metodu
Şöyle yaparız.
list.setPreferredSize (null);