Java multidimensional multi type Array (Map/List/Collection)?

We have a declaration like this:

ArrayList<Map<String, Map<Integer, Object>>> parameterSet = new ArrayList<Map<String, Map<Integer, Object>>>();

Probably it's possible to define it in a way like this (I know, it's wrong, please take it as pseudo code):

List<List<String, Integer, Object>> parameterSet = new ...;

I'm pretty sure, there is a better way to define such a two dimensional multi-type "array".

The problem here is not the dimension but the "multi-type".

Either you find a common super-type for your elements (last resort can always be Object) or you create a wrapper class that can hold whatever type you need.

List<Object> 

Having Object objects is fast and "easy" but it can get messy when you need to cast the elements to their actual class. Depending on how many different types you want to hold in you list, the ifs can become quite complex:

Object elem = mylist.get(i);
if(elem instanceof Float){
   Float floatElem = (Float) elem;
}
...

More precise would be the wrapper class

public class Wrapper<T>  {
     private T data;

     // constructors can be nice
     public Wrapper(Float f){this.data=f;}
     public Wrapper(Double d){this.data=d;}
     public Wrapper(String s){this.data=s;}

     public void setData(T newData) {
         data = newData;
     }

     public T getData() {
         return data;
     }

     // you can add convenience methods to find out what type your wrapper holds
     public boolean isString(){
         return this.data instanceof String;  // for example
     }

     // and also convenience methods to "cast" your data 
     public Float asFloat(){
        return (Float) this.data;
     }
}

Then your List will only need to hold your wrapper class

List<Wrapper> list = new ArrayList<>();
list.add(new Wrapper<Float>(1.2f));

And to check the type of your element you can use your convenience methods:

if(list.get(i).isFloat()){
  Float f = list.get(i).asFloat();
}

Using standard Java Collection API, you can do basically 2 things:

1. Use List instead of ArrayList in the declaration: List<Map<String, Map<Integer, Object>>> parameterSet = new ArrayList<Map<String, Map<Integer, Object>>>();
2. Use the diamond operator (if you are using Java 7+): List<Map<String, Map<Integer, Object>>> parameterSet = new ArrayList<>();

Still, in this case, I would consider defining a class encapsulating the complex data structure (map of map).