ArrayList help

Normal declaration:

ArrayList myList = new ArrayList();

This list can hold anything:

myList.add(new String(""));
myList.add(new Integer(1);
myList.add(true);

All of this will work.

By saying ArrayList<Object> you state that the list can only hold elements of type Object.
Now, because everything in Java always extends the Object class, you can also put anything you want in it. The following will work with no problem:

ArrayList<Object> myList = new ArrayList<Object>();
myList.add(new String(""));
myList.add(new Integer(1);
myList.add(true);

So there is no actual difference between saying ArrayList or ArrayList<Object>.
Note you can't store primitives into an ArrayList(int, double, float, short, byte, boolean, long, char).
If you want to put those into the list, you need to use their wrapper class (Integer, Double, Float, Short, Byte, Boolean, Long, Character)
This however works:

ArrayList<Integer> myList = new ArrayList<Integer>();
int i=1;
myList.add(i);

Quote

What? You just said you can't put primitives into an ArrayList.

Correct, but when you compile this, the compiler will make sure the int is transformed into an Integer properly. This is called "autoboxing" (more info: Autoboxing)

You should also know that this restriction of what you can put in an ArrayList (or any other Collection) is only checked at compile-time, and not at runtime.
You write down

ArrayList<Integer> myList = new ArrayList<Integer>();

After compilation, and what Java will actually be running is:

ArrayList myList = new ArrayList();

This! The JVM has no idea about the restrictions, it's just a List where you can put anything in.

So even though you declare an ArrayList to, say, only contain Strings. You can still dump other stuff in it if you want to:

public static void main(String[] args){
    ArrayList<String> myStrings = new ArrayList<String>();
    myMethod(myStrings);
    for(String word : myStrings){
        System.out.println(word);
    }
}

public static void myMethod(List myList){ //Compiler can't see what kind of List will be send here. At runtime Java doesn't notice there's an "ArrayList<String>" here, because at runtime only "ArrayList" remains.
    myList.add(1);
    myList.add(true);
}

This example compiles with no problem (possibly a warning, but it will compile). But this definitely crashes at runtime.

If this myMethod was written with the generics, this wouldn't have compiled:

public static void myMethod(List<String> myList){ 
    myList.add(1);  //Compiler sees this can't be put in that List -> compilation fails.
    myList.add(true);
}

So always try to use generics to limit your collections. And when doing so, try to be as specific as possible.
By "be as specific as possible" I mean, if you know the list will only contain Integer elements, then also declare it that way:

List<Integer> goodList = new ArrayList<Integer>();
List<Number> somewhatGoodList = new ArrayList<Number>();
List<Object> badList = new ArrayList<Object>();

(Integer extends Number, but so do BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short. So you're not 100% your list will contain Integers.)