Filter and map operations in Kafka - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to filter messages with value greater than 10.

Kafka

stream.filter(record -> record.value() [1] 10);

Drag options to blanks, or click blank then click option'

A>

B<=

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' will filter the wrong records.

Using '==' will only keep records equal to 10.

The filter should keep records where the value is greater than 10, so we use the > operator.

2fill in blank

medium

Complete the code to map each record to its key.

Kafka

stream.map(record -> record.[1]());

Drag options to blanks, or click blank then click option'

Avalue

Btopic

Ctimestamp

Dkey

Attempts:

3 left

💡 Hint

Common Mistakes

Using value() returns the value, not the key.

Using timestamp() or topic() returns other info.

To get the key from a record, use the key() method.

3fill in blank

hard

Fix the error in the filter condition to keep records with even values.

Kafka

stream.filter(record -> record.value() [1] 2 == 0);

Drag options to blanks, or click blank then click option'

A/

B*

C%

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using division / instead of modulo %.

Using multiplication or addition operators.

The modulo operator % returns the remainder. To check even numbers, use value() % 2 == 0.

4fill in blank

hard

Fill both blanks to create a map of keys to values for records with values greater than 5.

Kafka

stream.filter(record -> record.value() [1] 5).map(record -> new KeyValue<>(record.[2](), record.value()));

Drag options to blanks, or click blank then click option'

A>

B<

Ckey

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' in the filter.

Using value() instead of key() for the key.

We filter records with values greater than 5 using >. Then we map to a KeyValue with the record's key and value.

5fill in blank

hard

Fill all three blanks to filter records with values less than 20, map to uppercase keys, and keep values.

Kafka

stream.filter(record -> record.value() [1] 20).map(record -> new KeyValue<>(record.[2]().[3](), record.value()));

Drag options to blanks, or click blank then click option'

A<

Bvalue

CtoUpperCase

Dkey

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' in the filter.

Using value() instead of key() for the key.

Not calling toUpperCase() on the key.

We filter records with values less than 20 using <. Then map to a KeyValue with the uppercase key and the value.

Practice

1. What does the filter operation do in Kafka Streams?

easy

A. Deletes all messages in the stream

B. Changes messages to a new form

C. Keeps only messages that meet a condition

D. Sends messages to a different topic

Solution

1. Step 1: Understand filter purpose

   The filter operation selects messages that satisfy a given condition, removing others.

2. Step 2: Compare with other operations

   Unlike map, which changes message content, filter only keeps or drops messages.

3. Final Answer:

   Keeps only messages that meet a condition -> Option C

4. Quick Check:

   Filter = Keep messages by condition [OK]

Hint: Filter keeps or drops messages based on a rule [OK]

Common Mistakes:

• Confusing filter with map operation
• Thinking filter changes message content
• Assuming filter deletes all messages

2. Which of the following is the correct syntax to apply a map operation on a Kafka stream named stream to convert messages to uppercase?

easy

A. stream.map(value.toUpperCase)

B. stream.filter(value -> value.toUpperCase())

C. stream.map(value => value.toUpperCase())

D. stream.map(value -> value.toUpperCase())

Solution

1. Step 1: Identify correct lambda syntax in Kafka Streams

   Kafka Streams in Java uses map(value -> ...) syntax for mapping values.

2. Step 2: Check method call correctness

   value.toUpperCase() correctly converts string to uppercase.

3. Final Answer:

   stream.map(value -> value.toUpperCase()) -> Option D

4. Quick Check:

   Correct lambda and method call = stream.map(value -> value.toUpperCase()) [OK]

Hint: Use arrow -> for lambda in Kafka Streams Java [OK]

Common Mistakes:

• Using filter instead of map
• Using JavaScript arrow => instead of Java ->
• Missing parentheses in method call

3. Given the following Kafka Streams code, what will be the output messages after processing?

stream.filter(value -> value.length() > 3)
      .map(value -> value.substring(0, 3))

Input messages: ["apple", "cat", "banana", "dog"]

medium

A. ["cat", "dog"]

B. ["app", "ban"]

C. ["apple", "banana"]

D. ["app", "cat", "ban", "dog"]

Solution

1. Step 1: Apply filter condition

   Keep messages with length > 3: "apple" (5), "banana" (6). "cat" and "dog" are dropped.

2. Step 2: Apply map operation

   Take first 3 characters: "apple" -> "app", "banana" -> "ban".

3. Final Answer:

   ["app", "ban"] -> Option B

4. Quick Check:

   Filter then map = ["app", "ban"] [OK]

Hint: Filter first, then map to transform filtered messages [OK]

Common Mistakes:

• Not filtering before mapping
• Mapping before filtering
• Including messages with length ≤ 3

4. Identify the error in this Kafka Streams code snippet:

stream.filter(value -> value.startsWith("a"))
      .map(value -> value.toUpperCase())
      .filter(value -> value.length() > 5)

medium

A. No error; code is correct

B. Using two filter operations is not allowed

C. The second filter uses the mapped uppercase value correctly

D. The lambda syntax is incorrect

Solution

1. Step 1: Check filter and map chaining

   Chaining multiple filters and maps is allowed in Kafka Streams.

2. Step 2: Verify lambda syntax and logic

   Lambdas use correct syntax and logic: first filter checks start, map uppercases, second filter checks length.

3. Final Answer:

   No error; code is correct -> Option A

4. Quick Check:

   Multiple filters and maps allowed = No error; code is correct [OK]

Hint: Multiple filters and maps can be chained without error [OK]

Common Mistakes:

• Thinking multiple filters are disallowed
• Confusing lambda syntax with other languages
• Assuming map changes variable type incorrectly

5. You want to process a Kafka stream of user names to keep only those starting with 'J' and convert them to lowercase. Which code snippet correctly does this?

hard

A. stream.filter(name -> name.startsWith("J"))
.map(name -> name.toLowerCase())

B. stream.map(name -> name.toLowerCase())
.filter(name -> name.startsWith("J"))

C. stream.filter(name -> name.toLowerCase().startsWith("j"))
.map(name -> name.toUpperCase())

D. stream.map(name -> name.startsWith("J"))
.filter(name -> name.toLowerCase())

Solution

1. Step 1: Filter names starting with 'J'

   Use filter(name -> name.startsWith("J")) to keep only names starting with uppercase 'J'.

2. Step 2: Map filtered names to lowercase

   Apply map(name -> name.toLowerCase()) to convert names to lowercase.

3. Final Answer:

   stream.filter(name -> name.startsWith("J")) .map(name -> name.toLowerCase()) -> Option A

4. Quick Check:

   Filter first, then map to lowercase [OK]

Hint: Filter first by condition, then map to transform [OK]

Common Mistakes:

• Mapping before filtering causing wrong results
• Using incorrect lambda syntax
• Filtering after changing case causing misses