Populating Lists with harcoded data I have a class MassiveDTO that contains lists. At some point in the project, I need to generate an object of this class, that will contain some hardcoded data. 
I would like to know if there is a better way (or a design pattern) to populate those lists with known data. 

With the method generateLists I populate them and I use them later on.
Keep in mind, I need this class not to be static because I reuse it on the project.

MassiveDTO class

public class MassiveDTO {

  private List&lt;String&gt; company = new ArrayList&lt;&gt;();
  private List&lt;String&gt; partners = new ArrayList&lt;&gt;();
  private List&lt;String&gt; biodata = new ArrayList&lt;&gt;();

  public MassiveDTO(){}

  public MassiveDTO(List&lt;String&gt; company, List&lt;String&gt; partners, List&lt;String&gt; biodata) {
    super();
    this.company = company ;
    this.partners = partners ;
    this.biodata = biodata;
  }


  /** Getters and Setters **/
  public List&lt;String&gt; getCompany() {
    return company;
  }

  public void setCompany(List&lt;String&gt; company) {
    this.company = company;
  }

  public List&lt;String&gt; getPartners() {
    return partners;
  }

  public void setPartners(List&lt;String&gt; partners) {
    this.partners = partners;
  }

  public List&lt;String&gt; getBiodata() {
    return biodata;
  }

  public void setBiodata(List&lt;String&gt; biodata) {
    this.biodata = biodata;
  }

  public void generateLists(){
    /** Company**/
    company.add("X0788");
    company.add("X0192");


    /** Partners **/
    partners.add("X0081");

    /** Biodata**/
    biodata.add("X0913");

  }

}


My first idea is to create another static class that will extend MassiveDTO in order to reuse those lists, and that class will be static because I will only need it to contain those specific lists with their data.
So you need to separate the construction of that class from the class itself? This is the Factory Pattern.

Data class

Boil down to your DTO to ... well the data.

public class MassiveDTO {
    private final List&lt;String&gt; company;
    private final List&lt;String&gt; partners;
    private final List&lt;String&gt; biodata;

  /**
   * @see MassiveDTOBuilder
   */
  MassiveDTO(List&lt;String&gt; company, List&lt;String&gt; partners, List&lt;String&gt; biodata) {
    this.company = company;
    this.partners = partners;
    this.biodata = biodata;
  }
   ... getters only
}


Factory Pattern

Then have a second class, MassiveDTOFactory, that calls that constructor with suitable fixed values.

public class MassiveDTOFactory {
  public static MassiveDTO create() {
    return new MassiveDTO(
      List.of("X0788", "X0192"), // Here we use Java 9 immutable collections
      List.of("X0081"),
      List.of("X0913")
    );
  }
}


Fluent Builder Pattern

If you wish more flexibility on the values then a Fluent Builder is for you. Something like this: 

public class MassiveDTOBuilder {
  private List&lt;String&gt; companies = new ArrayList&lt;&gt;();
  private List&lt;String&gt; partners = new ArrayList&lt;&gt;();
  private List&lt;String&gt; biodata = new ArrayList&lt;&gt;();

  public static MassiveDTOBuilder massiveDto() {
    return new MassiveDTOBuilder();
  }

  private MassiveDTOBuilder() {
  }

  public MassiveDTOBuilder withCompany(String... items) {
    for (String i : items) {
      companies.add(i);
    }
    return this;
  }

  public MassiveDTOBuilder withPartner(String... items) {
    for (String i : items) {
      partners.add(i);
    }
    return this;
  }

  public MassiveDTOBuilder withBiodata(String... items) {
    for (String i : items) {
      biodata.add(i);
    }
    return this;
  }

  public MassiveDTO build() {
    return new MassiveDTO(
      Collections.unmodifiableList(companies),
      Collections.unmodifiableList(partners),
      Collections.unmodifiableList(biodata)
    );
  }
}


Which can used like:

MassiveDTO m = massiveDto()
  .withCompany("X0788", "X0192")
  .withPartner("X0081")
  .withBiodata("X0913")
  .build();