Since the number of columns is a constant, you can just have an List of int[].

    import java.util.*;
    //...

    List<int[]> rowList = new ArrayList<int[]>();

    rowList.add(new int[] { 1, 2, 3 });
    rowList.add(new int[] { 4, 5, 6 });
    rowList.add(new int[] { 7, 8 });

    for (int[] row : rowList) {
        System.out.println("Row = " + Arrays.toString(row));
    } // prints:
      // Row = [1, 2, 3]
      // Row = [4, 5, 6]
      // Row = [7, 8]

    System.out.println(rowList.get(1)[1]); // prints "5"

Since it's backed by a List, the number of rows can grow and shrink dynamically. Each row is backed by an int[], which is static, but you said that the number of columns is fixed, so this is not a problem.

It may be more appropriate to use a Map<Double, List<Double>>. Having the value of the Map as a List<Double> will allow you to expand the list as opposed to an array which has a fixed size.

public static void main(String[] args) throws CloneNotSupportedException {
    Map<Double, List<Double>> myMap = create(1, 3);
}

public static Map<Double, List<Double>> create(double row, double column) {
    Map<Double, List<Double>> doubleMap = new HashMap<Double, List<Double>>();

    for (double x = 0; x < row; x++) {
        for (double y = 0; y < column; y++) {
            doubleMap.put(x, new ArrayList<Double>());
        }
    }
    return doubleMap;
}

This isn't all that easy.

You can certainly represent your grid as a List<List<Cell>>.

 public Cell getCell(int x, int y) {
       return grid.get(x).get(y);
 }

However that doesn't give you a free pass to assign to any old number:

  List<String> list = new ArrayList<>();
  list.set(5,"Hello");

... will throw an IndexOutOfBounds exception too.

You can list.add(string) as many times as you like, and each time the list will grow. But you can't set() beyond its current size.

However if you know you want a cell object for every grid position, and you know that every time it grows it will grow by one, write your algorithm to use add() not set(), and this structure will work well.

Alternatively, as you suggest, a HashMap<Coordinates, Cell> might suit your needs.

You'll need a suitable Coordinates class, with a working hashCode() and equals() implementation. Then you could do:

   Map<Coordinates, Cell> grid = new HashMap<>();
   grid.put(new Coordinates(80, 100), new Cell());

This would work especially well if you want a "grid" that's sparsely populated but effectively unbounded.

There are plenty more approaches - including implementing your own array-reallocating algorithm (after all, that's what's inside an ArrayList -- find and study its source code, if you're curious).

You should probably also step back and ask why and when you need to change the size of the grid after initialising it. A fixed-size array of fixed-size arrays is a simple solution, and worth sticking with if it works most of the time. If the size only changes occasionally, maybe you'd be better off just creating a new grid and copying the old values into it whenever that happens.

  public void setCell(int x, int y, Cell cell) {
     if(x >= this.grid.length || y >= this.grid[0].length) {
          Cell[][] newGrid = createEmptyGrid(x,y);
          copyCells(this.grid,newGrid);
          this.grid = newGrid;
     }
     this.grid[x][y] = cell;
  }

createEmptyGrid() here needs to make a decision about the new size -- just big enough to accommodate [x][y]? Or bigger just-in-case? The right thing to do depends on your broader requirements.

Initialize a new Integer[] every time you add a new row.

That is, do it like this:

Integer[] test = new Integer[3];
List<Integer[]> al = new ArrayList<Integer[]>();
int i,t;
test[0]=1;
test[1]=2;
test[2]=3;
al.add(test);
test = new Integer[3]; // Note this line
test[0]=4;
test[1]=5;
test[2]=6;
al.add(test);
test = new Integer[3]; // Note this line
test[0]=7;
test[1]=8;
test[2]=9;
al.add(test);
test = new Integer[3]; // Note this line
test[0]=10;
test[1]=11;
test[2]=12;
al.add(test);

Or better yet, do it this way:

List<Integer[]> al = new ArrayList<Integer[]>();
al.add(new Integer[]{1, 2, 3});
al.add(new Integer[]{4, 5, 6});
al.add(new Integer[]{7, 8, 9});
al.add(new Integer[]{10, 11, 12});

This isn't possible, arrays are always static in length.

Try using a list of lists.

LinkedList<LinkedList<String>> list = new LinkedList<LinkedList<String>>();

list.add(new LinkedList<String>()); // [[]]
list.get(0).add("hello"); // [["hello"]]
list.get(0).add("world"); // [["hello", "world"]]

list.add(new LinkedList<String>()); // [["hello", "world"], []]
list.get(1).add("bonjour"); // [["hello", "world"], ["bonjour"]]

The list can use any class instead of String.

To loop through the lists, you'd need to do something like the following:

for(LinkedList<String> subList : list){
    for(String str : subList){
        ...
    }
}

How about List<List<Foo>> ?

For Example:

List<List<Foo>> list = new ArrayList<List<Foo>>();

List<Foo> row1 = new ArrayList<Foo>();
row1.add(new Foo());
row1.add(new Foo());
row1.add(new Foo());
list.add(row1);

List<Foo> row2 = new ArrayList<Foo>();
row2.add(new Foo());
row2.add(new Foo());

list.add(row2);

Use collections to do this. For example:

List<List<Integer>> dynamic2D = new ArrayList<List<Integer>>();

dynamic2D.add(new ArrayList<Integer>());
dynamic2D.add(new ArrayList<Integer>());
dynamic2D.add(new ArrayList<Integer>());

dynamic2D.get(0).add(5);
dynamic2D.get(0).add(6);
dynamic2D.get(0).add(7);

System.out.println(dynamic2D.get(0).get(0)); // 5
System.out.println(dynamic2D.get(0).get(1)); // 6
System.out.println(dynamic2D.get(0).get(2)); // 7