having problems with arraylist arrayList<int[]>

When you have a fixed size for element (as array) in your collection. Your solution is OK and that is a fast way.

But when your element does not have a fixed size, such as: [[1,2,3],[4,5],[6],[7,8,9,10,11]] so you can interator through your element:

for(int[] e : sparseArr)
{
    for(int number : e)
    {
        tree.add(number);
    }
}

No matter how many element in your sparseArr, no how long of your element>

To sort your element, I recommend you should use TreeSet<E>, element push into tree will be sorted automatically.

So if you just want to store 2 Integers paired together I recommend going with HashMaps. In your case you would use:

HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

HashMaps support .containsKey(key); as well as .containsValue(value);

If you want to check all entries you can transform the Map to an entrySet:

for(Entry<Integer, Integer> e : map.entrySet()) {
    int one = e.getKey();
    int two = e.getValue();
}

Unless you want to do something more special than just storing 2 paired Integers I really can recommend doing it this way!

The method you're after should do something like this

public int[] sparseToDense (ArrayList<int[]> sparse) {
  int i = 0;
  int[] dense = new int[sparse.get(sparse.size()-1)[0]];
  int[] sp;
  ListIterator<int[]> iter = sparse.listIterator();
  while (iter.hasNext()) {
    sp = iter.next();
    while (sp[0] != i) {
      dense[i++] = 0;
    }
    dense[i++] = sp[1];
  }
  return dense;
}

Just another way to do that, since you have java 8, you will be able to use stream. But if you're a beginner, i recommend you to try with for loops and arrays, will be better for your learning.

     public static ArrayList<Integer> returnDense(ArrayList<int[]> sparse) {
        return sparse.stream().flatMap(p -> IntStream.of(p).boxed())
              .collect(Collectors.toCollection(ArrayList::new));
     } 

also if you decide change int[] to Integer[].

public ArrayList<Integer> returnDense(ArrayList<Integer[]> sparse) {
    return sparse.stream().flatMap(p -> Arrays.asList(p).stream()).filter(Objects::nonNull)
        .collect(Collectors.toCollection(ArrayList::new));
    }

.filter(Objects::nonNull) is to be sure that will not have nulls values, but if you know that will not have it, that isn't necessary.