Lambda Expressions_v1.0

What is a lambda expression in Java?

• A method that takes no parameters and returns no value.

• A concise way to represent an anonymous function.

• A class that implements an interface.

• A variable that holds a constant value.

Which of the following is the correct syntax for a lambda expression in Java?

• `(int a, int b) -> a + b`

• `int a, int b -> a + b`

• `(int a, int b) { return a + b; }`

• `a, b -> a + b`

What is the primary use of lambda expressions in Java?

• To define a new class.

• To implement interfaces with multiple methods.

• To enable functional programming by passing behavior as parameters.

• To create a new package.

Which of the following interfaces is commonly used with lambda expressions in Java?

• Serializable

• Runnable

• Comparable

• FunctionalInterface

Consider the following lambda expression: `(x) -> x * x`. What is the return type if `x` is an integer?

• void

• int

• double

• String

Which of the following is NOT a characteristic of lambda expressions in Java?

• They can have zero or more parameters.

• They can have a body consisting of a single expression or a block of code.

• They can be used to create new classes.

• They can return a value.

What is the output of the following code snippet? ```java List list = Arrays.asList("a", "b", "c"); list.forEach(s -> System.out.print(s.toUpperCase())); ```

• abc

• ABC

• a b c

• A B C

Which of the following lambda expressions correctly implements the `Comparator` interface for sorting integers in ascending order?

• `(a, b) -> a.compareTo(b)`

• `(a, b) -> Integer.compare(a, b)`

• `(a, b) -> a - b`

• `(a, b) -> b - a`

In the context of lambda expressions, what does the term "effectively final" mean?

• A variable that is declared as final.

• A variable that is not modified after its initial assignment.

• A variable that is used only within a single method.

• A variable that is declared within a lambda expression.

Which of the following is a benefit of using lambda expressions in Java?

• They increase the verbosity of the code.

• They allow for the creation of new data types.

• They enable more readable and maintainable code.

• They require more memory to execute.