@NotNull, @NotBlank, @NotEmpty in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to ensure the 'name' field cannot be null.

Spring Boot

public class User {
    @[1]
    private String name;
}

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

ANotEmpty

BNotBlank

CNotNull

DSize

Attempts:

3 left

💡 Hint

Common Mistakes

Using @NotBlank instead of @NotNull when only null check is needed.

Confusing @NotEmpty with @NotNull.

The @NotNull annotation ensures the field is not null but allows empty strings.

2fill in blank

medium

Complete the code to ensure the 'username' field is not null and not empty (no blank spaces).

Spring Boot

public class Account {
    @[1]
    private String username;
}

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

ANotEmpty

BNotNull

CSize(min=1)

DNotBlank

Attempts:

3 left

💡 Hint

Common Mistakes

Using @NotEmpty which allows strings with only spaces.

Using @NotNull which allows empty strings.

The @NotBlank annotation ensures the string is not null, not empty, and not just whitespace.

3fill in blank

hard

Fix the error in the code to ensure the 'tags' list is not null and contains at least one element.

Spring Boot

public class BlogPost {
    @[1]
    private List<String> tags;
}

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

ANotEmpty

BNotBlank

CNotNull

DSize(min=1)

Attempts:

3 left

💡 Hint

Common Mistakes

Using @NotBlank on a collection causes errors.

Using @NotNull allows empty collections.

The @NotEmpty annotation ensures the collection is not null and has at least one element.

4fill in blank

hard

Fill both blanks to validate 'email' so it is not null and not blank.

Spring Boot

public class Contact {
    @[1]
    @[2]
    private String email;
}

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

ANotNull

BNotBlank

CNotEmpty

DEmail

Attempts:

3 left

💡 Hint

Common Mistakes

Using only @NotNull allows blank strings.

Using only @NotEmpty does not check for blank spaces.

Using both @NotNull and @NotBlank ensures the email is not null and not blank. However, @NotBlank alone is enough for strings, but sometimes both are used for clarity.

5fill in blank

hard

Fill all three blanks to create a map of word lengths for words longer than 3 characters.

Spring Boot

Map<String, Integer> wordLengths = words.stream()
    .filter(word -> word.length() [1] 3)
    .collect(Collectors.toMap(
        word -> word.[2](),
        word -> word.[3]()
    ));

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

A>

BtoUpperCase

Clength

DstartsWith

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > in filter.

Using startsWith instead of toUpperCase for keys.

Using toUpperCase instead of length for values.

The filter uses > to select words longer than 3. The key is the uppercase word using toUpperCase(), and the value is the word length using length().

Practice

1. Which annotation ensures a string field in a Spring Boot application is not null, but allows empty strings?

easy

A. @NotEmpty

B. @NotBlank

C. @NotNull

D. @Valid

Solution

1. Step 1: Understand @NotNull behavior

   @NotNull only prevents the value from being null but allows empty strings or collections.

2. Step 2: Compare with other annotations

   @NotEmpty and @NotBlank prevent empty values, so they are stricter than @NotNull.

3. Final Answer:

   @NotNull -> Option C

4. Quick Check:

   @NotNull allows empty but not null [OK]

Hint: Remember: @NotNull forbids null, allows empty [OK]

Common Mistakes:

• Confusing @NotNull with @NotEmpty or @NotBlank
• Thinking @NotNull forbids empty strings
• Assuming @Valid checks null automatically

2. Which of the following is the correct way to annotate a string field that must not be null, empty, or only spaces in Spring Boot?

easy

A. @NotBlank private String name;

B. @NotEmpty private String name;

C. @NotNull @NotEmpty private String name;

D. @NotNull private String name;

Solution

1. Step 1: Identify annotation that forbids null, empty, and spaces

   @NotBlank ensures the string is not null, not empty, and not just whitespace.

2. Step 2: Check other options

   @NotNull allows empty or spaces; @NotEmpty forbids empty but allows spaces; only @NotBlank covers all three.

3. Final Answer:

   @NotBlank private String name; -> Option A

4. Quick Check:

   @NotBlank forbids null, empty, spaces [OK]

Hint: Use @NotBlank for strings with no spaces or empties [OK]

Common Mistakes:

• Using @NotEmpty but ignoring spaces
• Combining @NotNull and @NotEmpty unnecessarily
• Assuming @NotNull forbids empty strings

3. Given the code snippet:

@NotEmpty
private List<String> tags;

What happens if tags is set to an empty list during validation?

medium

A. Validation passes because list is not null

B. Validation fails because list is empty

C. Validation fails only if list is null

D. Validation passes regardless of list content

Solution

1. Step 1: Understand @NotEmpty on collections

   @NotEmpty forbids null or empty collections, so empty list fails validation.

2. Step 2: Compare with other annotations

   @NotNull allows empty list; @NotEmpty forbids empty; @NotBlank is for strings only.

3. Final Answer:

   Validation fails because list is empty -> Option B

4. Quick Check:

   @NotEmpty forbids empty collections [OK]

Hint: @NotEmpty forbids empty lists or strings [OK]

Common Mistakes:

• Thinking empty list passes @NotEmpty
• Confusing @NotEmpty with @NotNull
• Applying @NotBlank to collections

4. Consider this code snippet:

@NotBlank
private String title;

Which of the following values for title will cause validation to fail with @NotBlank but pass with @NotEmpty?

medium

A. " " (string with spaces only)

B. "Hello"

C. "" (empty string)

D. null

Solution

1. Step 1: Understand @NotBlank validation rules

   @NotBlank forbids null, empty, and strings with only whitespace.

2. Step 2: Analyze each value

   null and "" fail both @NotBlank and @NotEmpty; "Hello" passes both; " " passes @NotEmpty (length > 0) but fails @NotBlank (trimmed length = 0).

3. Final Answer:

   " " (string with spaces only) -> Option A

4. Quick Check:

   @NotBlank forbids spaces-only strings [OK]

Hint: @NotBlank forbids spaces-only strings [OK]

Common Mistakes:

• Assuming empty string passes @NotBlank
• Confusing @NotBlank with @NotEmpty
• Ignoring spaces-only strings as invalid

5. You want to validate a user input field description that must not be null, empty, or only spaces, but also must allow strings like "0" or "false". Which annotation should you use in Spring Boot?

hard

A. @Size(min=1)

B. @NotEmpty

C. @NotNull

D. @NotBlank

Solution

1. Step 1: Understand requirements for description

   Must not be null, empty, or spaces-only, but allow "0" or "false" strings.

2. Step 2: Match annotation behavior

   @NotBlank forbids null, empty, and spaces-only strings but allows "0" and "false" as they are non-blank strings.

3. Step 3: Check alternatives

   @NotNull allows empty; @NotEmpty forbids empty but allows spaces; @Size(min=1) forbids empty but not spaces-only.

4. Final Answer:

   @NotBlank -> Option D

5. Quick Check:

   @NotBlank fits all conditions [OK]

Hint: Use @NotBlank to forbid null, empty, and spaces-only [OK]

Common Mistakes:

• Using @NotEmpty and missing spaces-only strings
• Assuming @Size(min=1) forbids spaces-only
• Confusing @NotNull with stricter annotations