You seem to need some Maps rather than Lists. Check the Javadoc for Map implementations; the most common is HashMap, but there are sorted, concurrent, deterministically iterable implementations etc. available too.

ListObject: every key corresponds to a String value; key is a string itself

Map<String, String>

ListObject: every key corresponds to an array of Strings; key is a string itself

Map<String, String[]>

(or preferably Map<String, List<String>>)

ListObject: same deal but with two value fields per key.

Map<String, UserDefinedClassWithTwoFields>

Map is a key-value pair

    public static void main(String[] args) {
        Map<Integer, Object> map;
        map = new HashMap<Integer, Object>();
        map.put(1,"any object");
        map.put(2,"fits here");
        map.put(3,5555555);
    }

An enum would suit best:

public enum Response {
  OK(200, "OK"), 
  Created(201, "Created"),
  NotFound(404, "Not found");

  private final int _code;
  private final String _message;

  Response(int code, String message) {
    _code = code;
    _message = message;
  }

  public int code() {
    return _code;
  }

  public String message() {
    return _message;
  }
}

Additional benefit of an enum is that you would operate with comprehensible constant names in code, such as Response.NotFound rather than numerical codes. If you need to really get a value by code, just add a static method to resolve the enum instance.

At the simplest level, a key-value pair is just two values, one of which you have designated to be a "key" and the other you have designated to be the "value".

However, it is more common to talk about key-value pairs in the context of a mapping, i.e. a (mathematical) function which maps from a key to the corresponding value or values. Depending on the properties of this mapping, you may constrain the set of key-value pairs. For example, for a 1-to-1 mapping, you need the keys in the set to be unique.

Follow-up questions:

Is this the same as an array?

Well ... an array could be considered as a mapping from a set of indexes (integers) to values. But a mapping is more general. And in Java, arrays have other properties that distinguish them from Maps ... and they have a much simpler, faster, and less memory-hungry implementation.

(Note that in some languages, there is no "array" data type per-se. Instead, the primitive is a "hash" or an "associative array" ... which is a more general map.)

And is a key always a string?

No. A key can be any type. (It is generally a bad idea to use a mutable type as a key, especially if your mapping is implemented using one of the standard Map types in Java. However, even that can work in some circumstances.)

Say a variable of type String points to an object or int variable points to int value. Isn't that variable a "key", and the object a "value"?

No. Or at least, not in a static language like Java. The thing that distinguishes a key-value pair from a variable binding is that the "key" object is data, and hence can take different values. By contrast, a variable's name is hard-wired in the source code of your program: you can't change it at runtime.

(In some dynamic languages, you can create new variables dynamically (at runtime), and for such languages you could argue that variables are key-value pairs in a mapping that represents the scope ... at some point in the program's execution. But Java isn't like that ...)

You need to iterate over your list, here is an example

public static void main(String[] args){
    List<LinkedHashMap<String,String>> list = new ArrayList<LinkedHashMap<String, String>>();

    LinkedHashMap<String, String> test = new LinkedHashMap<String, String>();
        test.put("a","1");
        test.put("b","2");

    list.add(test);

    for(Map<String, String> map : list){
        for(String key : map.keySet()){
            System.out.println("key: " + key + " value " + map.get(key));
        }
    }

}