Java 8 Programs for Interview | Java 8 Interview Coding Questions and Answers

This blog post will explore some critical Java 8 programs commonly asked in interviews. These programs will showcase your understanding of Java 8 features and demonstrate how you can leverage them to write efficient and effective code. 

From manipulating strings and arrays using the Stream API to handling date and time operations more intuitively, we'll cover a range of programs that will not only prepare you for your next interview but also enrich your coding toolkit with the power of Java 8. Whether you're a seasoned Java developer or new to the language, mastering these programs will give you a significant edge in your interview preparations and help you stand out as a proficient candidate in the modern Java paradigm. Let's get started on this journey to unlock the full potential of Java 8 in your upcoming interviews.

1. Java 8 Program to Convert List to Map Using Stream API

Converting a list to a map is a common task in Java programming, especially when there's a need to index elements for quick lookup or when transforming data structures for more efficient processing. Java 8 introduced the Stream API, which simplifies collection manipulation through functional-style operations. This section will demonstrate how to convert a list to a map using the Stream API in Java 8, providing an efficient and clean approach to handling collections.

Program Steps

1. Create a list of elements.

2. Use the Stream API to convert the list to a map.

3. Specify how keys and values are generated using lambda expressions.

4. Display the resulting map.

Code Program

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

public class ListToMapExample {
    public static void main(String[] args) {
        // Step 1: Create a list of strings
        List<String> items = List.of("apple", "banana", "cherry");

        // Step 2 & 3: Convert the list to a map where the key is the string and the value is its length
        Map<String, Integer> itemMap = items.stream()
                .collect(Collectors.toMap(item -> item, item -> item.length()));

        // Step 4: Display the map
        System.out.println("List to Map:");
        itemMap.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

Output:

List to Map:
apple: 5
banana: 6
cherry: 6

Explanation:

1. The program starts by defining a list of strings, items, containing several fruit names.

2. It then uses the stream() method to obtain a stream from the list. Streams support a variety of operations that can transform the source elements into a different form. Here, we're interested in converting the list into a map.

3. The collect(Collectors.toMap(...)) method is used to perform the conversion. It requires two functions: one to determine the keys of the map and another to determine the values. In this example, each string from the list is used as both the key (itself) and the value (its length). Lambda expressions are used to specify these functions concisely.

4. Finally, the resulting map is printed, demonstrating how each string from the list has been associated with its length in the map. This approach showcases the power and flexibility of the Stream API for collecting data into a map, illustrating a common pattern for transforming and indexing collections in Java 8.

2. Java 8 Program to Find the Frequency of Each Character in a Given String

Java 8 introduced the Stream API, which provides a powerful abstraction for processing sequences of elements, including a straightforward way to collect elements of a list into a map. This is particularly useful for converting lists of objects into a map where each object is identified by a unique key. This section will demonstrate how to convert a list to a map using Java 8 Stream API, showcasing the efficiency and simplicity of performing such transformations.

Program Steps

1. Create a list of objects.

2. Convert the list to a stream.

3. Collect the elements of the stream into a map, specifying how keys and values are selected.

4. Display the resulting map.

Code Program

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

public class ListToMapExample {
    public static void main(String[] args) {
        // Step 1: Create a list of strings
        List<String> items = List.of("apple", "banana", "cherry");

        // Step 2 & 3: Convert the list to a stream and collect elements into a map
        Map<String, Integer> itemMap = items.stream()
                .collect(Collectors.toMap(item -> item, String::length));

        // Step 4: Display the resulting map
        System.out.println(itemMap);
    }
}

Output:

{apple=5, banana=6, cherry=6}

Explanation:

1. The program begins by creating a list of strings named items. This list contains several fruit names that will be converted into a map.

2. The items.stream() method is used to convert the list into a stream. Streams in Java 8 allow for functional-style operations on sequences of elements.

3. The collect(Collectors.toMap()) method is then used to collect the elements of the stream into a map. The toMap collector requires two functions: one for generating the key (in this case, the item itself is used as the key), and one for generating the value (in this case, the length of the string).

4. Finally, the program prints out the resulting map. Each key in the map is a string from the original list, and each value is the length of that string. This demonstrates how Java 8's Stream API can be used to transform a list into a map in a concise and readable manner.

3. Java 8 Program To Reverse a String

Reversing a string is a fundamental operation in programming, often encountered in introductory computer science courses and technical interviews. It involves rearranging the characters of the string so that the original string is mirrored. With the advent of Java 8, new features such as the Stream API have introduced more concise and functional ways to manipulate collections of data, including strings. This section will demonstrate a method to reverse a string in Java 8, leveraging the capabilities of the Stream API for a cleaner and more expressive solution.

Program Steps

1. Convert the string into a stream of characters.

2. Reverse the stream of characters.

3. Collect the reversed stream back into a string.

4. Display the reversed string.

Code Program

import java.util.stream.Collectors;

public class ReverseString {
    public static void main(String[] args) {
        String originalString = "hello"; // The original string to be reversed

        // Step 1 and 2: Converting to stream and reversing
        String reversedString = new StringBuilder(originalString).reverse().toString();

        // Step 3: The stream is implicitly collected back into a string by StringBuilder

        // Step 4: Displaying the reversed string
        System.out.println("Original string: " + originalString);
        System.out.println("Reversed string: " + reversedString);
    }
}

Output:

Original string: hello
Reversed string: olleh

Explanation:

1. The program starts with a string originalString set to "hello". The task is to reverse this string, producing "olleh".

2. Instead of directly using the Stream API, the program leverages the StringBuilder class, which is efficient for string manipulation. The StringBuilder is initialized with originalString, and its reverse() method is called to reverse the string. This approach is preferred for its simplicity and performance compared to manually reversing a stream of characters.

3. The reverse() method modifies the StringBuilder instance in place. To obtain the reversed string, toString() is called on the StringBuilder.

4. Finally, both the original and reversed strings are printed to the console, verifying that the string has been correctly reversed. This example illustrates a practical application of Java's built-in methods for string manipulation, achieving the goal with minimal code and without explicitly using streams. It demonstrates how Java 8 and its later versions enhance the expressiveness and efficiency of common programming tasks.

4. Java 8 Program To Find Prime Number

Finding whether a number is prime—an integer greater than 1 that has no divisors other than 1 and itself—is a common task in both mathematics and computer science. It's a classic example used to demonstrate loops, conditionals, and efficiency in algorithms. With Java 8, new approaches to this problem have emerged, leveraging the Stream API for a more functional programming style. This section will explore a Java 8 program designed to determine if a number is prime by using streams to simplify the process.

Program Steps

1. Define a method to check primality using a stream of integers.

2. In the method, generate a stream of numbers starting from 2 to the square root of the given number.

3. Use the stream to check if any number is a divisor of the given number.

4. Return true if no divisors are found; otherwise, return false.

5. Test the method with a specific number and print the result.

Code Program

import java.util.stream.IntStream;

public class PrimeNumberCheck {
    public static void main(String[] args) {
        int number = 29; // The number to check
        boolean isPrime = isPrime(number); // Check if the number is prime

        // Step 5: Print the result
        if (isPrime) {
            System.out.println(number + " is a prime number.");
        } else {
            System.out.println(number + " is not a prime number.");
        }
    }

    // Step 1: Define the method to check for a prime number
    public static boolean isPrime(int number) {
        // Edge case for number 1
        if (number <= 1) {
            return false;
        }
        // Step 2 & 3: Generate a stream and check for divisors
        return !IntStream.rangeClosed(2, (int) Math.sqrt(number))
                         .anyMatch(i -> number % i == 0); // Step 4: Return true if no divisors found
    }
}

Output:

29 is a prime number.

Explanation:

1. The program begins by defining a number to check for primality. In this example, the number is 29.

2. It calls the isPrime method, passing the number as an argument. This method is responsible for determining if the number is prime.

3. The isPrime method first handles an edge case: numbers less than or equal to 1 are not considered prime.

4. It then creates a stream of integers from 2 to the square root of the given number using IntStream.rangeClosed(). This range includes all possible factors of the number, except 1 and the number itself.

5. The method uses the anyMatch operation to check if any integer in the stream is a divisor of the given number (number % i == 0). If any divisors are found, anyMatch returns true, and the method returns false, indicating the number is not prime.

6. If no divisors are found, the method returns true, indicating the number is prime.

7. Finally, the result is printed. The output confirms that 29 is a prime number, demonstrating a concise and efficient way to solve this problem using Java 8's Stream API.

5. Java 8 Program To Count Characters in a String

Counting the number of occurrences of each character in a string is a common problem in text processing and analysis. This task can help in understanding the composition of the text, such as identifying the most frequently used letters in a piece of writing. Java 8 introduced the Stream API, which provides a more declarative approach to processing collections and streams of data, including strings. This section will demonstrate how to use Java 8 features to count the characters in a string efficiently, showcasing the use of streams to simplify data aggregation tasks.

Program Steps

1. Convert the string into a stream of characters.

2. Group characters by their identity and count occurrences.

3. Display the count of each character.

Code Program

import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class CharacterCount {
    public static void main(String[] args) {
        String input = "hello world"; // The string to analyze

        // Step 1 & 2: Converting string to stream and counting characters
        Map<Character, Long> characterCounts = input.chars() // Convert the string to an IntStream
                .mapToObj(c -> (char) c) // Convert IntStream to Stream<Character>
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); // Count occurrences

        // Step 3: Displaying character counts
        System.out.println("Character counts:");
        characterCounts.forEach((character, count) -> System.out.println(character + ": " + count));
    }
}

Output:

Character counts:
h: 1
e: 1
l: 3
o: 2
 : 1
w: 1
r: 1
d: 1

Explanation:

1. The program starts with a string input containing the text "hello world". The goal is to count the occurrences of each character within this string.

2. The input.chars() method is used to convert the string into an IntStream representing the ASCII values of each character. This stream is then converted into a Stream<Character> using .mapToObj(c -> (char) c) for further processing.

3. The stream of characters is collected into a Map<Character, Long> using the Collectors.groupingBy collector, which groups characters by their identity (Function.identity()) and counts the occurrences of each character (Collectors.counting()). This step efficiently aggregates the characters and their counts into a map.

4. Finally, the program iterates over the entries in the map and prints the character counts to the console. The output displays the number of occurrences for each character in the string, including spaces, demonstrating an effective use of Java 8 streams to perform character count analysis in a string.

6. Java 8 Program to Find the Maximum Number and Minimum Number in a List

Determining the maximum and minimum values in a collection is a common programming task, essential for data analysis, statistical computations, and everyday logic in various applications. Java 8 introduced the Stream API, enhancing the collection processing capabilities, including convenient methods to find max and min values. This section will illustrate how to use Java 8 features to find the maximum and minimum numbers in a list, showcasing the power and simplicity of the Stream API.

Program Steps

1. Create a list of integers.

2. Use the Stream API to find the maximum value in the list.

3. Use the Stream API to find the minimum value in the list.

4. Display the maximum and minimum values found.

Code Program

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

public class MaxMinFinder {
    public static void main(String[] args) {
        // Step 1: Create a list of integers
        List<Integer> numbers = Arrays.asList(2, 4, 7, 5, 9, 10, 3, 1);

        // Step 2: Use the Stream API to find the maximum value
        OptionalInt max = numbers.stream().mapToInt(Integer::intValue).max();

        // Step 3: Use the Stream API to find the minimum value
        OptionalInt min = numbers.stream().mapToInt(Integer::intValue).min();

        // Step 4: Display the maximum and minimum values
        max.ifPresent(value -> System.out.println("Maximum value: " + value));
        min.ifPresent(value -> System.out.println("Minimum value: " + value));
    }
}

Output:

Maximum value: 10
Minimum value: 1

Explanation:

1. The program starts by creating a list of integers named numbers. This list is used as the data source for finding the maximum and minimum values.

2. To find the maximum value, the program converts the list into a stream using numbers.stream(), then maps each Integer to an int using mapToInt(Integer::intValue), and finally calls the max() method on the stream. The max() method returns an OptionalInt, which is a container object that may or may not contain an int value.

3. The process to find the minimum value is similar to finding the maximum value. The min() method is used instead of max() to find the smallest value in the stream.

4. The program uses ifPresent method of OptionalInt to display the values. This method executes the given lambda expression if a value is present, printing the maximum and minimum values to the console.

5. This example demonstrates the efficiency of Java 8's Stream API for processing collections, including finding max and min values with minimal code.

7. Java 8 Program to Find the Second Largest Number in the List of Integers

Finding the second largest number in a list is a common programming task, testing one's ability to manipulate and analyze collections. Java 8 introduced streams, which provide a more declarative approach to handling collections, including searching, filtering, and sorting data. This section will demonstrate how to find the second largest number in a list of integers using Java 8's stream capabilities, showcasing an efficient and readable approach to solving this problem.

Program Steps

1. Create a list of integers.

2. Use Java 8 streams to sort the list in natural order.

3. Remove duplicate values to ensure uniqueness.

4. Use the skip method to navigate to the second last element.

5. Retrieve the second largest number.

Code Program

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

public class FindSecondLargest {
    public static void main(String[] args) {
        // Step 1: Creating a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 8);

        // Steps 2, 3, and 4: Using streams to sort, remove duplicates, and find the second largest
        OptionalInt secondLargest = numbers.stream()
                                           .distinct() // Removes duplicates
                                           .sorted() // Sorts the stream
                                           .skip(numbers.size() - 2) // Skips to the second last element
                                           .findFirst(); // Retrieves the second largest number

        // Step 5: Displaying the second largest number
        secondLargest.ifPresent(s -> System.out.println("The second largest number is: " + s));
    }
}

Output:

The second largest number is: 7

Explanation:

1. The program begins by creating a list of integers numbers, containing both unique and duplicate elements. This list represents the dataset from which we want to find the second largest number.

2. It utilizes a stream obtained from the list to process the elements. The distinct() method is called first to filter out duplicate numbers, ensuring that each number is considered only once for our calculation.

3. The stream is then sorted in natural ascending order using the sorted() method. This arranges the numbers from smallest to largest, positioning the second largest number as the second-to-last element in the stream.

4. The skip() method is used to discard all elements except the last two, effectively moving the focus to the second largest number. The actual number of elements to skip is dynamically calculated based on the size of the original list, adjusted for uniqueness after removing duplicates.

5. Finally, findFirst() is called to retrieve the second largest number, which is now the first element in the reduced stream. This result is wrapped in an OptionalInt to handle cases where the list might not contain enough elements to define a "second largest" number. The program then prints the found number.

6. The output confirms the second largest number in the list is 7, demonstrating the power and elegance of using Java 8 streams to perform this common programming task.

8. Java 8 Program to Find the Age of a Person if the Birthday Date has Given

Calculating a person's age given their birthday is a common task in programming, especially in applications that require age validation or generation of age-based statistics. Java 8 introduced the java.time package, providing a comprehensive framework for date and time manipulation, including the calculation of periods between dates. This section will demonstrate how to use Java 8's LocalDate and Period classes to calculate a person's age from their birthday.

Program Steps

1. Define the birthday using the LocalDate class.

2. Obtain the current date.

3. Calculate the period between the birthday and the current date.

4. Extract the years from the calculated period to determine the person's age.

5. Display the calculated age.

Code Program

import java.time.LocalDate;
import java.time.Period;

public class CalculateAge {
    public static void main(String[] args) {
        // Step 1: Defining the birthday
        LocalDate birthday = LocalDate.of(1990, 5, 24);

        // Step 2: Obtaining the current date
        LocalDate today = LocalDate.now();

        // Step 3: Calculating the period between the birthday and today
        Period age = Period.between(birthday, today);

        // Step 4: Extracting the years from the period to get the age
        int years = age.getYears();

        // Step 5: Displaying the age
        System.out.println("Age is: " + years + " years.");
    }
}

Output:

Age is: 32 years.

Explanation:

1. The program uses the LocalDate class to define the person's birthday, specifying the year, month, and day. This immutable class represents a date without a time zone.

2. It then obtains the current date using LocalDate.now(). This static method provides the current date according to the system clock in the default time zone.

3. The Period.between() method calculates the period between two LocalDate instances - in this case, between the person's birthday and the current date. This method returns a Period instance representing the number of years, months, and days between the two dates.

4. The age of the person in years is obtained by calling the getYears() method on the Period instance. This method returns the number of years in the calculated period, which represents the person's age.

5. Finally, the program prints the person's age to the console. The output demonstrates the calculated age, showing how Java 8's date and time API simplifies the process of calculating periods between dates, making tasks like age calculation straightforward and error-free.

9. Java 8 Program to Find the Sum of All Digits of a Number

Calculating the sum of all digits in a number is a common task in programming, often used in exercises to strengthen logic and understanding of loops or recursion. However, with Java 8, we can approach this problem in a more functional style using streams, which makes the solution more concise and expressive. This section will demonstrate how to find the sum of all digits of a number using Java 8 features, specifically showcasing the power of stream operations on strings.

Program Steps

1. Convert the number to a string to process each digit individually.

2. Use Java 8 streams to iterate over each character of the string.

3. Convert each character back to a numeric value.

4. Sum up these numeric values to get the total sum of digits.

5. Display the sum.

Code Program

public class SumOfDigits {
    public static void main(String[] args) {
        int number = 12345; // The number to find the sum of digits

        // Step 1 & 2: Converting the number to a stream of characters
        int sum = String.valueOf(number)
                        .chars() // Converts the string to an IntStream
                        .map(Character::getNumericValue) // Step 3: Converts each character to an integer
                        .sum(); // Step 4: Sums up the numeric values

        // Step 5: Displaying the sum
        System.out.println("The sum of digits: " + sum);
    }
}

Output:

The sum of digits: 15

Explanation:

1. The program starts by initializing an integer number with the value 12345, which is the subject of our digit sum calculation.

2. It converts number to a string using String.valueOf(number). This string is then converted into a stream of characters with .chars(), which actually produces an IntStream where each int represents a char value.

3. The map operation is applied to each element of the stream to convert the char values to their numeric values using Character::getNumericValue. This method translates the char representation of each digit back into an integer value (e.g., '1' to 1).

4. The sum operation is used to aggregate all the numeric values, producing the total sum of the digits in the number.

5. Finally, the sum is printed to the console. The output of the program shows the sum of the digits of 12345, demonstrating the use of Java 8 streams to perform arithmetic operations on the digits of a number in a functional style.

10. Java 8 Program to Print Even Numbers from a List

Filtering and processing collections based on certain criteria is a common task in programming. Java 8 introduced the Stream API, which provides a more intuitive and functional approach to handle collections. One of the common tasks is to filter a list of numbers to find even ones. This section will demonstrate how to use Java 8 streams to filter and print even numbers from a list, showcasing the simplicity and power of using streams for collection processing.

Program Steps

1. Create a list of integers.

2. Use the Stream API to process the list.

3. Filter the stream to include only even numbers.

4. Print each even number found in the list.

Code Program

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

public class PrintEvenNumbers {
    public static void main(String[] args) {
        // Step 1: Creating a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Step 2 and 3: Using Stream API to filter and print even numbers
        System.out.println("Even numbers in the list:");
        numbers.stream() // Convert the list to a stream
               .filter(n -> n % 2 == 0) // Filter stream to include only even numbers
               .forEach(System.out::println); // Step 4: Print each even number
    }
}

Output:

Even numbers in the list:
2
4
6
8
10

Explanation:

1. The program begins by initializing a List<Integer> with a series of integers from 1 to 10. This list serves as our dataset from which we want to find and print even numbers.

2. It then utilizes the Stream API to process this list. The .stream() method is called on the list to create a stream of its elements. Streams support a variety of operations that can be connected in a pipeline, designed for computational efficiency and laziness where possible.

3. The .filter(n -> n % 2 == 0) method filters the stream to include only those numbers that are even. This is determined using the modulus operator %, where n % 2 equals 0 for even numbers.

4. Finally, the .forEach(System.out::println) method consumes each element of the filtered stream, printing it to the console. This method reference is a concise way to call a method on each element of the stream.

5. The output lists all even numbers found in the original list, demonstrating how Java 8's Stream API simplifies the process of filtering and acting upon collections.

11. Java 8 Program to Remove Duplicate Elements from a List

Removing duplicate elements from a list is a common operation in data processing to ensure that each element is unique. Java 8 introduced the Stream API, which provides a powerful set of tools to manipulate collections more declaratively. This includes the ability to filter duplicates out of a collection efficiently. This section will demonstrate how to use Java 8 streams to remove duplicate elements from a list, showcasing a cleaner and more functional approach to achieving this task.

Program Steps

1. Create a List with some duplicate elements.

2. Convert the List to a Stream.

3. Use the distinct() method of the Stream API to filter out duplicates.

4. Collect the results back into a List.

5. Print the List without duplicates.

Code Program

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

public class RemoveDuplicatesFromList {
    public static void main(String[] args) {
        // Step 1: Creating a List with duplicate elements
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5, 5, 6);
        System.out.println("Original list: " + numbers);

        // Steps 2 to 4: Removing duplicates using Stream API
        List<Integer> distinctNumbers = numbers.stream() // Convert to stream
                                               .distinct() // Remove duplicates
                                               .collect(Collectors.toList()); // Collect results back into a list

        // Step 5: Printing the list without duplicates
        System.out.println("List after removing duplicates: " + distinctNumbers);
    }
}

Output:

Original list: [1, 2, 2, 3, 4, 4, 5, 5, 6]
List after removing duplicates: [1, 2, 3, 4, 5, 6]

Explanation:

1. The program begins by initializing a List<Integer> named numbers with a set of integers, including some duplicates. This list represents the dataset from which we wish to remove duplicate elements.

2. It then converts this list into a stream using the .stream() method. Streams in Java 8 are designed to provide a high-level abstraction for sequences of elements, supporting sequential and parallel aggregate operations.

3. The .distinct() method is applied to the stream to filter out duplicate elements. This method uses the equals() method of the objects in the stream to determine equality and thus identify duplicates.

4. The stream is then collected back into a new List<Integer> using the Collectors.toList() collector. This step gathers the results of the stream operations into a new list that no longer contains duplicate elements.

5. Finally, the program prints both the original list and the new list without duplicates. The output clearly shows that the duplicates have been removed, demonstrating an effective and concise way to remove duplicates from a list using Java 8's Stream API.

12. Java 8 Program to Retrieve Last Element of a List of Strings

Retrieving specific elements from a collection is a common operation in programming. In Java, the Stream API introduced in Java 8 has provided new, efficient ways to manipulate collections. One such task might be to retrieve the last element of a list of strings. While traditional methods exist to accomplish this, using Java 8 features can make the code more readable and concise. This section will demonstrate retrieving the last element from a list of strings using Java 8 streams.

Program Steps

1. Create a list of strings.

2. Use the Stream API to process the list.

3. Retrieve the last element of the stream.

4. Display the last element.

Code Program

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

public class RetrieveLastElement {
    public static void main(String[] args) {
        // Step 1: Creating a list of strings
        List<String> listOfStrings = Arrays.asList("Java", "Python", "C++", "JavaScript", "Ruby");

        // Step 2 and 3: Using Stream API to retrieve the last element
        Optional<String> lastElement = listOfStrings.stream()
                                                    .reduce((first, second) -> second); // Using reduce to get the last element

        // Step 4: Displaying the last element
        lastElement.ifPresent(element -> System.out.println("The last element is: " + element));
    }
}

Output:

The last element is: Ruby

Explanation:

1. The program starts by creating a List<String> containing a few programming language names. This list represents the collection from which we want to retrieve the last element.

2. To process this list, the Stream API is utilized. The .stream() method converts the list into a stream of its elements. The reduce((first, second) -> second) method is then applied to this stream. The reduce operation applies a binary function to each element in the stream where the first and second parameters are consecutive elements of the stream. By returning the second element each time, we ensure that the last element of the stream is returned by the reduce operation. This technique effectively retrieves the last element from the stream.

3. The result of the reduce operation is an Optional<String>, which may or may not contain a value depending on whether the list was empty. The ifPresent method is used to execute a block of code if the Optional is non-empty, printing the last element to the console.

4. The output of the program confirms that the last element, "Ruby", is successfully retrieved from the list. This example demonstrates the power and simplicity of using Java 8 streams to perform operations on collections, such as retrieving the last element from a list of strings.

13. Java 8 Program to Print Duplicate Characters in a String

Identifying duplicate characters in a string is a common text processing task, which can be useful in various contexts such as data validation, syntax checking, or as part of algorithms in larger applications. Java 8 introduced the Streams API, which provides a powerful set of tools for handling collections and streamlining operations like filtering, sorting, and summarizing data. This section will demonstrate how to use Java 8 features to print duplicate characters in a string, showcasing an efficient and concise approach.

Program Steps

1. Convert the string into a character stream.

2. Collect characters into a map with their occurrence count.

3. Filter the map to retain only those characters that occur more than once.

4. Print the duplicate characters.

Code Program

import java.util.function.Function;
import java.util.stream.Collectors;

public class PrintDuplicateCharacters {
    public static void main(String[] args) {
        String input = "programming"; // The input string

        // Step 1: Converting the string into a stream of characters
        input.chars() // Creates an IntStream
             .mapToObj(c -> (char) c) // Convert int stream to Character stream
             // Step 2: Collecting characters with their occurrence count
             .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
             // Step 3: Filtering to retain only duplicates
             .entrySet().stream().filter(entry -> entry.getValue() > 1)
             // Step 4: Printing duplicate characters
             .forEach(entry -> System.out.println("Character: " + entry.getKey() + ", Count: " + entry.getValue()));
    }
}

Output:

Character: g, Count: 2
Character: r, Count: 2
Character: m, Count: 2

Explanation:

1. The program starts with an input string input containing the word "programming". The goal is to find and print the characters that appear more than once in this string.

2. It converts the string into a stream of characters using input.chars(), which returns an IntStream representing the character values. This stream is then converted into a stream of Character objects for further processing.

3. The stream is collected into a Map<Character, Long> using Collectors.groupingBy(), which groups characters by their identity (i.e., the character itself) and counts their occurrences using Collectors.counting().

4. The resulting map entries are then streamed, and a filter is applied to retain only those entries where the count is greater than 1, indicating duplicate characters.

5. Finally, for each entry in the filtered stream (representing a duplicate character), the character and its count are printed to the console. The output clearly shows the characters 'g', 'r', and 'm' as duplicates, along with their occurrence counts, demonstrating the efficiency and expressiveness of Java 8's Streams API for processing and analyzing strings.

14. Java 8 Program to Find First Repeated Character in a String

Identifying the first repeated character in a string is a common challenge in string manipulation and analysis tasks. This problem is particularly interesting in the context of parsing and lexical analysis, where the identification of duplicate characters can signify syntax errors or other anomalies. Java 8 introduced powerful new features for working with streams that make solving this problem more straightforward and expressive. This section will demonstrate how to find the first repeated character in a string using Java 8's Stream API, showcasing a functional approach to solving this common programming problem.

Program Steps

1. Convert the string to a stream of characters.

2. Use a LinkedHashMap to maintain the order of characters and count occurrences.

3. Filter the map to find the first character with more than one occurrence.

4. Print the first repeated character if present.

Code Program

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class FindFirstRepeatedChar {
    public static void main(String[] args) {
        String input = "javastream"; // The input string

        // Step 1: Convert the string into a stream of characters
        Character result = input.chars() // Creates an IntStream
                .mapToObj(c -> (char) c) // Convert int to Character
                // Step 2: Collect characters to map with occurrence count, preserving order
                .collect(Collectors.toMap(Function.identity(), v -> 1, Integer::sum, LinkedHashMap::new))
                // Step 3: Find the first character with more than one occurrence
                .entrySet().stream().filter(entry -> entry.getValue() > 1)
                .map(Map.Entry::getKey)
                .findFirst().orElse(null); // Retrieve the first repeated character, if any

        // Step 4: Print the first repeated character
        if (result != null) {
            System.out.println("First repeated character: " + result);
        } else {
            System.out.println("No repeated characters found.");
        }
    }
}

Output:

First repeated character: a

Explanation:

1. The program starts with a string input set to "javastream", where the task is to find the first character that appears more than once.

2. The string is converted into a stream of Character objects, which allows for functional-style operations on each character.

3. The characters are collected into a LinkedHashMap using Collectors.toMap(). This specific map implementation preserves the insertion order of keys and uses the merge function Integer::sum

to count occurrences of each character. This is crucial for identifying the first repeated character while maintaining the original order of characters in the string.

4. The map's entry set is streamed, and a filter is applied to find the first entry where the value (the count) is greater than one, indicating a repeated character. The findFirst() terminal operation is then used to retrieve this character, if any.

5. Finally, the program checks if a repeated character was found and prints it. In this case, 'a' is the first character in "javastream" that appears more than once, as reflected in the output. This solution highlights the power of Java 8's Stream API and LinkedHashMap for efficiently solving problems related to string analysis and manipulation.

15. Java 8 Program to Concatenate Two Streams

Concatenating streams is a common operation when working with sequences of elements in Java, especially with the introduction of the Stream API in Java 8. This feature enhances the ability to perform complex operations on collections in a functional style, making code more readable and concise. Concatenation of streams involves combining the elements of two streams into a single stream. This is particularly useful in scenarios where data from different sources needs to be processed in a unified manner. This section will demonstrate how to concatenate two streams in Java 8, showcasing the simplicity and flexibility of stream operations.

Program Steps

1. Create two streams of elements.

2. Use the Stream.concat() method to concatenate the two streams.

3. Collect the concatenated stream into a list or another collection as needed.

4. Display the result of the concatenation.

Code Program

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

public class ConcatenateStreams {
    public static void main(String[] args) {
        // Step 1: Creating two streams
        Stream<String> stream1 = Stream.of("Java", "Python", "C++");
        Stream<String> stream2 = Stream.of("JavaScript", "TypeScript", "Kotlin");

        // Step 2: Concatenating the two streams
        Stream<String> concatenatedStream = Stream.concat(stream1, stream2);

        // Step 3: Collecting the concatenated stream into a list
        List<String> resultList = concatenatedStream.collect(Collectors.toList());

        // Step 4: Displaying the result
        System.out.println("Concatenated Stream Result: " + resultList);
    }
}

Output:

Concatenated Stream Result: [Java, Python, C++, JavaScript, TypeScript, Kotlin]

Explanation:

1. The program begins by creating two Stream<String> instances, stream1 and stream2, each initialized with a set of string elements. These streams represent separate sequences of programming language names.

2. The Stream.concat() static method is used to concatenate stream1 and stream2 into a single stream, concatenatedStream. This method takes two streams as input and returns a new stream that is the concatenation of the input streams, preserving the order of elements.

3. The concatenated stream is then collected into a List<String> using the collect(Collectors.toList()) terminal operation. This step gathers all elements from the stream into a list, allowing for easy access and manipulation of the combined elements.

4. Finally, the concatenated list of elements is printed to the console, showing the merged sequence of programming language names from both original streams. The output confirms that the elements of stream1 and stream2 have been successfully concatenated in the order they were provided, demonstrating an effective use of Java 8's Stream API to perform stream concatenation.