Java Method with Enforced Array Size Parameters?

Question

I would like to create an initialisation method for a Java class that accepts 3 parameters:

Employee[] method( String[] employeeNames, Integer[] employeeAges, float[] employeeSalaries )
{
    Employee myEmployees[] = new Employee[SIZE];// dont know what size is

    for ( int count = 0; count < SIZE; count++)
    {
        myEmployees[count] = new Employee( employeeNames[count], employeeAges[count], employeeSalaries[count] );
    }
    return myEmployees;
}

You may notice that this code is wrong. THe SIZE variable is not defined. My problem is that I would like to pass in 3 arrays, but I would like to know if I can ensure that the three arrays are ALL of the same array size. This way the for loop will not fail, as the constructor in the for loop uses all the parameters of the arrays.

Perhaps Java has a different feature that can enforce a solution to my problem. I could accept another parameter called SIZE which will be used in the for loop, but that doesn't solve my problem if parameters 1 and 2 are of size 10 and the 3rd parameter is an array of size 9.

So just to rehash incase I wasn't clear. How can I enforce that the 3 arguments are all arrays that contain the exact same number of elements?

Using an extra parameter that specifies the array sizes isn't very elegant and kind of dirty. It also doesn't solve the problem the array parameters contain different sized arrays.

Answer 1

You can't enforce that at compile-time. You basically have to check it at execution time, and throw an exception if the constraint isn't met:

Employee[] method(String[] employeeNames,
                  Integer[] employeeAges,
                  float[] employeeSalaries)
{
    if (employeeNames == null
        || employeeAges == null 
        || employeeSalaries == null)
    {
        throw new NullPointerException();
    }
    int size = employeeNames.length;
    if (employeesAges.length != size || employeeSalaries.length != size)
    {
        throw new IllegalArgumentException
            ("Names/ages/salaries must be the same size");
    }
    ...
}

Answer 2

Since the arrays being passed in aren't generated until runtime, it is not possible to prevent the method call from completing depending upon the characteristics of the array being passed in as a compile-time check.

As Jon Skeet has mentioned, the only way to indicate a problem is to throw an IllegalArgumentException or the like at runtime to stop the processing when the method is called with the wrong parameters.

In any case, the documentation should clearly note the expectations and the "contract" for using the method -- passing in of three arrays which have the same lengths. It would probably be a good idea to note this in the Javadocs for the method.

Answer 3

A way to skirt around the problem is to create a builder, e.g., EmployeeArrayBuilder,

public class EmployeeArrayBuilder {
   private Integer arraySize = null;
   private String[] employeeNames;
   public EmployeeArrayBuilder addName(String[] employeeNames) {
      if (arraySize == null) {
         arraySize = employeeNames.length;
      } else if (arraySize != employeeNames.length) {
         throw new IllegalArgumentException("employeeNames needs to be " + arraySize + " in length");
      }
      this.employeeNames = employeeNames;
      return this;
   }
   public EmployeeArrayBuilder addSalaries(float[] employeeSalaries) {/* similar to above */}
   public EmployeeArrayBuilder addAges(Integer[] employeeAges) {/* similar  */}
   public Employee[] build() {
       // here, you can do what you needed to do in the constructor in question, and be sure that the members are correctly sized.
       Employee myEmployees[] = new Employee[arraySize ];// dont know what size is            
       for ( int count = 0; count < arraySize ; count++) {
            myEmployees[count] = new Employee( employeeNames[count], employeeAges[count], employeeSalaries[count] );
       }
       return myEmployees;
   }
}