Top 40 Java 8面试问题及答案

@FunctionalInterface
interface MyFunctionalInterface {
    void performAction();
}

public class Main {
    public static void main(String[] args) {
        // Using a lambda expression to implement the abstract method of the functional interface
        MyFunctionalInterface myFunction = () -> System.out.println("Performing custom action");
        myFunction.performAction(); // Output: Performing custom action
    }
}

import java.util.ArrayList;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();

        names.add("John");
        names.add("Alice");
        names.add("Bob");
        names.add("Emily");

        // Method reference to static method
        names.forEach(System.out::println);

        // Method reference to instance method of a particular object
        names.forEach(String::toUpperCase);

        // Method reference to instance method of an arbitrary object of a particular type
        names.sort(String::compareToIgnoreCase);

        // Method reference to constructor
        names.stream()
             .map(String::new)
             .forEach(System.out::println);
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Jane", "Adam", "Eva");

        // Example 1: Using a lambda expression
        Consumer<String> printName = (name) -> System.out.println(name);
        names.forEach(printName);

        // Example 2: Using a method reference
        Consumer<String> printUpperCase = System.out::println;
        names.forEach(printUpperCase.andThen(String::toUpperCase));
    }
}

import java.util.function.Supplier;

public class SupplierExample {
    public static void main(String[] args) {
        // Example 1: Using a lambda expression
        Supplier<String> randomStringSupplier = () -> "Hello, World!";
        System.out.println(randomStringSupplier.get());

        // Example 2: Using a method reference
        Supplier<Double> randomNumberSupplier = Math::random;
        System.out.println(randomNumberSupplier.get());
    }
}

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

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

        // Example 1: Using a lambda expression
        Predicate<Integer> isEven = (number) -> number % 2 == 0;
        List<Integer> evenNumbers = filter(numbers, isEven);
        System.out.println("Even numbers: " + evenNumbers);

        // Example 2: Using a method reference
        Predicate<Integer> isGreaterThanFive = PredicateExample::checkGreaterThanFive;
        List<Integer> greaterThanFiveNumbers = filter(numbers, isGreaterThanFive);
        System.out.println("Numbers greater than five: " + greaterThanFiveNumbers);
    }

    private static List<Integer> filter(List<Integer> numbers, Predicate<Integer> predicate) {
        // Filter the numbers based on the given predicate
        return numbers.stream()
                .filter(predicate)
                .toList();
    }

    private static boolean checkGreaterThanFive(Integer number) {
        return number > 5;
    }
}

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        // Example 1: Convert string to integer
        Function<String, Integer> strToInt = Integer::parseInt;
        int number = strToInt.apply("123");
        System.out.println("Number: " + number);

        // Example 2: Transform a string to uppercase
        Function<String, String> toUpperCase = String::toUpperCase;
        String result = toUpperCase.apply("hello");
        System.out.println("Uppercase string: " + result);
    }
}

import java.util.function.BiFunction;

public class BiFunctionExample {
    public static void main(String[] args) {
        // Example 1: Concatenate two strings
        BiFunction<String, String, String> concat = (s1, s2) -> s1 + s2;
        String result = concat.apply("Hello, ", "World!");
        System.out.println("Concatenated string: " + result);

        // Example 2: Sum two integers
        BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b;
        int total = sum.apply(5, 3);
        System.out.println("Sum: " + total);
    }
}

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

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

        // Sequential Stream
        System.out.println("Sequential Stream:");
        numbers.stream()
                .forEach(System.out::println);

        // Parallel Stream
        System.out.println("Parallel Stream:");
        numbers.parallelStream()
                .forEach(System.out::println);
    }
}

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Stream stream = numbers.stream().filter(n -> n % 2 == 0).map(n -> n * 2);

List names = Arrays.asList("John", "Jane", "Adam", "Eve");
long count = names.stream().filter(name -> name.length() > 3).count();

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

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

        // forEach - prints each element
        numbers.stream()
                .forEach(System.out::println);

        // filter - filters even numbers
        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("Even numbers: " + evenNumbers);

        // map - squares each number
        List<Integer> squaredNumbers = numbers.stream()
                .map(n -> n * n)
                .collect(Collectors.toList());
        System.out.println("Squared numbers: " + squaredNumbers);

        // distinct - removes duplicates
        List<Integer> distinctNumbers = numbers.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("Distinct numbers: " + distinctNumbers);

        // max - finds the maximum number
        Optional<Integer> maxNumber = numbers.stream()
                .max(Integer::compareTo);
        System.out.println("Max number: " + maxNumber.orElse(null));

        // min - finds the minimum number
        Optional<Integer> minNumber = numbers.stream()
                .min(Integer::compareTo);
        System.out.println("Min number: " + minNumber.orElse(null));

        // peek - prints each element before and after mapping
        List<Integer> peekedNumbers = numbers.stream()
                .peek(n -> System.out.println("Before mapping: " + n))
                .map(n -> n * n)
                .peek(n -> System.out.println("After mapping: " + n))
                .collect(Collectors.toList());

        // limit - limits the number of elements
        List<Integer> limitedNumbers = numbers.stream()
                .limit(5)
                .collect(Collectors.toList());
        System.out.println("Limited numbers: " + limitedNumbers);

        // reduce - sums all the numbers
        int sum = numbers.stream()
                .reduce(0, Integer::sum);
        System.out.println("Sum: " + sum);

        // skip - skips the first 5 numbers
        List<Integer> skippedNumbers = numbers.stream()
                .skip(5)
                .collect(Collectors.toList());
        System.out.println("Skipped numbers: " + skippedNumbers);

        // flatMap - flattens nested lists
        List<List<Integer>> nestedLists = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4, 5));
        List<Integer> flattenedList = nestedLists.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());
        System.out.println("Flattened list: " + flattenedList);

        // sorted - sorts the numbers in ascending order
        List<Integer> sortedNumbers = numbers.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println("Sorted numbers: " + sortedNumbers);

        // collect - collects the elements into a new list
        List<Integer> collectedNumbers = numbers.stream()
                .collect(Collectors.toList());
        System.out.println("Collected numbers: " + collectedNumbers);
    }
}

import java.util.stream.IntStream;

public class IntStreamExample {
    public static void main(String[] args) {
        // Create an IntStream from 1 to 5 (inclusive)
        IntStream intStream = IntStream.rangeClosed(1, 5);

        // Print the elements of the IntStream
        intStream.forEach(System.out::println);
    }
}

import java.util.stream.LongStream;

public class LongStreamExample {
    public static void main(String[] args) {
        // Create a LongStream from 1 to 5 (inclusive)
        LongStream longStream = LongStream.rangeClosed(1, 5);

        // Calculate the sum of the LongStream elements
        long sum = longStream.sum();

        // Print the sum
        System.out.println("Sum: " + sum);
    }
}

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

public class CollectorsExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry", "Date", "Apple", "Banana");

        // Example 1: Grouping fruits by their length
        Map<Integer, List<String>> groupedByLength = fruits.stream()
                .collect(Collectors.groupingBy(String::length));
        System.out.println("Grouped by length: " + groupedByLength);

        // Example 2: Partitioning fruits into two groups: odd length and even length
        Map<Boolean, List<String>> partitionedByLength = fruits.stream()
                .collect(Collectors.partitioningBy(fruit -> fruit.length() % 2 == 0));
        System.out.println("Partitioned by length: " + partitionedByLength);

        // Example 3: Counting the occurrences of each fruit
        Map<String, Long> fruitCounts = fruits.stream()
                .collect(Collectors.groupingBy(fruit -> fruit, Collectors.counting()));
        System.out.println("Fruit counts: " + fruitCounts);

        // Example 4: Mapping fruit names to their lengths
        List<Integer> fruitLengths = fruits.stream()
                .collect(Collectors.mapping(String::length, Collectors.toList()));
        System.out.println("Fruit lengths: " + fruitLengths);
    }
}