Topic 9.5: Working with Selected classes from the Java API - Write a simple Lambda expression that consumes a Lambda Predicate expression

Question 1

How do we use a lambda predicate expression to check if a student’s age is greater than or equal to 21?

Answer 1

(student) -> { return student.getAge() >= 21; }.

Question 2

Provide an example of using a Predicate object in a method.

Answer 2

public static List<Student> getMatching(List<Student> students, Predicate<Student> ps) {
    List<Student> results = new ArrayList<>();
    for (Student s : students) {
        if (ps.test(s)) {
            results.add(s);
        }
    }
    return results;
}

Question 3

What is the purpose of the test() method in the Predicate interface?

Answer 3

The test() method in the Predicate interface evaluates the condition specified by the predicate on the given input object and returns true or false accordingly.

Question 4

How are lambda expressions related to functional interfaces?

Answer 4

Lambda expressions allow you to create instances of functional interfaces concisely and inline, without the need for explicit class implementations.

Question 5

What is the functionality of the or() method in the Predicate interface?

Answer 5

The or() method returns a composed predicate that represents a logical OR operation between the current predicate and another predicate. It returns true if either of the predicates evaluates to true.

Question 6

Show a code snippet that uses the negate() method in the Predicate interface to create a negated predicate.

Answer 6

Predicate<Integer> isEven = num -> num % 2 == 0;
Predicate<Integer> isOdd = isEven.negate();
boolean result = isOdd.test(3); // true

Question 7

What is the purpose of functional interfaces in Java?

Answer 7

Functional interfaces serve as the foundation for lambda expressions and provide a way to represent functions as objects in Java.

Question 8

What are the options for representing the implementation of a lambda expression in Java?

Answer 8

The body of a lambda expression can be a single expression/statement or a block of code enclosed in curly braces {}.

• If it’s a single expression, it is implicitly returned.
• If it’s a block of code and a value is expected, you need to include a return statement explicitly.

Question 9

What is the purpose of the test() method in the Predicate interface?

Answer 9

The test() method in the Predicate interface is used to evaluate a condition on the input argument and returns a boolean value (true or false).

Question 10

What does the negate() method do in the Predicate interface?

Answer 10

The negate() method returns a predicate that represents the negation of the current predicate. It flips the result of the current predicate; if the current predicate returns true, the negated predicate will return false, and vice versa.

Question 11

Can you specify argument types (formal parameter types) in lambda expressions?

Answer 11

Yes, you can specify argument types in lambda expressions. However, if you provide the argument type for one parameter, you must provide it for all parameters when the context requires multiple parameters. This helps remove ambiguity for the compiler.

Question 12

How do you implement the Predicate interface?

Answer 12

To implement the Predicate interface, use the syntax: class ClassName implements Predicate<T>, where T is the type of the input to the predicate.</T>

Question 13

What is the benefit of using a Predicate object?

Answer 13

By using a Predicate object, we can encapsulate logic that will return a boolean value. this logic may then be re-used and passed to a generalized method, making the method dynamic and reusable without the need for rewriting the logic.

Question 14

What does the Predicate functional interface represent in Java?

Answer 14

The Predicate functional interface represents a boolean-valued function that takes an input and returns true or false based on a specified condition.

Question 15

What is the general rule for creating lambda expressions in Java?

Answer 15

Lambda expressions can only be used with interfaces that have exactly one abstract method. These interfaces are known as functional interfaces.

Question 16

Can you use the same variable name in separate lambda expressions?

Answer 16

Yes, variable names used within separate lambda expressions do not conflict, as the variable names go out of scope after the expression is evaluated.

Question 17

What are the three parts of the syntax for creating a lambda expression in Java?

Answer 17

The syntax for a lambda expression consists of a parameter list, an arrow token (->), and a body.

Question 18

Provide an example of a lambda expression using a custom Predicate.

Answer 18

Predicate<String> containsLetterA = str -> str.contains("a");

Question 19

How is the type of a lambda expression determined in Java?

Answer 19

The type of a lambda expression is determined from the context in which it is used. The compiler recognizes the lambda’s type based on how it’s assigned to a variable or used in a method parameter.

Question 20

What is the syntax of a lambda predicate expression?

Answer 20

The syntax of a lambda predicate expression is (parameter_list) -> { lambda_body }.

Question 21

How is the test() method used in the Predicate interface?

Answer 21

The test() method is the functional method of the Predicate interface. It accepts an argument of a specified type and returns a boolean value, indicating whether the condition specified by the predicate is met or not.

Question 22

What can be omitted in a simple lambda predicate expression that returns a boolean?

Answer 22

In a simple lambda predicate expression that returns a boolean, we can omit:
* the body curly braces
* the return keyword
* the semicolon closing the statement within the body

Question 23

What is the purpose of the Predicate interface?

Answer 23

The Predicate interface in the java.util.function package contains one abstract method, test(T t), which takes an input object and returns a boolean value.

Question 24

Provide an example of implementing the Predicate interface.

Answer 24

public class Student21PlusPredicate implements Predicate<Student> 
{
    @Override
    public boolean test(Student s) {
        return s.getAge() >= 21;
    }
}

Question 25

What is the scope of lambda expression parameters?

Answer 25

The parameter names used in lambda expressions should not conflict with the variable names currently in scope.

The variable names used in lambda expressions do not escape the lambda’s scope.

Question 26

Show a code snippet that uses the and() method in the Predicate interface to combine two predicates.

Answer 26

Predicate<Integer> isEven = num -> num % 2 == 0;
Predicate<Integer> isGreaterThanTen = num -> num > 10;

Predicate<Integer> isEvenAndGreaterThanTen = isEven.and(isGreaterThanTen);
boolean result = isEvenAndGreaterThanTen.test(12); // true

Question 27

When can we omit the parentheses around the parameter in a lambda predicate expression?

Answer 27

If we are only passing a single parameter to the lambda body, we may omit the parentheses around it.

For example: s -> s.getAge() > 18

Question 28

How does the and() method of the Predicate interface work?

Answer 28

The and() method returns a composed predicate that represents a logical AND operation between the current predicate and another predicate. It returns true only if both predicates evaluate to true.

Question 29

Provide a code snippet demonstrating the use of the or() method in the Predicate interface.

Answer 29

Predicate<Integer> isEven = num -> num % 2 == 0;
Predicate<Integer> isDivisibleByThree = num -> num % 3 == 0;

Predicate<Integer> isEvenOrDivisibleByThree = isEven.or(isDivisibleByThree);
boolean result = isEvenOrDivisibleByThree.test(12); // true

Question 30

What happens when you use a lambda expression to implement the functional method of a functional interface?

Answer 30

When you use a lambda expression to implement the functional method of a functional interface, you effectively create an instance of that interface.

Question 31

What characterizes a functional interface in Java?

Answer 31

A functional interface contains only a single abstract method, which is often referred to as the functional method.

Question 32

How do lambda expressions simplify implementing the Predicate interface?

Answer 32

Lambda expressions provide a shorthand way to implement the test() method of the Predicate interface without the need to create a separate implementing class.

Question 33

Where is the Predicate interface located, and what does it belong to?

Answer 33

The Predicate interface is located in the java.util.function package, and it belongs to the group of functional interfaces in Java.

Question 34

What are lambda expressions in Java?

Answer 34

Lambda expressions in Java are anonymous functions that provide a concise way to represent functional interfaces with a single abstract method.

Question 35

How do you create a lambda expression using Predicate to evaluate a custom condition?

Answer 35

To create a lambda expression using Predicate to evaluate a custom condition, you need to implement the test() method within the lambda’s body.

Question 36

How does the relationship between functional interfaces and lambda expressions impact Java code?

Answer 36

The relationship allows for the creation of compact and expressive code, making Java more functional in nature. By using lambda expressions with functional interfaces, you can pass behavior as a method argument, store it in variables, or return it from methods.

Question 37

Provide a code snippet demonstrating the use of the test() method in the Predicate interface.

Answer 37

Predicate<String> isLongWord = word -> word.length() > 5;
boolean result = isLongWord.test("Java"); // false

Question 38

What is a Predicate in Java?

Answer 38

This is a statement or function in Java that returns either true or false.