Cú pháp và các tính năng mới trong Java 5

//Đoạn code của interface java.util.List trong phiên bản 1.4.2
 interface List{
  void add(Object o);
  Iterator iterator();
 }
//Đoạn code của interface java.util.Iterator trong phiên bản 1.4.2
 interface Iterator{
  Object next();
  boolean hasNext();
 }

// Đoạn code của interface java.util.List trong phiên bản 1.5
 interface List<E> {
   void add(E x);
   Iterator<E> iterator();
  }
// Đoạn code của interface java.util.Iterator trong phiên bản 1.5
interface Iterator<E>{
   E next();
   boolean hasNext();
 }

java.util.List<Number> list=new java.util.ArrayList<Number>();

LinkedList<Integer> li =new LinkedList<Integer>();
     li.add(new Integer(0));
     Integer i = li.iterator().next();

Vector v = new Vector();
v.add(new Integer(4));
...
String s=(String)v.get(0);

// ClassCastException
String s = (String)v.get(0);

Vector<String> vs = new Vector<String>();
vs.add(new Integer(5)); // Compile Error!!
vs.add(new String("hello"));
String s = vs.get(0); // No need cast

HashMap<String, Mammal> map =new HashMap<String, Mammal>();
map.put("wombat", new Mammal("wombat"));
Mammal w = map.get("wombat");

ArrayList<Integer> ai = new ArrayList<Integer>();
ArrayList<Object> ao = ai;
ao.add(new Object());
Integer i = ai.get(0);

ArrayList<Number> an = new ArrayList<Number>();
an.add(new Integer(5)); // OK
an.add(new Long(1000L)); // OK
an.add(new String("hello")); // Error In Compile time!!

static void printCollection(Collection<?> c) {
    for (Object o : c)
     System.out.println(o);
  }
   
  public static void main(String[] args) {
    List<Integer> li = new ArrayList<Integer>(10);
     printCollection(li); // OK at Compile time
     Collection<String> cs = new Vector<String>();
     printCollection(cs); // OK at Compile time
  }

void printCollection(Collection<? extends Object> c){..}

static void printCollection(Collection<? extends Number> c) {
    for (Object o : c)
    System.out.println(o);
  }
    
  public static void main(String[] args) {
    List<Integer> li = new ArrayList<Integer>(10);
    printCollection(li);  // OK

    List<Long> ll = new ArrayList<Long>();
    printCollection(ll);  // OK

    Collection<String> cs = new Vector<String>();
    printCollection(cs); // Error at Compile time.
  }

ArrayList<?> a1 = new ArrayList<Number>(10);

a1.add(new Integer(3)); // Error at Compile time
a1.add(new Long(100L)); // Error at Compile time
a1.add(new Object()); // Error at Compile time

a1.add(null);
Object o = a1.get(0);

Number n = a1.get(0);// Error at Compile time
Integer i = a1.get(0);// Error at Compile time

ArrayList<Number> a1 = new ArrayList<Number>();
// thay cho khai báo
// Instead of declare
ArrayList<?> a1 = new ArrayList<Number>();

public class Pair<F, S> {
    F first;
    S second;

    public Pair(F f, S s) {
        first = f;
        second = s;
    }
}

public class Pair<F, S> {
    F first;
    S second;

    public Pair(F f, S s) {
        first = f;
        second = s;
    }

    public void setFirst(F f) {
        first = f;
    }

    public F getFirst() {
        return first;
    }

    public void setSecond(S s) {
        second = s;
    }

    public S getSecond() {
        return second;
    }
}

Number n1 = new Integer(5);
String s1 = new String("Sun");
Pair<Number,String> p1 =new Pair<Number,String>(n1, s1);
 
p1.setFirst(new Long(6L));
p1.setSecond(new String("rises"));

public class PairExtended<F, S, T> extends Pair<F, S> {
    T third;

    
    PairExtended(F f, S s, T t) {
        super(f, s);
        third = t;
    }

    public T getThird() {
        return third;
    }
}

public class Pair<F, S> {
   F first;
   S second;

   public Pair(F f, S s) {
       first = f;
       second = s;
   }

   public void setFirst(F f) {
       first = f;
   }
}

// Class thừa kế class Pair chỉ rõ F
public class PairExtended1<S> extends Pair<String, S> {
   public PairExtended1(String f, S s) {
       super(f, s);
   }

   public PairExtended1(S s) {
       this("String default", s);
   }
}

// Class thừa kế class Pair chỉ rõ cả F và S
public class PairExtended2 extends Pair<String, Integer> {
   public PairExtended2(String f, Integer s) {
       super(f, s);
   }
}

// Kiểu Generic cụ thể hóa bởi kiểu tham số
List<String> ls = new LinkedList<String>();
// Kiểu Generic cụ thể hóa với không kiểu tham số nào
// tham số thô
List lraw = new LinkedList();

// Đúng hay sai ?
// True or False?
ArrayList<Integer> ai = new ArrayList<Integer>();
ArrayList<String> as = new ArrayList<String>();
boolean b1 = (ai.getClass() == as.getClass());
System.out.println("ai.getClass().getName():"+ai.getClass().getName());
System.out.println("as.getClass().getName():"+as.getClass().getName());
System.out.println(" Do ArrayList<Integer> "
            +"and ArrayList<String> share same class? " + b1);

ai.getClass().getName():java.util.ArrayList
      as.getClass().getName():java.util.ArrayList
      Do ArrayList<Integer> and ArrayList<String> share same class? true