3 Ocak 2019 Perşembe

IntStream Arayüzü

Giriş
Şu satırı dahil ederiz.
import java.util.stream.IntStream;
Stream<T> arayüzünden kalıtır. Kendine özel metodları da mevcuttur.

average metodu
Açıklaması şöyle.
A Stream<T> has no average() method, since the element type T can be any reference type, which doesn't necessarily have a meaning for calculation of the average of the Stream elements.

On the other hand, an IntStream has an average() method, since it has int elements, for which the average operation is well defined.
SummaryStatistics yazısına taşıdım.

boxed metodu
Örnek ver. Sream<Integer> nesnesi döner.

collect metodu
İmzası şöyle. Yani Collector alamaz
<R> R collect(Supplier<R> supplier,
              ObjIntConsumer<R> accumulator,
              BiConsumer<R, R> combiner)
Şu kod derlenmez.
private Map<String, Object> collectArguments() {
  ... 
  return IntStream.range(0, args.length)
        .collect(Collectors.toMap(...));
}
boxed() metodu ile normal Stream sınıfın çevirmek için şöyle yaparız.
return IntStream.range(0, args.length)
                .boxed()
                .collect(Collectors.toMap(...));
Bu collect metodunu kullanmak için şöyle yaparız.
return IntStream.range(0, args.length)
                .collect(HashMap::new,
                         (m,i)->m.put(argNames[i],args[i]),
                         Map::putAll);
findFirst metodu
Stream Search Metodları yazısına taşıdım.

getAsInt metodu
Şöyle yaparız.
int result = IntStream
    .range(100, 10000)
    .filter(i -> ...)
    .findFirst()
    .getAsInt();
iterate metodu - initial element + predicate
Örnek
limit() ile verilen değer kadar iterate edilir. Şöyle yaparız
IntStream.iterate(0, i -> i + 1).limit(5).forEach(val -> ints.add(val));
Aynı şeyi şöyle de yapabiliriz. Ancak bu yöntem i değerini değiştirdiği için makbul değil.
IntStream.iterate(0, i -> ++i).limit(5).forEach(ints::add);
iterate metodu - initial element + has next predicate + next element
Açıklaması şöyle.
first parameter - the initial element;
second parameter - a predicate to apply to elements to determine when the stream must terminate;
third parameter- a function to be applied to the previous element to produce a new element.
Şöyle yaparız. Üçüncü parametre bir önceki iterasyonda kabul edilen değerdir.
int[] seq = IntStream.iterate(0, x -> ..., x -> ...).toArray();
map metodu
int döner. Açıklaması şöyle
map of IntStream can only map an int value to another int value. It accepts an IntUnaryOperator (which accepts an int and returns an int) as the mapper function, and returns an IntStream.
Örnek
Aslında bu kod skip(), limit() gibi bir çok metod için de örnek olabilir.
System.out.println(Arrays.toString(
IntStream.rangeClosed(1, 20).skip(9).limit(10).map((new IntUnaryOperator() {
        @Override
        public int applyAsInt(int operand) {
            return operand - 1;
        }
}).andThen(new IntUnaryOperator() {
        @Override
        public int applyAsInt(int operand) {
            return operand * 2;
        }
})).toArray()));
mapToDouble metodu
Şöyle yaparız.
double[] sequence = IntStream.range(200000, 400000)
  .mapToDouble( i -> i * 0.001).toArray();
mapToObj metodu
int tipini başka bşr tipe cast etmek için kullanılır.
Örnek
Şöyle yaparız
var s = IntStream.rangeClosed(1,5).mapToObj(String::valueOf).collect(Collectors.toList());
Örnek
Şöyle bir listemiz olsun.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
Bu listeyi stream'e çevirirsek IntStream elde ederiz. int tipini Int'e çevirmek için de mapToObj kullanmamız gerekir. Örnek
String commaSeparatedNumbers = Arrays.stream(numbers)
    .mapToObj(i -> ((Integer) i).toString()) //i is an int, not an Integer
    .collect(Collectors.joining(", "));
range metodu
Factory metodudur. IntSream nesnesini yaratir.
Örnek 0 ile 10 arasındaki sayıların toplamını bulur. Reduce ile range() ile elde edilen her yeni eleman add işlemine sokularak toplama eklenir. reduce işlemi 0'dan başlar.
IntBinaryOperator add = (a, b) -> a + b;
int sum2 = IntStream.range(0, 10)
                    .reduce(0, add);
Bir başka örnekte elimizde bir items listesi var. Bu listedeki her elemanı bulunduğu indekse göre bir Map<Integer,Item> veri yapısına doldurmak istiyoruz. range ile 0-size() arasında sayı üretiriz. Bu sayı Integer nesnesine çevrilir. Daha sonra collect() metodu ile Map'e çevrilir.
Map<Integer,Item> map = 
    IntStream.range(0,items.size())
             .boxed()
             .collect(Collectors.toMap (i -> i, i -> items.get(i)));
rangeClosed metodu
Şöyle yaparız.
IntStream.rangeClosed('A', 'Z')
  .mapToObj(a -> (char) a)
  .collect(...)
  .forEach(System.out::print); 
sorted metodu
Açıklaması şöyle.
Returns a stream consisting of the elements of this stream in sorted order.
Stream sınıfı gibi comparator almaz. Şöyle yaparız.
Arrays.stream(intArray)
      .mapToInt(x->x)
      .sorted()
      .toArray();
toArray metodu
Şöyle yaparız.
int[] arr = IntStream.range(0, 10).map(i -> i*2).toArray();



Hiç yorum yok:

Yorum Gönder