Core Java Important Concepts for Interview

1.1 Java Different Version Features

1.2 Java 8 Features

Stream Operations

Java 8 Map New Features

1.3 Aggregate (Reduction) Functions in Java 8 Streams

long c = list.stream().count();

int s = list.stream()
    .mapToInt(i -> i)
    .sum();

Optional<Integer> min =
    list.stream().min(Integer::compare);

Optional<Integer> max =
    list.stream().max(Integer::compare);

OptionalDouble avg =
    list.stream()
        .mapToInt(i -> i)
        .average();

int sum =
    list.stream()
        .reduce(0, (a, b) -> a + b);

Optional<Integer> total =
    list.stream()
        .reduce((a, b) -> a + b);

IntSummaryStatistics stats =
    list.stream().collect(
        Collectors.summarizingInt(i -> i)
    );

String joined =
    list.stream().collect(
        Collectors.joining(", ")
    );

list.stream()
    .collect(
        Collectors.groupingBy(
            Function.identity(),
            Collectors.counting()
        )
    );

1.4 Optional

The Optional class in Java 8 is a container object used to contain not-null objects. Optional is part of the java.util package and was introduced to reduce the risk of NullPointerException and provide a better way to handle optional values.

Optional Example

Optional<String> name =
    Optional.of("Srikanth");

name.ifPresent(
    n -> System.out.println(
        n.toUpperCase()
    )
);

String result =
    name.orElse("Default");

System.out.println(result);

Optional<String> emptyName =
    Optional.empty();

String result2 =
    emptyName.orElse("Default");

System.out.println(result2);

When to Use Optional

• As a return type when the result might be absent.
• To replace null checks.

1.5 Lambda Expression

Lambda expressions provide a concise way to implement the abstract method of a functional interface.

Lambda expressions let you write shorter, cleaner, and more expressive code, especially for functional interfaces.

They are extensively used with Streams, Collections, and multithreading.

1.6 Functional Interfaces (SAM)

A functional interface is an interface that contains exactly one abstract method.

These interfaces are used primarily with lambda expressions and method references, enabling you to write cleaner and more concise code.

Function<String, Integer> lengthFunction =
    str -> str.length();

System.out.println(
    lengthFunction.apply("Sree")
);

BiFunction<Integer, Integer, Integer> sum =
    (a, b) -> a + b;

System.out.println(
    sum.apply(5, 3)
);

Consumer<String> consumer =
    name -> System.out.println(
        "Hello, " + name
    );

consumer.accept("Alice");

BiConsumer<String, Integer> print =
    (name, age) ->
        System.out.println(
            name + " is " + age +
            " years old"
        );

print.accept("Bob", 30);

Supplier<String> supplier =
    () -> "Hello from Supplier!";

System.out.println(
    supplier.get()
);

Predicate<String> isLongerThan5 =
    s -> s.length() > 5;

System.out.println(
    isLongerThan5.test("Hello")
);

BiPredicate<String, String> isEqual =
    (a, b) -> a.equalsIgnoreCase(b);

System.out.println(
    isEqual.test("Java", "java")
);

UnaryOperator<String> toUpperCase =
    s -> s.toUpperCase();

System.out.println(
    toUpperCase.apply("hello")
);

BinaryOperator<Integer> multiply =
    (a, b) -> a * b;

System.out.println(
    multiply.apply(4, 5)
);

Predicate Example

Predicate<Integer> isEven =
    number -> number % 2 == 0;

System.out.println(
    "Is 10 even? " +
    isEven.test(10)
);

Function Example

Function<String, Integer> stringLength =
    str -> str.length();

System.out.println(
    "Length of 'Hello': " +
    stringLength.apply("Hello")
);

1.7 Collection Internal Data Structure

1.8 Comparable vs Comparator

1.13.1 Comparator Java 8 Enhancements

Comparator in Java 8 is more powerful. You can use static methods like:

people.sort(
    Comparator.comparing(Person::getAge)
              .thenComparing(Person::getName)
);

people.forEach(
    person ->
        System.out.println(
            person.getName()
        )
);

List<Integer> sortedArrayList =
    al.stream()
      .sorted(Comparator.reverseOrder())
      .collect(Collectors.toList());

int k = 2;

System.out.println(
    sortedArrayList.get(k - 1)
);

1.9 Method References

A method reference is essentially a shorthand notation for calling a method using a lambda expression.

Method references can be used in the context of functional interfaces (interfaces with a single abstract method), commonly used in places where lambda expressions are applicable.

Types of Method References

Method references provide a more concise and expressive way to refer to methods and are especially useful with Java's functional programming features (like Streams). They can simplify your code by replacing lambda expressions where the lambda body is just calling a method.