try {
<code>
} catch (<exception type1> <parameter1>) { // 0 or more
<statements>
}
} finally { // finally block
<statements>
}

public class CollectionUtil{
  public static void performSomething(Collection collection) {
    Iterator iterator = collection.iterator();
    while(iterator.hasNext()){
      Object object = iterator.next();
      //do something to object here...
    }
  }
}
//By using subtypes of Collection, this method is called: 
Set  set  = new HashSet();
List list = new ArrayList();

CollectionUtil.performSomething(set);
CollectionUtil.performSomething(list);

Collection collection   = new HashSet();
boolean containsElement = collection.contains("an element");

Collection elements     = new HashSet();
boolean containsAll     = collection.containsAll(elements);

Collection myCollection = new HashSet();
//... add elements to the collection

Iterator iterator = myCollection.iterator();
while(iterator.hasNext()){
    Object object = iterator.next();
    //do something to object;    
}

//You can also use the new for-loop: 

Collection myCollection = new HashSet();
//... add elements to the collection

for(Object object : collection) {
  //do something to object;
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SimpleSort {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(5);
        list.add(4);
        list.add(3);
        list.add(7);
        list.add(2);
        list.add(1);
        Collections.sort(list);
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

public void processElements(List<Object> elements){
   for(Object o : elements){
      System.out.println(o);
   }
}

List<?> listOfUnknown = new ArrayList<?>();    
//ProcessElements() method could be defined as following: 
public void processElements(List<?> elements){
   for(Object o : elements){
      System.out.println(o);
   }
}
//ProcessElements() could be called with any kind of generified List instance. For Example: 
List<String> elements = new ArrayList<String>
// ... add String elements to the list.
processElements(elements);

public static <T> T add(T element, Collection<T> collection){
    collection.add(element);
    return element;
}

String stringElement = "stringElement";
List<String> stringList = new ArrayList<String>();
String theElement = add(stringElement, stringList);    
Integer integerElement = new Integer(123);
List<Integer> integerList = new ArrayList<Integer>();
Integer theElement = add(integerElement, integerList);

String stringElement = "stringElement";
List<Object> objectList = new ArrayList<Object>();
Object theElement = add(stringElement, objectList);

Object objectElement = new Object();
List<String> stringList = new ArrayList<String>();
Object theElement = add(objectElement, stringList);

public class GenericTestFactory<E> {
    Class myClass = null;
    public GenericTestFactory(Class myClass) {
        this.myClass = myClass;
    }
    public E createInstance()
    throws IllegalAccessException, InstantiationException {
        return (E) this.myClass.newInstance();
    }
}

GenericTestFactory<MyClass> factory =
    new GenericTestFactory<MyClass>(MyClass.class);
MyClass myClassInstance = factory.createInstance();

GenericTestFactory<MyClass> factory =
    new GenericTestFactory<MyClass>(MyClass.class);
MyClass myClassInstance = factory.createInstance();
GenericTestFactory<SomeObject> factory =
    new GenericTestFactory<SomeObject>(SomeObject.class);
SomeObject someObjectInstance = factory.createInstance();

Map<Integer, String> set = new HashMap<Integer, String>;

Map<Integer, String> map = new HashMap<Integer, String>;
Integer key1   = new Integer(123);
String  value1 = "value 1";
map.put(key1, value1);
String value1_1 = map.get(key1);

Map<Integer, String> map = new HashMap<Integer, String>;
Iterator<Integer> keyIterator   = map.keySet().iterator();
while(keyIterator.hasNext()){
  Integer aKey   = iterator.next();
  String  aValue = map.get(aKey);
}

Iterator<String>  valueIterator = map.values().iterator();
while(valueIterator.hasNext()){
  String aString = valueIterator.next();
}

Set<String> set = new HashSet<String>;

Set<String> set = new HashSet<String>;
String string1 = "a string";
set.add(string1);

Set<String> set = new HashSet<String>;
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
  String aString = iterator.next();
}

List<String> list = new ArrayList<String>;

List<String> list = new ArrayList<String>;
String string = "my string";
list.add(string);
string2 = list.get(0);

List<String> list = new ArrayList<String>;
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
  String aString = iterator.next();
}

List<String> list = new ArrayList<String>;
for(String aString : list) {
    System.out.println(aString);
}

Set<String> set = new HashSet<String>;
for(String aString : set) {
    System.out.println(aString);
}

public class Box<T> {

    private T t;          

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public <U> void inspect(U u){
        System.out.println("T: " +
            t.getClass().getName());
        System.out.println("U: " +
            u.getClass().getName());
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = 
            new Box<Integer>();
        integerBox.add(new Integer(10));
        integerBox.inspect("some text");
    }
}

T: java.lang.Integer
U: java.lang.String

public class Box<T> {

    // T stands for "Type"
    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

Box<Integer> integerBox;
integerBox = new Box<Integer>();

Box<Integer> integerBox = new Box<Integer>();

List list = new ArrayList();
list.add(new Integer(2));
list.add("String");

Integer integer = (Integer) list.get(0);
String  string   = (String) list.get(1);

List<String> strings = new ArrayList<String>();
strings.add("a String");
String aString = strings.get(0);

// Get current size of heap in bytes
long heapSize = Runtime.getRuntime().totalMemory();

// Get maximum size of heap in bytes. The heap cannot grow beyond this size.
// Any attempt will result in an OutOfMemoryException.
long heapMaxSize = Runtime.getRuntime().maxMemory();

// Get amount of free memory within the heap in bytes. This size will increase
// after garbage collection and decrease as new objects are created.
long heapFreeSize = Runtime.getRuntime().freeMemory();