Stream API

Intermediate or non-terminal operations: filter(),  map(),  flatMap(),  distinct(),  limit().

Terminal operations: collect(), count(), forEach(), min(), max(), reduce(), toArray(), toList().

1. Filter

->

package az.ingress.filterdomes;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Filterdemo1 {
    public static void main(String[] args) {
        List<Integer> numbersList = Arrays.asList(10, 15, 20, 25, 30);
        List<Integer> evenNumbersList = new ArrayList<>();
        // without using streams
        for (int n : numbersList) {
            if (n % 2 == 0)
                evenNumbersList.add(n);
        }
        // with streams
        evenNumbersList = numbersList.stream()
                .filter(a -> a % 2 == 0).toList();

        numbersList.stream()
                .filter(n -> n % 2 == 0)
                .forEach(System.out::println);
    }
}


->

package az.ingress.filterdomes;

import java.util.Arrays;
import java.util.List;

public class Filterdemo2 {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Melisandre", "Sansa", "Jon", "Daenerys", "Joffery");
        names.stream()
                .filter(s -> s.length() > 6 && s.length() < 8)
                .forEach(System.out::println);
    }
}


->

package az.ingress.filterdomes;

import java.util.Arrays;
import java.util.List;

public class Filterdemo3 {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("cup", null, "forest", "sky", "book", null, "theatre");
        words.stream()
                .filter(n -> n != null)
                .forEach(System.out::println);
    }
}


->

package az.ingress.filterdomes;

public class Product {
    public int id;
    public String name;
    public double price;

    public Product(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}
package az.ingress.filterdomes;

import java.util.Arrays;
import java.util.List;

public class Filterdemo4 {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
                new Product(1, "HP Laptop", 25000),
                new Product(2, "Dell Laptop", 30000),
                new Product(3, "Lenovo Laptop", 28000),
                new Product(4, "Sony Laptop", 23000),
                new Product(5, "Apple Laptop", 90000)
        );

        products.stream()
                .filter(a -> a.price > 25000)
                .forEach(System.out::println);
    }
}


2.Map

->

package az.ingress.mapdemos;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Mapdemo1 {
    public static void main(String[] args) {
        List<String> vehicles = Arrays.asList("bus", "car", "bicycle", "flight", "train");
        List<String> vehiclesUpperCase = new ArrayList<>();
        // without streams
        for(String name: vehicles) {
            vehiclesUpperCase.add(name.toUpperCase());
        }
        // with streams
        vehiclesUpperCase = vehicles.stream()
                .map(a -> a.toUpperCase())
                .collect(Collectors.toList());
    }
}


-> 

package az.ingress.mapdemos;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Mapdemo2 {
    public static void main(String[] args) {
        List<String> vehicles = Arrays.asList("bus", "car", "bicycle", "flight", "train");
        vehicles.stream()
                .map(a -> a.length())
                .forEach(System.out::println);
    }
}


->

package az.ingress.mapdemos;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Mapdemo3 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(2, 3, 4, 5);
        List<Integer> collect = list.stream()
                .map(a -> a.intValue() * a.intValue())
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}


->

package az.ingress.mapdemos;

public class Employee {
    public int id;
    public String name;
    public int salary;

    public Employee(int id, String name, int salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }
}
package az.ingress.mapdemos;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterMapdemo4 {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
                new Employee(1, "Alex", 10000),
                new Employee(2, "Brian", 20000),
                new Employee(3, "Charles", 30000),
                new Employee(4, "David", 40000),
                new Employee(5, "Edward", 50000)
        );
        List<Integer> collect = employees.stream()
                .filter(e -> e.salary > 20000)
                .map(e -> e.salary)
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}

 

3. FlatMap

->

package az.ingress.flatmapdemos;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Demo1 {
    public static void main(String[] args) {
        List<List<Integer>> list = Arrays.asList(
                Arrays.asList(1, 2),
                Arrays.asList(3, 4),
                Arrays.asList(5, 6)
        );

        list.stream()
                .flatMap(x -> x.stream())
                .forEach(System.out::println);

        list.stream()
                .flatMap(x -> x.stream().map(a -> a + 5))
                .forEach(System.out::println);
    }
}


-> 

package az.ingress.flatmapdemos;

import java.util.Arrays;
import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        List<List<String>> list = Arrays.asList(
                Arrays.asList("Scott", "David", "John"),
                Arrays.asList("Mary", "Luna", "Tom"),
                Arrays.asList("Ken", "Jony", "Kitty")
        );
        // without stream
        for(List<String> s : list) {
            for(String ss : s) {
                System.out.println(ss);
            }
        }
        // with streams
        list.stream()
                .flatMap(s -> s.stream())
                .forEach(System.out::println);
    }
}


->

package org.example;

public class Student {
    public String name;
    public int id;
    public char grade;

    public Student() {
    }

    public Student(String name, int id, char grade) {
        this.name = name;
        this.id = id;
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Student{name='%s', id=%d, grade=%s}"
                .formatted(name, id, grade);
    }
}
package org.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<List<Student>> lists = Arrays.asList(
                Arrays.asList(
                        new Student("Smith", 101, 'A'),
                        new Student("John", 102, 'B'),
                        new Student("Kennedy", 103, 'C')
                ),
                Arrays.asList(
                        new Student("Scott", 104, 'A'),
                        new Student("Mary", 105, 'B'),
                        new Student("Kitty", 106, 'C')
                )
        );
        lists.stream()
                .flatMap(l -> l.stream())
                .map(s -> s.name)
                .forEach(System.out::println);
    }
}


4. Distinct

->

package org.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("bus", "car", "cycle", "car", "car", "bike");
        List<String> distinct = list.stream()
                .distinct().toList();
        System.out.println(distinct);
    }
}


5. Count

->

package org.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("bus", "car", "cycle", "car", "car", "bike");
        long count = list.stream().count();
        long count1 = list.stream().distinct().count();
        System.out.println(count);
        System.out.println(count1);
    }
}


6. Limit and skip

->

package org.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("bus", "car", "cycle", "car", "car", "bike");
        List<String> collect = list.stream().limit(3).toList();
        System.out.println(collect);
    }
}
package org.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.stream().skip(3).collect(Collectors.toList()).forEach(System.out::println);
    }
}


7. Min and Max

-> 

package org.example;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Optional<Integer> min = list.stream().min((a, b) -> a.compareTo(b));
        System.out.println(min.get());
    }
}
package org.example;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Optional<Integer> min = list.stream().max((a, b) -> a.compareTo(b));
        System.out.println(min.get());
    }
}


8. Reduce

->

package org.example;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "1", "2", "3");
        Optional<String> reduce = list.stream().reduce((value, combinedValue) -> {
            return value + combinedValue;
        });
        System.out.println(reduce.get());
    }
}


9. Sorted

-> 

package org.example;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(2, 4, 1, 3, 7, 5, 9);
        list.stream().sorted().forEach(System.out::print);
        System.out.println();
        list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::print);
    }
}


10. anyMatch(), allMatch(), noneMatch()

->

package org.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "alfa", "accent", "attract");
        System.out.println(list.stream().anyMatch(a -> a.equals("apple")));
        System.out.println(list.stream().allMatch(a -> a.startsWith("a")));
        System.out.println(list.stream().noneMatch(a -> a.endsWith("ac")));
    }
}


11. findAny(), findFirst()

->

package org.example;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "alfa", "accent", "attract");
        Optional<String> first = list.stream().findFirst();
        System.out.println(first.get());
        Optional<String> any = list.stream().findAny();
        System.out.println(any.get());
    }
}


12. Concat

-> 

package org.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> animal1 = Arrays.asList("dog", "cat");
        List<String> animal2 = Arrays.asList("parrot", "snake");
        Stream<String> stream1 = animal1.stream();
        Stream<String> stream2 = animal2.stream();
        Stream<String> concat = Stream.concat(stream1, stream2);
    }
}


13. Parallel stream

-> 

package org.example;

public class Student {
    public String name;
    public int score;

    public Student() {
    }

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{name='%s', score=%d}"
                .formatted(name, score);
    }
}
package org.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Student> list = Arrays.asList(
                new Student("David", 82),
                new Student("Bob", 90),
                new Student("John", 65),
                new Student("Kennedy", 55),
                new Student("Eric", 85),
                new Student("Smith", 88),
                new Student("Scott", 50)
        );
        list.parallelStream()
                .filter(s -> s.score >= 80)
                .limit(3)
                .forEach(System.out::println);
    }
}



----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------



Комментарии

Отправить комментарий

Популярные сообщения из этого блога

Lesson1: JDK, JVM, JRE

Изображение
1. Compiler - takes the entire programming code written in high language and translates the whole of it into machine code at once. After this process the an executable file will be ready to run. The translation takes some times to be done, but after that execution is so fast. 2. Interpreter - takes each single instructions of the code translates it and then executes it on its own. The translation step is before the program runs is fast, but execution is slow. JDK = JRE + development tools JRE = JVM + library class JDK -> Java Development Kit. A kit which provides the environment to develop and execute (run) Java program. JRE -> Java Runtime Environment. Provides environment to only run. JVM -> Java Virtual Machine f * Compiled: Fortran, C, C++, Pascal, Haskell, Rust, Go * Interpreted: JavaScript, PHP, Python, Ruby Java both compiled and interpreted language. Terminalda : javac Main.java yazdiqda, source fayli(.java) bytecode(.class) faylina cevirir. Terminalda: java Main (bu z
Далее...

SE_21_Lesson_11: Inheritance, Polymorphism

->  instanceof anlayishi, misallarla izahi   package org.example.lesson_13 ; public class Ulubaba { public String ad ; public String soyad ; public Integer yash ; public void odunDogramaq () { System . out .println( "Ulubaba 50 kq odunu 1 saata dograyir" ) ; } } package org.example.lesson_13 ; public class Baba extends Ulubaba { public String hobbi ; public void otBicmek () { System . out .println( "Baba 1 hektar otu 1 gune bicir" ) ; } } package org.example.lesson_13 ; public class Main { public static void main ( String [] args ) { Baba baba = new Baba() ; System . out .println( baba instanceof Ulubaba ) ; System . out .println( baba instanceof Object ) ; } } -> Upcasting package org.example.lesson_13 ; public class Main { public static void main ( String [] args ) { Ulubaba u = new Baba() ; } } -> Downcasting Problemsiz situasiya: package org.example.lesson_13
Далее...

SE_21_Lesson_9: Initialization Blocks, Wrapper types, String class

Изображение
-> static block: package org.example.test3 ; public class Blocks { static { System . out .println( "In static block" ) ; } public static void method () { System . out .println( "In static method" ) ; } } package org.example.test3 ; public class Main { public static void main ( String [] args ) { Blocks . method () ; } } -> Class.forName() metodunu ishe salmaq: package org.example.test3 ; public class Blocks { static { System . out .println( "In static block" ) ; } } package org.example.test3 ; public class Main { public static void main ( String [] args ) throws Exception { Class . forName ( "org.example.test3.Blocks" ) ; } } -> non-static (instance) block: package org.example.test3 ; public class Blocks { static { System . out .println( "in static block" ) ; } { System . out .println( "in non static (instance) block
Далее...