每次添加/删除元素时如何验证列表？

Question

Say I have the following class, with a list as a field:

class Group {
    private List<Tile> tiles;

    public Group(List<Tile> tiles) {
        this.tiles = tiles;
    }

    public Group() {
        this(new LinkedList<>());
    }

    public List<Tile> getTiles() {
        return tiles;
    }
}

What would be the best way to ensure the list is in a valid state each time elements are added/removed ? (Currently the Tile class doesn't contain any setters so I don't need to worry about elements being modified.)

One possible way is to add a boolean field valid , and a method that updates valid , called after each time an element is added/removed:

class Group {
    // ...
    private boolean valid;
    // ...
    public void updateValid() {
        // Check list is valid...
        valid = true; // Updates `valid`
    }
}

Example usage:

group.getTiles().add(new Tile());
group.updateValid();

However, with this there is the possibility of the valid field becoming inconsistent with the list (eg if one forgets to call updateValid after adding/removing an element).

Edit

I've since realised a simpler way is to just have a method returning a boolean rather than updating a boolean field, but I'm not sure if this is ideal as it's still possible for the list to be in an invalid state.

Answer 1

The safest solution is to expose individual methods controlling access to the list, instead exposing the entire object:

class Group {
    private List<Tile> tiles;

    public Group(List<Tile> tiles) {
        // defensive copy
        this.tiles = new LinkedList<>(tiles);
    }

    public Group() {
        this.tiles = new LinkedList<>();
    }

    public boolean add(Tile tile) {
        // validate *before* inserting
        return validate(tile) && tiles.add(tile);
    }
}

If your validation logic involves other elements in the list, you can calculate it after inserting:

public void add(Tile tile) {
    tiles.add(tile);
    updateValid();  // or throw IllegalStateException
}

Another approach would be to use lazy validation instead of expecting the client to call an extra method:

public boolean isValid() {
    boolean valid = ... // validation logic here
    return valid;
}

Depending on your read/write ratio, this could be more or less expensive than the eager validation you're proposing.

Answer 2

The updateValid() method is a good idea to validate the adding/removing operation.
To force the constraint, this method should not be called by client of the class as in your usage example but by the internal of the class, that is : any method of Group that modifies the List should call the private updateValid() method.

Besides, which is the usefulness of the boolean valid field? If a validation fails, should you not stop the processing and throw an exception ?
Otherwise, it means that the current state of the Group object could be inconsistent. Which seems undesirable.
You could do it for example :

private void updateValid() {
     if (...){  // is not valid
         throw new IllegalArgumentException("modification not valid");
     }
}

At last, as shmosel said, you should also avoid to provide a public method that get the real list. You could do a defensive copy to avoid change by the clients :

public List<Tile> getTiles() {
    return new LinkedList(tiles);
}