An immutable object cannot be modified after it was created. Instead, a copy of the object is returned.

• Thread safety: they cannot change its state, so they cannot be corrupted by thread interference or observed in an inconsistent state.
• Atomicity of failure: if an immutable object throws an exception, it's never left in an undesirable or indeterminate state.
• Predictability: objects won't change due to coding mistakes or by 3rd party libraries. As long as we reference a data structure, we know it is the same as at the time of its creation.
• Validity: is not needed to be tested again and again. Once we create the immutable object and test its validity once, we know that it will be valid indefinitely.

Immutable classes require a separate object for each distinct value. Creating these objects can be costly, especially if they are large.

• make fields private and final
• methods that alters the object state should return new objects
• make copies of caller provided data (except primitives or immutable objects)
• ensure the class cannot be overridden (make the class final, or use static factories and keep constructors private)
• don't provide setter methods for variables.

final class Record {
 
  private final long id;
  private final String name;
  private final List<String> tokens;
 
  public Record(long id, String name, List<String> tokens) {
    this.id = id;
    this.name = name;
    this.tokens = tokens;
  }
 
  public long getId() {
    return id;
  }
 
  public String getName() {
    return name;
  }
 
  public List<String> getTokens() {
    return new ArrayList<>(tokens);
  }
 
  @Override
  public String toString() {
    return "Record{" +
        "id=" + id +
        ", name='" + name + '\'' +
        ", tokens=" + tokens +
        '}';
  }
}