@NotNull, @NotBlank, @NotEmpty in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference between @NotNull and @NotEmpty

Which statement correctly describes the difference between @NotNull and @NotEmpty annotations in Spring Boot validation?

A <code>@NotNull</code> ensures the value is not null, but allows empty strings or collections; <code>@NotEmpty</code> ensures the value is not null and not empty (for strings, collections).

B <code>@NotNull</code> only works on strings; <code>@NotEmpty</code> only works on collections.

C <code>@NotNull</code> ensures the value is not null and not empty; <code>@NotEmpty</code> only checks for null values.

D <code>@NotNull</code> and <code>@NotEmpty</code> are interchangeable and have the same effect.

💡 Hint

Think about whether empty strings or empty collections are allowed.

@NotNull only checks that the value is not null but allows empty strings or empty collections. @NotEmpty checks that the value is not null and also not empty (length > 0 for strings, size > 0 for collections).

❓ component_behavior

intermediate

Validation behavior of @NotBlank on a string field

Given a Spring Boot model with a string field annotated with @NotBlank, what input value will cause validation to fail?

Spring Boot

public class User {
    @NotBlank
    private String username;

    // getters and setters
}

A "user123" (a normal non-empty string)

B " " (a string with only spaces)

C "null" (the string literal 'null')

D "user_1" (a string with underscore)

💡 Hint

Remember what @NotBlank checks for in strings.

@NotBlank fails validation if the string is null, empty, or contains only whitespace characters. A string with spaces only is considered blank.

📝 Syntax

advanced

Correct usage of @NotEmpty on a collection

Which code snippet correctly applies @NotEmpty to a list field in a Spring Boot model to ensure it is not null and not empty?

A

public class Order {
    @NotEmpty
    private List<String> items;
}

B

public class Order {
    @NotEmpty
    private String items;
}

C

public class Order {
    @NotEmpty
    private Map<String, String> items;
}

D

public class Order {
    @NotEmpty
    private int[] items;
}

💡 Hint

Consider which data types @NotEmpty supports.

@NotEmpty supports strings, collections, maps, and arrays. Option A uses a List which is a collection, so it is valid. Option A uses a string which is valid but the question asks for a list. Option A uses a Map which is valid but the question asks for a list. Option A uses an array, not a list.

🔧 Debug

advanced

Why does @NotBlank not work on an Integer field?

Consider this Spring Boot model:

public class Product {
    @NotBlank
    private Integer quantity;
}

Why will validation fail or not work as expected?

A <code>@NotBlank</code> only works on primitive types, not wrapper classes.

B <code>@NotBlank</code> works on all object types, so this should work fine.

C <code>@NotBlank</code> requires the field to be annotated with @NotNull as well.

D <code>@NotBlank</code> only works on CharSequence (strings), so it cannot validate Integer fields.

💡 Hint

Check the supported types for @NotBlank.

@NotBlank is designed to validate strings (CharSequence). It does not apply to numeric types like Integer. For numeric fields, @NotNull or other numeric validations should be used.

❓ state_output

expert

Validation result for a complex object with mixed annotations

Given this Spring Boot model:

public class UserProfile {
    @NotNull
    private String id;

    @NotBlank
    private String name;

    @NotEmpty
    private List roles;

    // getters and setters
}

Which input will pass all validations?

A {"id": "456", "name": "Bob", "roles": []}

B {"id": null, "name": "Alice", "roles": ["user"]}

C {"id": "789", "name": "Carol", "roles": ["editor"]}

D {"id": "123", "name": "", "roles": ["admin"]}

💡 Hint

Check each annotation's requirement for each field.

@NotNull requires id not to be null.
@NotBlank requires name not to be null, empty, or whitespace.
@NotEmpty requires roles not to be null or empty.
Option C meets all these conditions.

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