Guided: Java SE 21 Developer (Exam 1Z0-830) - Collections and Streams

Welcome to the lab Guided: Java SE 21 Developer (Exam 1Z0-830) - Collections and Streams.

Java provides a rich set of data structures through the Collections Framework, which includes lists, sets, and maps, along with powerful stream operations for functional-style data processing.

Consider this scenario:

List<String> questions = new ArrayList<>();
questions.add("What is the capital of France?");
questions.add("What is the capital of Germany?");
questions.add("What is the capital of France?"); // Duplicate question

System.out.println(questions);

This approach works, but it lacks structure and efficiency when handling larger datasets. If you later need to remove duplicates, categorize questions, or compute statistics, basic lists won't enough.

Instead, you can leverage collections like sets and maps to maintain uniqueness and categorize questions efficiently:

Set<String> uniqueQuestions = new HashSet<>(questions);
System.out.println(uniqueQuestions); // Duplicates automatically removed!

If you need to filter questions by category, you can loop through a list:

List<String> scienceQuestions = new ArrayList<>();
for (String q : questions) {
    if (q.contains("Science")) {
        scienceQuestions.add(q);
    }
}

However, with streams, you can achieve the same result in a more concise and declarative way:

List<String> scienceQuestions = questions.stream()
    .filter(q -> q.contains("Science"))
    .collect(Collectors.toList());

In this lab, you'll build a Trivia Question Analyzer, implementing key collection and stream operations. By completing this lab, you will:

• Understand lists, sets, and maps and how to use them
• Learn to implement operations using both imperative loops and functional streams
• Practice filtering, mapping, and aggregating data ---

Familiarizing with the Program Structure

The application includes the following classes in the src/main/java directory:

• com.pluralsight.trivia.Question: Represents a trivia question with text, category, difficulty, possible answers, and the correct answer index.
• com.pluralsight.trivia.TriviaAnalyzer: The main class where you'll implement collection and stream operations.
• com.pluralsight.trivia.Main: The application's entry point with test data and method calls to demonstrate functionality.

The Question and Main classes are fully implemented. You'll be working on the TriviaAnalyzer class, where TODO comments indicate the areas to complete.

You can compile and run the application using the Run button located at the bottom-right corner of the Terminal. Initially, the application will compile successfully but will throw an exception when executed.

Begin by examining the code to understand the program's structure. Once you're ready, proceed with the coding tasks. If you need help, you can find solution files in the solution directory, organized by steps (e.g., step2, step3, etc.). Each solution file follows the naming convention [filename]-[step]-[task].java (e.g., TriviaAnalyzer-2-1.java in step2).

A List is an ordered collection of elements that allows duplicates. The List interface in Java is part of the Java Collections Framework and its most frequently used implementation is ArrayList, which provides fast random access and dynamic resizing.

To create a List, use:

List<String> items = new ArrayList<>();

You can add, remove, and access elements using methods provided by the List interface:

items.add("Apple");  // Adds "Apple" to the list
items.add("Banana"); // Adds "Banana" to the list
items.remove("Apple"); // Removes "Apple" from the list
System.out.println(items.get(0)); // Retrieves the first element

To process elements in a list, you can use traditional for loops and enhanced for loops.

The traditional for loop uses an index to iterate through the list:

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

for (int i = 0; i < fruits.size(); i++) {
    System.out.println(fruits.get(i));
}

The enhanced for loop simplifies iteration by eliminating the need for an index:

for (String fruit : fruits) {
    System.out.println(fruit);
}

You can ensure elements are unique before adding them using an if statement and checking for its properties:

List<String> names = new ArrayList<>();
names.add("Alice");

String newName = "Alice";
boolean exists = false;

for (String name : names) {
    if (name.equalsIgnoreCase(newName)) {
        exists = true;
        break;
    }
}

if (!exists) {
    names.add(newName);
}

Now that you understand how lists work, you will implement a method that ensures no duplicate questions are added.

A Set is a collection that does not allow duplicate elements. Unlike lists, which maintain an ordered sequence of elements, sets are designed to store unique items without any specific order.

The most commonly used implementation of the Set interface is HashSet, which provides efficient add, remove, and contains operations.

To create a Set, use:

Set<String> uniqueItems = new HashSet<>();

Elements can be added using the add() method:

Set<String> colors = new HashSet<>();
colors.add("Red");
colors.add("Blue");
colors.add("Red"); // Duplicate, will not be added
System.out.println(colors); // Output: [Red, Blue]

Even though "Red" was added twice, the set ensures that only one copy is stored.

You can iterate over a set using a traditional for loop, but it requires an Iterator or converting the Set to an array or a list first. For this reason, the recommended approach is to use an enhanced for loop:

for (String color : colors) {
    System.out.println(color);
}

Sets are useful when:

• You need to store only unique elements.
• You do not require a specific order for elements.
• You want fast lookups (checking if an item exists).

Now that you understand how sets work, you will implement a method that collects unique categories from a list and stores them in a Set.

A Map is a collection that stores key-value pairs. Unlike lists and sets, which store single elements, maps associate each key with a value, allowing efficient lookups and modifications.

The most commonly used implementation of the Map interface is HashMap, which provides fast access to elements using keys.

To create a Map, use:

Map<String, Integer> scoreMap = new HashMap<>();

You can add key-value pairs using the put() method:

scoreMap.put("Alice", 90);
scoreMap.put("Bob", 85);

To retrieve a value, use the get() method:

int score = scoreMap.get("Alice"); // Returns 90

If you try to access a key that does not exist, get() returns null.

System.out.println(scoreMap.get("Charlie")); // Output: null

If a key already exists, calling put() with the same key overwrites the value:

scoreMap.put("Alice", 95); // Updates Alice's score to 95

For example, to increment a value, you can use:

scoreMap.put("Bob", scoreMap.get("Bob") + 5); // Increases Bob's score by 5

However, before modifying a map, you can check if a key already exists using containsKey():

if (scoreMap.containsKey("Alice")) {
    System.out.println("Alice's score: " + scoreMap.get("Alice"));
}

Or, instead of checking if a key exists before retrieving it, you can use getOrDefault():

int defaultScore = scoreMap.getOrDefault("Charlie", 0); // Returns 0 if "Charlie" is not in the map

Finally, to iterate over all key-value pairs, you can use an enhanced for loop:

for (Map.Entry<String, Integer> entry : scoreMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

Maps are useful when:

• You need to store data in key-value pairs.
• You require fast lookups based on a unique identifier (e.g., names, categories, IDs).
• You need to keep a count of occurrences (e.g., word frequency, category counts).

Now that you understand how maps work, you will implement a method that counts occurrences in the question dataset by storing values in a Map.

Filtering is the process of selecting specific elements from a collection based on a given condition. It is commonly used to extract a subset of data that meets certain criteria. For example, given a list of numbers, you might want to filter out only even numbers.

Filtering With Loops (Imperative Approach)

In traditional Java programming, you can filter elements using a for loop or an enhanced for loop:

List<Integer> numbers = Arrays.asList(10, 15, 20, 25, 30);
List<Integer> evenNumbers = new ArrayList<>();

for (Integer num : numbers) {
    if (num % 2 == 0) {
        evenNumbers.add(num);
    }
}
System.out.println(evenNumbers); // Output: [10, 20, 30]

In the above example:

• A new list (evenNumbers) is created to store the filtered elements.
• A loop iterates over each number in the list.
• If the number matches the condition (num % 2 == 0), it is added to evenNumbers.

Filtering With Streams (Functional Approach)

The Stream API provides a more concise and readable way to filter elements using the filter() method:

List<Integer> numbers = Arrays.asList(10, 15, 20, 25, 30);

List<Integer> evenNumbers = numbers.stream()
    .filter(num -> num % 2 == 0)
    .collect(Collectors.toList());

System.out.println(evenNumbers); // Output: [10, 20, 30]

In the above example:

• stream() converts the list into a stream.
• filter(num -> num % 2 == 0) selects only even numbers using a lambda expression.
• collect(Collectors.toList()) gathers the filtered results into a new list.

Now that you understand filtering operations, you will:

1. Implement a filtering method using a loop (imperative approach).
2. Implement the same method using a stream (functional approach).

Transformation refers to converting elements in a collection from one format to another. This is commonly done using the map operation, which allows you to modify each element in a collection and store the transformed results. For example, given a list of numbers, you might want to square each number, or for a list of names, you may want to convert them to uppercase.

Transformation With Loops (Imperative Approach)

The traditional way to transform elements is by using a for loop to modify each element and store the result in a new list:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredNumbers = new ArrayList<>();

for (Integer num : numbers) {
    squaredNumbers.add(num * num);
}

System.out.println(squaredNumbers); // Output: [1, 4, 9, 16, 25]

In the above example:

• A new list (squaredNumbers) is created to store the transformed elements.
• A loop iterates over each number in the list.
• Each number is squared (num * num) and added to the new list.

Transformation With Streams (Functional Approach)

The Stream API provides a more concise way to transform elements using the map() method:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> squaredNumbers = numbers.stream()
    .map(num -> num * num)
    .collect(Collectors.toList());

System.out.println(squaredNumbers); // Output: [1, 4, 9, 16, 25]

In the above example:

• stream() converts the list into a stream.
• map(num -> num * num) applies the transformation to each element.
• collect(Collectors.toList()) gathers the transformed elements into a new list.

Now that you understand transformation operations, you will:

1. Implement a transformation method using a loop (imperative approach).
2. Implement the same method using a stream (functional approach).

Aggregation refers to computing a single result from a collection of elements. Unlike filtering or transformation, which return new collections, aggregation reduces a collection into a single value. For example, given a list of numbers, you might want to calculate the total sum or find the highest number.

Aggregation With Loops (Imperative Approach)

The traditional way to aggregate elements is by using a for loop and manually updating a variable:

List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);
int total = 0;

for (int num : numbers) {
    total += num;
}

System.out.println(total); // Output: 150

In the above example:

• A variable (total) is initialized to store the result.
• A loop iterates over each number in the list.
• Each number is added to total.
• The final result is printed after the loop.

Aggregation With Streams (Functional Approach)

The Stream API provides a more concise way to aggregate elements using the reduce() method:

List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);

int total = numbers.stream()
    .reduce(0, (sum, num) -> sum + num);

System.out.println(total); // Output: 150

In the above example:

• stream() converts the list into a stream.
• reduce(0, (sum, num) -> sum + num) accumulates elements by adding them together.
• The first argument (0) is the identity value. The reduction starts with this value, and every element in the stream is combined with it using the provided accumulator function.
• The second argument ((sum, num) -> sum + num), the accumulator function, is a lambda expression that adds each element to the total.

reduce is a generic method for performing reduction operations, however, the Stream API also provides specialized reduction methods for common cases like sum, min, and max:

int total = numbers.stream()
    .mapToInt(Integer::intValue)
    .sum();

Now that you understand aggregation operations, you will:

1. Implement an aggregation method using a loop (imperative approach).
2. Implement the same method using a stream (functional approach).

The Optional<T> Class

Optional<T> is a wrapper class introduced in Java 8 to help prevent null pointer exceptions. It is used to represent a value that may or may not be present. Instead of returning null, methods can return an Optional to indicate that a result might be absent.

For example, without Optional, checking for a missing value requires a null check:

String result = findValue();
if (result != null) {
    System.out.println(result.toUpperCase());
}

With Optional, you can avoid explicit null checks:

Optional<String> result = findValueOptional();
result.ifPresent(val -> System.out.println(val.toUpperCase()));

You can create an Optional in different ways:

Optional<String> nonEmpty = Optional.of("Hello"); // Throws an exception if null  
Optional<String> maybeEmpty = Optional.ofNullable(null); // Allows null values  
Optional<String> empty = Optional.empty(); // Represents an absent value  

To access the value inside an Optional, use:

• get(): Returns the value if present, but throws an exception if empty.
• orElse(defaultValue): Returns the value if present, otherwise returns a default value.
• orElseGet(Supplier): Similar to orElse(), but accepts a lambda expression for lazy evaluation.
• orElseThrow(): Throws an exception if no value is present.

For example:

String value = maybeEmpty.orElse("Default");
System.out.println(value); // Output: Default

To check if a value exists, use:

• isPresent(): Returns true if a value is present.
• ifPresent(Consumer): Executes a lambda function if a value is present.

For example:

maybeEmpty.ifPresent(System.out::println); // Prints only if not empty

The Stream API and Optional

Some Stream API methods return an Optional because the result may not exist. For example, methods like max() and min() return an Optional<T> because the list could be empty:

Optional<Integer> maxNumber = numbers.stream()
    .max(Integer::compareTo);

If the stream has no elements, max() will return an empty Optional instead of null, preventing potential errors.

Using Comparator.comparingInt()

To find the largest or smallest element based on a property, use Comparator.comparingInt():

Optional<Person> oldestPerson = people.stream()
    .max(Comparator.comparingInt(Person::getAge));

Here's how it works:

• comparingInt(Person::getAge) tells the comparator to use the age for comparison.
• max() finds the person with the highest age.

Now that you understand Optional, you will:

1. Find the toughest question (highest difficulty) using max().
2. Properly handle the Optional result to avoid null issues.

Congratulations on successfully completing this Code Lab!

By implementing the methods of the TriviaAnalyzer class, you can see the following differences between traditional loops and streams in Java:

Advantages of Loops:

• Familiar and easy to understand.
• Works in older versions of Java (before Java 8).

Disadvantages of Loops:

• Requires manual list creation and modification.
• Can become verbose and harder to maintain for complex conditions.

Advantages of Streams:

• More concise and readable than loops.
• Allows declarative programming, making code easier to understand.
• Optimized for parallel processing when used with parallelStream().

Disadvantages of Streams:

• Harder to debug compared to loops.
• Can be less intuitive for beginners unfamiliar with functional programming.

But, which approach should you use?

Here are two guidelines:

• Use loops when working with simple logic or when streams seem unnecessary.
• Use streams when working with large datasets or when conciseness and readability are priorities. ---

Executing the Application

To compile and run the application, you can either click the Run button in the bottom-right corner of the screen or use the Terminal with the following commands:

1. Compile and package the application:

   mvn clean package
   

2. Execute the application:

   java -cp target/trivia-analyzer-1.0-SNAPSHOT.jar com.pluralsight.trivia.Main
   

The program will generate an analysis of the questions defined in the Main class.

You can modify, add, or remove questions to see different results when running the program. Experiment with different categories, difficulties, and question formats to explore how the program processes and filters data. ---

Extending the Program

Here are some ideas to further enhance your skills and extend the application's capabilities:

1. Use generics for a more flexible trivia analyzer. Refactor the TriviaAnalyzer class to support different types of questions (e.g., multiple choice, true/false, or open-ended).

2. Saving and loading questions from a file. Implement a method to load questions from an external file instead of manually adding them in the Main class.

3. Parallel processing with streams. Modify the aggregation operations (finding the toughest question and computing total difficulty) to use parallel streams for performance improvements. Compare the execution time of sequential vs. parallel stream processing for large datasets.

Each of these extensions will help you reinforce your understanding of Java Collections and Streams. ---

Related Courses in Pluralsight's Library

If you'd like to continue building your Java skills or explore related topics, check out these courses available on Pluralsight:

• Java

These courses cover a wide range of Java programming topics. Explore them to further your learning journey in Java!