Java Streams API (map, filter, reduce) Quiz

0 Passed

0% acceptance

Master the Java Streams API for functional-style operations on collections. Learn to create streams, use intermediate operations like map and filter, apply terminal operations, perform reductions, and follow best practices for efficient stream processing.

35 Questions

~70 minutes

Question 1

What is the primary purpose of the Java Streams API?

To provide functional-style operations on collections

To replace all loops in Java code

To create new collection types

To handle file I/O operations

Question 2

How do you create a stream from a List?

java

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

Using the stream() method on the List

Using Stream.of(list)

Using new Stream<>(list)

Using Arrays.stream(list)

Question 3

What does the map() intermediate operation do?

Transforms each element using a function

Filters elements based on a predicate

Combines all elements into one result

Sorts the elements

Question 4

How do you create a stream from an array?

java

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

Using Arrays.stream(array)

Using array.stream()

Using Stream.of(array)

Using new Stream<>(array)

Question 5

What is the difference between intermediate and terminal operations?

Intermediate operations return a stream, terminal operations return a result or void

Intermediate operations are lazy, terminal operations are eager

Both A and B are correct

Intermediate operations modify the source, terminal operations don't

Question 6

What does the filter() operation do?

java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> even = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

Selects elements that match a predicate

Transforms elements using a function

Sorts elements in ascending order

Removes duplicate elements

Question 7

How do you create an infinite stream?

java

Stream<Integer> infinite = Stream.iterate(1, n -> n + 1);

Using Stream.iterate() or Stream.generate()

Using Stream.of() with no arguments

Using an empty collection.stream()

Infinite streams cannot be created

Question 8

What is a reduction operation in streams?

An operation that combines stream elements into a single result

An operation that filters elements

An operation that transforms elements

An operation that sorts elements

Question 9

How do you collect stream results into a List?

java

List<String> result = stream.collect(Collectors.toList());

Using collect(Collectors.toList())

Using toList() directly

Using collect(Collectors.toCollection(ArrayList::new))

All of the above work

Question 10

What does the distinct() intermediate operation do?

java

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3);
List<Integer> unique = numbers.stream()
    .distinct()
    .collect(Collectors.toList());

Removes duplicate elements

Sorts elements in ascending order

Limits the number of elements

Reverses the order of elements

Question 11

How do you find the first element of a stream?

java

Optional<String> first = stream.findFirst();

Using findFirst() which returns Optional

Using first() directly

Using get(0) on the stream

Using findAny() and hoping for the first

Question 12

What is the purpose of the limit() operation?

java

Stream<Integer> limited = Stream.iterate(1, n -> n + 1)
    .limit(5);

Limits the stream to a maximum number of elements

Limits processing time

Limits memory usage

Limits the number of operations

Question 13

How do you perform a reduction with reduce()?

java

int sum = numbers.stream()
    .reduce(0, (a, b) -> a + b);

Using reduce(identity, accumulator)

Using reduce(accumulator) only

Using collect() with summing

Using sum() directly

Question 14

What does the flatMap() operation do?

java

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);
List<String> flat = listOfLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());

Flattens nested collections into a single stream

Creates a map from stream elements

Applies a function and flattens the result

Both A and C are correct

Question 15

How do you check if any element matches a predicate?

java

boolean anyEven = numbers.stream()
    .anyMatch(n -> n % 2 == 0);

Using anyMatch(predicate)

Using contains() on the stream

Using findAny() and checking

Using someMatch(predicate)

Question 16

What is the difference between findFirst() and findAny()?

findFirst() is deterministic, findAny() may return any element for parallel streams

findFirst() is for ordered streams, findAny() for unordered

findFirst() returns the first element, findAny() returns a random element

They are identical in behavior

Question 17

How do you sort a stream?

java

List<String> sorted = strings.stream()
    .sorted()
    .collect(Collectors.toList());

Using sorted() for natural order or sorted(comparator) for custom order

Using sort() method

Using orderBy()

Using arrange()

Question 18

What does the peek() operation do?

java

stream.peek(System.out::println)
    .collect(Collectors.toList());

Performs an action on each element without modifying the stream

Looks at the next element without consuming it

Returns the first element

Skips elements in the stream

Question 19

How do you count elements in a stream?

java

long count = stream.count();

Using the count() terminal operation

Using size() method

Using length() method

Using Collectors.counting()

Question 20

What is a stream pipeline?

A sequence of stream operations chained together

A physical pipe connecting stream sources

A storage mechanism for stream data

A type of stream collector

Question 21

How do you create a parallel stream?

java

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> parallelStream = list.parallelStream();

Using parallelStream() on collections

Using stream().parallel()

Both A and B

Using ParallelStream.of()

Question 22

What is the difference between sequential and parallel streams?

Sequential processes elements one by one, parallel may process concurrently

Sequential is faster, parallel is slower

Sequential uses more memory, parallel uses less

Sequential is deprecated, parallel is recommended

Question 23

How do you group elements by a classifier?

java

Map<String, List<Person>> byCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));

Using Collectors.groupingBy(classifier)

Using groupBy() on streams

Using partitionBy() with a predicate

Using categorize() method

Question 24

What does the skip() operation do?

java

Stream<Integer> skipped = numbers.stream().skip(3);

Skips the first n elements of the stream

Skips elements that match a predicate

Skips null elements

Skips duplicate elements

Question 25

How do you concatenate two streams?

java

Stream<String> combined = Stream.concat(stream1, stream2);

Using Stream.concat(stream1, stream2)

Using stream1.addAll(stream2)

Using stream1.merge(stream2)

Using flatMap with both streams

Question 26

What is stream laziness?

Intermediate operations are not executed until a terminal operation is called

Streams delay processing to save memory

Streams are lazy by default and eager when needed

All of the above are aspects of laziness

Question 27

How do you handle checked exceptions in streams?

Wrap in try-catch or use functional interfaces that throw unchecked exceptions

Streams automatically handle checked exceptions

Use try-with-resources in stream operations

Checked exceptions cannot be used in streams

Question 28

What is the purpose of the forEach() terminal operation?

java

numbers.stream().forEach(System.out::println);

Performs an action for each element in the stream

Iterates over elements without collecting results

Both A and B

Replaces traditional for-each loops

Question 29

How do you create a stream from a range of numbers?

java

IntStream range = IntStream.range(1, 10); // 1 to 9
IntStream rangeClosed = IntStream.rangeClosed(1, 10); // 1 to 10

Using IntStream.range(start, end) or rangeClosed(start, end)

Using Stream.range(start, end)

Using Arrays.stream() with an array

Using List.of() and stream()

Question 30

What is a common pitfall when using parallel streams?

Using non-thread-safe operations or shared mutable state

Parallel streams are always slower

Parallel streams don't work with infinite streams

Parallel streams cannot be collected

Question 31

How do you partition a stream into two groups?

java

Map<Boolean, List<Person>> partitioned = people.stream()
    .collect(Collectors.partitioningBy(person -> person.getAge() >= 18));

Using Collectors.partitioningBy(predicate)

Using Collectors.groupingBy() with boolean classifier

Using filter() twice

Using splitBy() method

Question 32

What does the allMatch() operation check?

java

boolean allEven = numbers.stream()
    .allMatch(n -> n % 2 == 0);

Whether all elements match the predicate

Whether any element matches the predicate

Whether no elements match the predicate

Whether exactly one element matches

Question 33

How do you create a stream from a file?

java

try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
    lines.forEach(System.out::println);
}

Using Files.lines(path) which returns a stream of lines

Using new FileInputStream() and stream()

Using Scanner and stream()

Using BufferedReader.lines()

Question 34

What is the benefit of using streams over traditional loops?

More readable, composable, and potentially parallelizable code

Faster execution in all cases

Less memory usage

Automatic error handling

Question 35

Mastering Java Streams API means you now write code that:

Processes collections functionally with map, filter, reduce operations, creates streams from various sources, applies intermediate and terminal operations correctly, and follows best practices for efficient and readable stream processing

Always uses parallel streams for better performance

Avoids all traditional loops entirely

Uses streams only for simple filtering operations

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Rust

30 quizzes

Cargo and Project Setup

Variables and Mutability

Data Types

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Java

Java Basics & JVM Fundamentals

50 in-depth questions (30 with code) covering Java platform independence, JVM architecture, compilation, bytecode, class loading, memory areas, garbage collection, and your first real Java program.

Variables, Data Types & Type Casting

40 focused questions Java primitive and reference types, variable declaration rules, widening/narrowing conversions, the final keyword, and the most common type-casting pitfalls.

Operators & Expressions

40 medium-to-advanced questions Java operators & expressions that force deep thinking about arithmetic, relational, logical, assignment, and ternary operators — including precedence traps, short-circuit behavior, compound assignment quirks, and real-world expression bugs.

Strings & String Methods

35 in-depth questions covering String immutability, object creation, comparison behavior, common methods, StringBuilder/StringBuffer usage, and performance implications in real-world Java code.

Numbers & Math Class

35 deep-dive questions on Java's numerical capabilities, from Math utilities and rounding behavior to BigInteger/BigDecimal precision, number formatting, and the subtle dangers of primitive overflow.

Arrays & Multi-Dimensional Arrays

35 deep and practical questions on Java arrays — from declaration and initialization to advanced 2D/3D usage, Arrays utility methods, common pitfalls, and performance gotchas that trip even senior developers.

Classes, Objects & Constructors

40 deep and challenging questions that explore every corner of object creation, constructor behavior, the true meaning of this, the subtle differences between instance and static members, and the complete lifecycle of objects in Java.

Methods, Parameters & Overloading

35 challenging and insight-revealing questions that dive deep into how Java really handles method invocation, parameter passing, overloading resolution, varargs behavior, return type rules, and the subtle edge cases that surprise even experienced developers.

Packages & Import Statements

40 deep, practical, and often overlooked questions about Java packages — from directory structure enforcement and classpath mechanics to import rules, static imports, naming conventions, and the subtle ways packages affect accessibility, compilation, and runtime behavior.

Control Flow (if, else, switch)

35 deep, real-world, and frequently misunderstood questions about Java control flow — covering if-else pitfalls, dangling else, fall-through dangers, modern switch expressions, pattern matching, exhaustive checking, and the best practices that prevent bugs in production code.

Loops (for, while, do-while)

35 deep, practical, and often misunderstood questions about Java loops — from subtle break/continue label behavior and enhanced for-loop limitations to infinite loop detection, do-while quirks, loop unrolling myths, and the performance & safety best practices used in real production systems.

Encapsulation & Abstraction in OOP

35 in-depth questions (15 with code) covering encapsulation principles, getters/setters implementation, abstraction concepts, abstracting behavior, and design benefits in object-oriented programming.

Polymorphism (Compile-Time & Runtime)

35 in-depth questions (15 with code) covering method overloading as compile-time polymorphism, overriding as runtime polymorphism, dynamic method dispatch, upcasting/downcasting, and why polymorphism matters in object-oriented design.

Interfaces, Abstract Classes & Multiple Inheritance

35 in-depth questions (15 with code) covering interface basics, abstract class fundamentals, default/static methods in interfaces, functional interfaces, and multiple inheritance resolution in Java.

Exception Handling (try, catch, finally)

40 in-depth questions (20 with code) covering types of exceptions, try/catch syntax, finally block purpose, stack traces, and best practices in Java exception handling.

Custom Exceptions & Exception Hierarchy

30 in-depth questions (15 with code) covering creating custom exceptions, throw vs throws, checked vs unchecked exceptions, chained exceptions, and designing exception structures in Java.

Collections Framework (List, Set, Map)

35 in-depth questions (18 with code) covering List types (ArrayList, LinkedList), Set types (HashSet, TreeSet), Map types (HashMap, TreeMap), Collections utility class, and choosing the right collection for different use cases in Java.

Generics Deep Dive

35 in-depth questions (18 with code) covering why generics exist, generic methods, bounded type parameters, wildcards (? extends, ? super), and raw types pitfalls in Java.

Java I/O (Files, Streams, Readers/Writers)

35 in-depth questions (18 with code) covering Input/Output streams, Readers vs Writers, File operations, Buffered I/O, and handling I/O exceptions in Java.

Date & Time API (java.time)

35 in-depth questions (18 with code) covering LocalDate & LocalTime, LocalDateTime & ZonedDateTime, formatting dates, parsing dates, and Duration & Period in Java's modern date-time API.

Streams API (map, filter, reduce)

JVM Memory Model (Heap, Stack, GC)

Understand the JVM memory architecture including heap and stack management, garbage collection mechanisms, classloader hierarchy, memory leak prevention, and JVM optimization techniques.