Problem With Referenced Array Loading

Question

Hi. I'm working on the final lab for my java class at the moment, and I'm to create a program which reads a file containing transaction records, stores each record as an array element, and then prints various types of reports using the array of transactions. I've created a class called Transaction which stores all the data for each transaction, and the array used in my program is of type Transaction.
I'm not having any problems in writing the program, except there's something going wrong with my attempt to write a method to load the array. The method declaration is:
*  Method to accept a file from the user and load its data into an array.
*  Returns the number of elements added to the array.
public static int loadArray(Transaction[] transactionArray, int size) throws ExceptionNow, I'm under the impression (and my teacher confirmed this) that arrays are passed by reference. So I'm assuming that by creating an array in my main method, passing it into loadArray(), and changing the values within the method, all the data will be present in the array within main without having to explicitly return the loaded array.
However, as soon as I try to do anything with the loaded array, I get a NullPointerException. I opened up the debug mode, set a breakpoint in my main right after loadArray() is called, and it shows that every element in my array is null. I am at a loss as to why. If anyone can help me figure out why my reference array isn't staying updated as it's edited elsewhere, it would be greatly appreciated.
Here is my loadArray() code in case it would help, but there is no error in it's execution, as the same code directly in my main method works fine.
     public static int loadArray(Transaction[] transactionArray, int size) throws Exception
          int logicalSize = 0; // the number of transactions loaded into the array
          int itemID; // the item ID involved in the transaction
          int units; // the number of units in the transaction
          double unitCost; // the cost of each unit in the transaction
          char type; // the type of the transaction
          String date; // the date of the transaction
          String fileName; // the name of the user selected file
          String record; // the current record in the file
          Scanner file; // reads input from a user selected file
          Scanner parse; // reads input from the file's current record
          transactionArray = new Transaction[size]; // creates a new array for the new data
          System.out.print("Please enter a file name: ");
          fileName = input.nextLine();
          file = new Scanner(new File(fileName));
          record = file.nextLine(); // discards the initial line of headers
          while(file.hasNext())
               // grab the next record and parse all its data
               record = file.nextLine();
               parse = new Scanner(record).useDelimiter(",");
               date = parse.next();
               itemID = parse.nextInt();
               type = parse.next().toUpperCase().charAt(0);
               units = parse.nextInt();
               unitCost = parse.nextDouble();
               transactionArray[logicalSize] = new Transaction(date, itemID, type, units, unitCost); // loads the current transaction into the array
               logicalSize++;
          return logicalSize;
     }Thanks!
Oh, I guess I should also add that the variable input is a global variable of type Scanner.
static Scanner input = new Scanner(System.in); // reads input from keyboardMessage was edited by:
Kristofer.Ward

Answer 1

Now, I'm under the impression (and my teacher confirmed this) that arrays are
passed by reference.Java passes references to arrays by value.
So I'm assuming that by creating an array in my main method, passing it into
loadArray(), and changing the values within the method, all the data will be present
in the array within main without having to explicitly return the loaded array.Bearing in mind my statement above, what really happens is that a reference to
the array you created is passed to loadArray() by value. What I mean by that
last bit is that your loadArray() is free to assign a reference to a completely
different array to its argument variable and the caller will not notice the change.
That's what's happening here:public static int loadArray(Transaction[] transactionArray, int size) throws Exception
    // declarations of local variables
         * The argument variable is now assigned a reference to a completely
         * new array.  When this function returns the variable the caller used to
         * invoke this method will have exactly the same value it did before this
         * method was invoked.  Ie it will *still* refer to an array of nulls.
    transactionArray = new Transaction[size];
    // more stuff - that involves changing the contents of
    // the newly created array, not the one the caller has
    // a reference to.
    return logicalSize;
}