Java 8 Learnings

1. In Java8, double and sum the number

public class Demo1 {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        System.out.println(
                numbers.stream()
                        .mapToInt(number -> number * 2)
                        .sum());
    }
}

2. Double the first even number greater than 3 from the given list

public class Sample {
    public static boolean isGreaterThan2(int number) {
        return number > 2;
    }

    public static boolean isEven(int number) {
        return number % 2 == 0;
    }

    public static int doubleIt(int number) {
        return number * 2;
    }

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

        //double the first even number greater than 3 from the list

        System.out.println(
                numbers.stream()
                        .filter(Sample::isGreaterThan2)
                        .filter(Sample::isEven)
                        .mapToInt(Sample::doubleIt)
                        .findFirst()
                        .getAsInt()
        );
    }
}

3. Create a collection of people whose name start with B or K and have 3 or 4 letters

public class Demo3 {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Ben", "Brad", "Bill", "Kara", "Sara", "Jil", "Brenda");
        System.out.println(
                names.stream()
                        .filter(name -> name.startsWith("B") || name.startsWith("K"))
                        .filter(name -> name.length() == 3 || name.length() == 4)
                        .collect(Collectors.toList()));
    }
}

4. Separation of concerns

public class SeparationOfConcerns {
    public static int totalValues(List<Integer> numbers, Predicate<Integer> selector) {
        return numbers.stream()
                .filter(selector)
                .mapToInt(value -> value)
                .sum();
    }

    public static void main(String[] args) {
        List<Integer> values = Arrays.asList(1, 2, 3, 4, 5, 6);
        System.out.println(totalValues(values, value -> true));
        System.out.println(totalValues(values, value -> value % 2 == 0));
        System.out.println(totalValues(values, value -> value % 2 != 0));
    }
}

5. Find the names whose length is 5 and make it upper case.

public class Demo4 {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Dory", "Gill", "Bruce", "Nemo", "Darla", "Marlin", "Jacques");
        names.stream()
                .filter(n -> n.length() == 5)
                .map(String::toUpperCase)
                .forEach(System.out::println);
    }
}

6. Square root of 1st and last prime of 100

public class SqrtOf100Prime {
    public static boolean isPrime(int number) {
        return number > 1 && IntStream.range(2, number).noneMatch(index -> number % index == 0);
    }

    public static void main(String[] args) {
        List<Double> sqrtOfFirst100Primes =
                Stream.iterate(1, e -> e + 1)
                        .filter(SqrtOf100Prime::isPrime)
                        .map(Math::sqrt)
                        .limit(100)
                        .collect(Collectors.toList());

        System.out.println(
                String.format("Computer %d values, first is %g, last is %g",
                        sqrtOfFirst100Primes.size(),
                        sqrtOfFirst100Primes.get(0),
                        sqrtOfFirst100Primes.get(sqrtOfFirst100Primes.size() - 1)));
    }
}

7. Compute the sum of Double of 1000 Even numbers

public class Compute {
    static final int MAX = 1000;

    public static int computeSumOfDoubleOf1000EvenFromFunctional(int starting) {
        return Stream.iterate(starting, e -> e + 1)
                .filter(e -> e % 2 == 0)
                .mapToInt(e -> e * 2)
                .limit(MAX)
                .sum();
    }

    public static void main(String[] args) {
        int starting = 33;
        System.out.println(computeSumOfDoubleOf1000EvenFromFunctional(starting));
    }
}

8. Method Reference with different options

public class MethodRefDiffOptions {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        System.out.println(numbers.stream()
                        .map(String::valueOf)
                        .reduce("", String::concat));
    }
}

9. Converting nested list to list in Java 8

public class NestedList {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3);
        List<Integer> list2 = Arrays.asList(4, 5, 6);
        List<Integer> list3 = Arrays.asList(7, 8, 9);

        List<List<Integer>> listofList = Arrays.asList(list1, list2, list3);
        List<Integer> list = listofList.stream().flatMap(e -> e.stream()).collect(Collectors.toList());
        System.out.println(list);
    }
}

10. Converting nested array into list

public class NestedArrayIntoList {
    public static void main(String[] args) {
        String[][] dataArray = new String[][]{ {"a", "b"}, {"c", "d"}, {"e", "f"}, {"g", "h"}}
        List<String> list = Arrays.stream(dataArray).flatMap(e -> Arrays.stream(e)).collect(Collectors.toList());
        System.out.println(list);
    }
}

11. Find the employee whose age > 30 and result should be a list of unique email id.

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

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

@AllArgsConstructor
@NoArgsConstructor
@Data
@Builder
public class Employee {
    private String name;
    private Integer age;
    private String email;
}

class Main {
    public static void main(String[] args) {
        Employee e1 = Employee.builder().name("Ravi").age(30).email("ravi@gmail.com").build();
        Employee e2 = Employee.builder().name("Kavita").age(55).email("kavita@gmail.com").build();
        Employee e3 = Employee.builder().name("Deepak").age(34).email("deepak@gmail.com").build();
        Employee e4 = Employee.builder().name("Parag").age(67).email("parag@gmail.com").build();
        Employee e5 = Employee.builder().name("Harshita").age(88).email("harshita@gmail.com").build();
        Employee e6 = Employee.builder().name("Neha").age(56).email("neha@gmail.com").build();
        Employee e7 = Employee.builder().name("Shrutika").age(39).email("shrutika@gmail.com").build();
        Employee e8 = Employee.builder().name("Ravi").age(32).email("ravi@gmail.com").build();

        //
        List<Employee> employees = List.of(e1, e2, e3, e4, e5, e6, e7, e8);
        List<String> r = employees.stream()
                .filter(e -> e.getAge() > 30)
                .map(e -> e.getEmail())
                .distinct()
                .collect(Collectors.toList());
        System.out.println(r);
    }
}

Output — [kavita@gmail.com, deepak@gmail.com, parag@gmail.com, harshita@gmail.com, neha@gmail.com, shrutika@gmail.com, ravi@gmail.com]

12. Perform Grouping based on Department Name

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

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

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private String name;
    private Integer age;
    private Double salary;
    private Department department;
}

enum Department {
    MARKETING, LEGAL, HR, OPERATIONS;
}

class Main {
    public static void main(String[] args) {
        List<Employee> employeeList = Arrays.asList(
                new Employee("Tom Jones", 45, 12000.00, Department.MARKETING),
                new Employee("Harry Major", 26, 20000.00, Department.LEGAL),
                new Employee("Ethan Hardy", 65, 30000.00, Department.LEGAL),
                new Employee("Nancy Smith", 22, 15000.00, Department.MARKETING),
                new Employee("Catherine Jones", 21, 18000.00, Department.HR),
                new Employee("James Elliot", 58, 24000.00, Department.OPERATIONS),
                new Employee("Frank Anthony", 55, 32000.00, Department.MARKETING),
                new Employee("Michael Reeves", 40, 45000.00, Department.OPERATIONS));

        Map<Department, List<Employee>> grping = employeeList.stream()
            .collect(Collectors.groupingBy(Employee::getDepartment));
        System.out.println(grping);
    }
}

Output —

{OPERATIONS=[Employee(name=James Elliot, age=58, salary=24000.0, department=OPERATIONS), Employee(name=Michael Reeves, age=40, salary=45000.0, department=OPERATIONS)], LEGAL=[Employee(name=Harry Major, age=26, salary=20000.0, department=LEGAL), Employee(name=Ethan Hardy, age=65, salary=30000.0, department=LEGAL)], HR=[Employee(name=Catherine Jones, age=21, salary=18000.0, department=HR)], MARKETING=[Employee(name=Tom Jones, age=45, salary=12000.0, department=MARKETING), Employee(name=Nancy Smith, age=22, salary=15000.0, department=MARKETING), Employee(name=Frank Anthony, age=55, salary=32000.0, department=MARKETING)]}

— — — — —

12. Find the Top 3 salaried employees

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

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

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private String name;
    private Integer age;
    private Double salary;
}

class Main {
    public static void main(String[] args) {
        List<Employee> employeeList = Arrays.asList(
                new Employee("Tom Jones", 45, 15000.00),
                new Employee("Tom Jones", 45, 7000.00),
                new Employee("Ethan Hardy", 65, 8000.00),
                new Employee("Nancy Smith", 22, 10000.00),
                new Employee("Deborah Sprightly", 29, 9000.00));

        List<Employee> names = employeeList.stream()
                .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
                .limit(3)
                .collect(Collectors.toList());
        System.out.println(names);
    }
}

Output:

[Employee(name=Tom Jones, age=45, salary=15000.0), Employee(name=Nancy Smith, age=22, salary=10000.0), Employee(name=Deborah Sprightly, age=29, salary=9000.0)]

— — —

13. Sort the Employee using FirstName and lastName

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

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

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private String firstName;
    private String lastName;
    private Integer age;
}

class Main {
    public static void main(String[] args) {
        List<Employee> employeeList = Arrays.asList(
                new Employee("Tom", "Jones", 30),
                new Employee("Tom", "Kerr", 35),
                new Employee("Ethan", "Hardy", 36),
                new Employee("Nancy", "Smith", 22),
                new Employee("Deborah", "Sprightly", 40));

        List<Employee> employees = employeeList.stream()
                .sorted(Comparator.comparing(Employee::getFirstName).thenComparing(Employee::getLastName).reversed())
                .collect(Collectors.toList());
        System.out.println(employees);
    }
}

[Employee(firstName=Tom, lastName=Kerr, age=35), Employee(firstName=Tom, lastName=Jones, age=30), Employee(firstName=Nancy, lastName=Smith, age=22), Employee(firstName=Ethan, lastName=Hardy, age=36), Employee(firstName=Deborah, lastName=Sprightly, age=40)]