Adding @NotNull or Pattern constraints on List

Question

How can we ensure the individual strings inside a list are not null/blank or follow a specific pattern

@NotNull
List<String> emailIds;

I also want to add a pattern

@Pattern("\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b.")

but I can live without it.But I would definitely like to have a constraint which will check if any strings inside a list are null or blank. Also how would the Json schema look like

"ids": {
      "description": "The  ids associated with this.", 
    "type": "array",
        "minItems": 1,
        "items": {
        "type": "string",
         "required" :true }
 }

"required" :true does not seem to do the job

Why not create an Object rather than String, and enforce the pattern within the object creation. Say, List eMailIds; Class EMailInfo (String emailid) .. check for valid, return null if bad; and use method get emailIds in that class — ErstwhileIII, Mar 06 '14 at 19:01
Create a derived class of List, whose add() method override does all that? — Mark W, Mar 06 '14 at 19:01
Check this http://stackoverflow.com/questions/4308224/hibernate-validation-of-collections-of-primitives — Guy Bouallet, Mar 06 '14 at 19:09

score 59 · Answer 1 · answered Jun 07 '18 at 20:50

Bean validation 2.0 (Hibernate Validator 6.0.1 and above) supports validating container elements by annotating type arguments of parameterized types. Example:

List<@Positive Integer> positiveNumbers;

Or even (although a bit busy):

List<@NotNull @Pattern(regexp="\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]{2,4}\\b") String> emails;

References:

score 12 · Accepted Answer · answered Mar 06 '14 at 19:11

You can create a simple wrapper class for the e-mail String:

public class EmailAddress {

    @Pattern("\b[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]{2,4}\b.")
    String email;

    //getters and setters
}

Then mark the field @Valid in your existing object:

@NotNull
@Valid
List<EmailAddress> emailIds;

The validator will then validate each object in the list.

score 9 · Answer 3 · edited May 23 '17 at 11:54

9

You don’t have to use any wrapper class just to validate a list of strings. Just use @EachPattern constraint from validator-collection:

@NotNull
@EachPattern(regexp="\b[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]{2,4}\b.")
List<String> values;

And that’s all. Easy, right? See this SO answer for more information.

edited May 23 '17 at 11:54

Community

1
1

answered Apr 03 '14 at 01:08

Jakub Jirutka

10,269
4
42
35

2

not sure i would advocate to use a third party library just to validate a list of strings either. – mre May 06 '18 at 14:18
especially since it's not even actively updated anymore – Deniss M. Oct 26 '20 at 07:47

score 0 · Answer 4 · answered Mar 06 '14 at 19:02

0

In my opinion, use a wrapper class for the object, and have your own verification on the methods:

public class ListWrapper<E> {

    private List<E> list = new ArrayList<>();
    private Pattern check = /*pattern*/;

    public boolean add(E obj) {
        if (this.verify(obj)) {
            return list.add(obj);
        }
        return false;
    }

    //etc

    public boolean verify(E obj) {
        //check pattern and for null
    }

Alternatively, just use a custom object for the list

answered Mar 06 '14 at 19:02

Rogue

11,105
5
45
71

I would rather extend arraylist than wrap it. Right now, methods that accept List as parameter cannot accept this class – Oskar Kjellin Mar 06 '14 at 19:06
To each their own, would depend on the use-case I suppose – Rogue Mar 06 '14 at 19:30

Adding @NotNull or Pattern constraints on List

4 Answers4

Linked

Related