Arrays cannot be resized.  Use one of the classes implementing List instead.

    robert

VB has the dynamic array where you can "redim" it to another size or "redim
preserve" to resize it without nuking the contents - but Java has the
ArrayList<yourType> and related lists which is easier to work with anyway.
HTH

You could use a list but if you insist to use an array I have an
example. I wrote a JTable Model to handle sorting. I have some methods
that needs to dynamical expand and keep its data. So the following code
is what I wrote:

=====> This is what I do for adding a column.

protected void addColumn(String columnName)
{
    if (columnNames == null)
    {
        //
        // First time
        this.columnNames = new String[1];
        this.columnNames[0] = columnName;
    } else
    {
        // Create temp Object to hold current columns data plus one new
        // empty element
        Object temp[] = new Object[columnNames.length + 1];
        //
        // Copy all current Column data to temp
        System.arraycopy(columnNames, 0, temp, 0, columnNames.length);
        //
        // Added the new column name to the temp Object
        temp[temp.length - 1] = columnName;
        //
        // Rebuild the Instance Column object with all of the new data
        this.columnNames = new String[temp.length];
        System.arraycopy(temp, 0, columnNames, 0, columnNames.length);
    }
}

=====> This is what I do for adding a row.

protected void addRow(Object[] data)
{
    if (this.data == null)
    {
        this.data = new Object[1][data.length];
        //
        // loop and add the new first data row elements
        for (int j = 0; j < data.length; j++)
        {
            this.data[0][j] = data[j];
        }
    } else
    {
        //
        // Create temp Object to hold current columns data plus one new
        // empty element
        Object temp[][] = new Object[this.data.length + 1][data.length];
        //
        // Copy all current Column data to temp
        copyObjects(this.data, temp);
        //
        // Add the new column data elements
        for (int outer = 0; outer < data.length; outer++)
        {
            temp[temp.length - 1][outer] = data[outer];
        }
        //
        // Rebuild the Instance data object with all of the new data
        this.data = new Object[temp.length][data.length];
        copyObjects(temp, this.data);
        //
        // Display the data if in debug mode
        if (DEBUG) printDebugData(this.data);
        //
        // Update the JTable display with new data
        fireTableDataChanged();
    }
}

/**
 * I added this Method as a helper to manage the data[][] expansion
 *
 * @param fromdata    the data[]][] object to copy from
 * @param todata      the data[]][] object build target
 *
 * @return Object[][] return the build data[][] object
 */
protected Object[][] copyObjects(Object[][] fromdata, Object[][] todata)
{
    for (int outer = 0; outer < fromdata.length; outer++)
    {
        for (int inner = 0; inner < fromdata[outer].length; inner++)
        {
            todata[outer][inner] = fromdata[outer][inner];
        }
    }
    return todata;
}

private void printDebugData(Object[][] data)
{
    int numRows = data.length;
    int numCols = data[0].length;

    out.println();

    for (int i = 0; i < numRows; i++)
    {
        out.print("    row " + i + ":");
        for (int j = 0; j < numCols; j++)
        {
            out.print("  " + data[i][j]);
        }
        out.println();
    }
}

As other have already told you then various collections especially
ArrayList seems perfect for your usage.

If you insist on using an array and you just happen to be on
Java 1.6 (or 6 for those who prefer that name) then look at
the Arrays.copyOf methods.

Arne