What's new in Java 1.5

Java Collection: Generic in Java 5.0 vs old version

Charles Li
Copyright © 2004-2006
secret

In this article, we use examples to illustrate the new feature known as generics in Java 5.0.

You can refer to J2SE 1.5 in a Nutshell.
You can download the Java 1.5.0 beta version at J2SE 1.5 beta 1.

How to compile

To compile programs written in Java 1.5, use(may be outdated)

javac -source 1.5 XXX.java

Generic Types

Java 1.4: Old1.java

The program prints out fruit names with a 'n'.
You have to do type casting to cast it to a String in order to use indexOf method. What a headache!

import java.util.*;

public class Old1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Orange");
        list.add("Apple");
        list.add("Pineapple");
        list.add("Lemon");
        list.add("Pear");
        for(int i=0; i <  list.size(); i++) {
            String s = (String)list.get(i);
            if(s.indexOf('n' ) &t;= 0) {
                System.out.println(s);
            }
        }
    }
}

Java 1.5: New1.java

To compile, use javac -source 1.5 New1.java.
No more type casting!
Use List<String> list = new ArrayList<String>(); to create a List of String. You can replace String by other class.

import java.util.*;

public class New1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Orange");
        list.add("Apple");
        list.add("Pineapple");
        list.add("Lemon");
        list.add("Pear");
        for(int i=0; i <  list.size(); i++) {
            String s = list.get(i); // no need to type cast
            if(s.indexOf('n' ) >= 0) {
                System.out.println(s);
            }
        }
    }
}

Java 1.4 : Old2.java

Find out the average scores

import java.util.*;

public class Old2 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("Amy", new Integer(55));
        map.put("Ben", new Integer(68));
        map.put("Charles", new Integer(88));
        map.put("Dave", new Integer(88));
        map.put("Betty", new Integer(100));
        double sum = 0;
        Collection scores = map.values();// get all the scores
        for(Iterator i = scores.iterator(); i.hasNext();) {
            sum+=((Integer)i.next()).intValue();
        }
        System.out.println("Average is: "  + sum/scores.size());
    }
}

Java 1.5 : New2.java

Map<String, Integer> map = new HashMap<String, Integer>() is a map with key type String and value type Integer
Collection<Integer> scores = map.values() : create a Collection of Integer.
Iterator i = scores.iterator() : create an iterator of Integers.
sum+=i.next().intValue(): no type casting.

public class New2 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("Amy", new Integer(55));
        map.put("Ben", new Integer(68));
        map.put("Charles", new Integer(88));
        map.put("Dave", new Integer(88));
        map.put("Betty", new Integer(100));
        double sum = 0;
        Collection<Integer> scores = map.values();// get all the scores
        for(Iterator<Integer> i = scores.iterator(); i.hasNext();) {
            sum+=i.next().intValue();
        }
        System.out.println("Average is: "  + sum/scores.size());
    }
}

Autoboxing and Auto-unboxing of Primitive Types

Converting between primitive types, like int, boolean, and their equivalent Object-based counterparts like Integer and Boolean, can require unnecessary amounts of extra coding, especially if the conversion is only needed for a method call to the Collections API, for example.
The autoboxing and auto-unboxing of Java primitives produces code that is more concise and easier to follow. The 1.5 version leaves the conversion required to transition to an Integer and back to the compiler.

Java 1.4: Old3.java

You have to covert primitive type double to Double class or in the other way around.

import java.util.*;

public class Old3 {
    public static void main(String[] args) {
        double[] array = {2,5, 7.94, 8.21, 3.14, 2.72};
        ArrayList list = new ArrayList();
        for(int i = 0; i < array.length; i++) {
            list.add(new Double(array[i]));
        }
        
        // find the sum of the doubles in the list
        double sum=0;
        for(int i = 0; i < list.size(); i++) {
            double num = ((Double)list.get(i)).doubleValue();
            sum+=num;
        }
        System.out.println("Sum: " + sum);
    }
}

Java 1.5: New3.java

The conversion between double and Double are automatically done by compiler.

public class New3 {
    public static void main(String[] args) {
        double[] array = {2,5, 7.94, 8.21, 3.14, 2.72};
        ArrayList<Double> list = new ArrayList<Double>();
        for(int i = 0; i < array.length; i++) {
         // expect an Object as argument, but automatically changed to Double
            list.add(array[i]);
        }
        
        // find the sum of the doubles in the list
        double sum=0;
        for(int i = 0; i < list.size(); i++) {
            // returns a Double, but automatically converted to Double
            double num = list.get(i); 
            sum+=num;
        }
        System.out.println("Sum: " + sum);
    }
}

Enhanced for loop

java 1.4: Old4.java

Similar to Old1.java. Use iteration instead.

import java.util.*;

public class Old4 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Orange");
        list.add("Apple");
        list.add("Pineapple");
        list.add("Lemon");
        list.add("Pear");
        for(Iterator i = list.iterator(); i.hasNext();) {
            String s = (String)i.next();
            if(s.indexOf('n') >= 0) {
                System.out.println(s);
            }
        }
    }
}

Java 1.5 : New4.java

for(String s : list): it means for each String s in the list .....

import java.util.*;

public class New4 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Orange");
        list.add("Apple");
        list.add("Pineapple");
        list.add("Lemon");
        list.add("Pear");
        for(String s : list) { // read as for each s in list 
            if(s.indexOf('n') >= 0) {
                System.out.println(s);
            }
        }
    }
}

java 1.4: Old4.java

public class Old5 {
    public static void main(String[] args) {
        int[] a= {1,3,5,3,4,2,4};
        for(int i=0; i < a.length; i++) {
            int x =a[i];
            System.out.println(x);
        }
    }
}

java 1.5: New5.java

array is also a collection.

public class New5 {
    public static void main(String[] args) {
        int[] a= {1,3,5,3,4,2,4};
        for(int x : a) {
            System.out.println(x);
        }
    }
}

Java 1.5: New2b.java

with all the technique you learn, here is a new verion of New2.java

import java.util.*;

public class New2b {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("Amy", 55);
        map.put("Ben", 68);
        map.put("Charles", 88);
        map.put("Dave", 88);
        map.put("Betty", 100);
        double sum = 0;
        for(int score: map.values()) {
            sum+=score;
        }
        System.out.println("Average is: "  + sum/map.values().size());
    }
}

More reference

To learn more , you can read

Gilad Bracha's generics tutorial (http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf).