31 Temmuz 2017 Pazartesi

super Anahtar Kelimesi

Giriş
super() çağrısı yapılmasa bile derleyici bizim için otomatik yapar.

super ve this
super ve this aynı constructor içinde kullanılamaz. Şu kod derlenmez.
class Point {

  private int x, y;

  public Point(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public Point() {
    super();
    this(0, 0);
  }
}

Period Sınıfı

Giriş
Açıklaması şöyle
A date based amount of time e.g. 5 days.
Period sınıfı, Duration sınıfının aksine java.lang.Comparable arayüzünü gerçekleştirmez. Period artık yıl, yaz saati gibi şeyleri hesaba katar.

Kullanım
ofX() metodu ile yaratılan period nesnesine plus() çağrısı ile diğer süreler eklenir. Şöyle yaparız.
Period.ofYears(1).plus(Period.ofWeeks(1));
of metodları sürekli yeni nesne ürettiği için 1 yıl 1 hafta yaratmak için şu kod yanlış. Elimize sadece 1 hafta geçer.
Period wrong = Period.ofYears(1).ofWeeks(1);
ofWeeks metodu
Açıklaması şöyle
The resulting period will be day-based, with the amount of days equal to the number of weeks multiplied by 7. The years and months units will be zero.
Şöyle yaparız.
Period p = Period.ofWeeks(3);
ofYears metodu
Şöyle yaparız.
Period p = Period.ofYears(1);
withDays metodu
Şöyle yaparız. 3 ay 2 gün elde ederiz.
Period p = Period.ofMonths(3);
p = p.withDays(2);
Şu kullanım yanlış.
Period p = Period.ofWeeks(3);
p = p.withDays(2);

Collector Arayüzü

Giriş
Java 8 ile gelen Stream kütüphanesindeki collect() metodu içine bir Collector alır.

Arayüz Parametreleri
Collector arayüzü şöyle tanımlıdır. T reduction işlemine giren nesneyi, A işlem sonucunda çıkan biriktirilmiş nesneyi (accumulation type), R reduction işleminin sonucunu belirtir.
public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    BinaryOperator<A> combiner();
    Function<A, R> finisher();
}
of metodu - supplier + accumulator + combiner
Şöyle yaparız. İlk parametre Supplier, ikinci parametre Accumulator, üçüncü parametre Combiner nesneleridir.
Collector<Foo, MyResult, MyResult> MyCollector = Collector.of(
  () -> Foo::new,
  (a, p) -> { //a accumulation Type , p reduction işlemine giren nesne
    ...
  }, (r1, r2) -> { //r1 combiner r2 yeni accumulator
    ...;
});
Bu Collector şöyle kullanılır.
Map<Date, MyResult> results = stream().collect
  (groupingBy (Foo::getDate, MyCollector));
of metodu - supplier + accumulator + combiner - finisher
Şöyle yaparız.
List<String> result = IntStream.of(1, 2, 3, 4, 5, 12, 13, 14, 19)
  .boxed()
  .collect(Collector.of(
    () -> {
      List<List<Integer>> list = new ArrayList<>();
      list.add(new ArrayList<>());
      return list;
    },
    (list, x) -> {
      List<Integer> inner = list.get(list.size() - 1);
        if (inner.size() == 0) {
          inner.add(x);
        } else {
          int lastElement = inner.get(inner.size() - 1);
          if (lastElement == x - 1) {
            inner.add(x);
          } else {
            List<Integer> oneMore = new ArrayList<>();
            oneMore.add(x);
            list.add(oneMore);
          }
        }
      },
      (left, right) -> {
        throw new IllegalArgumentException("No parallel!");
      },
      list -> {
      
        return list.stream()
          .map(inner -> {
            if (inner.size() > 1) {
              return inner.get(0) + "-" + inner.get(inner.size() - 1);
            }
            return "" + inner.get(0);
            }).collect(Collectors.toList());
}));