J2SE 5.0 Sample Code

J2SE 5.0 (formerly known as J2SE 1.5) has some very useful enhancements.  Thanks to Josh Bloch of Sun Microsystems for helpful hints.

These community postings allow you to create new discussion threads, or reply to an existing posting.  After you click on a 'Try It!' button in a community posting, or after you press a 'New' button to start a new discussion thread, edit your code, select the type of program (J2SE 5.0 Fragment or J2SE 5.0 Class), and then 'Run It!' until it works (or you give up).  When you click on the 'Save' button, the New Posting Wizard will appear.  The wizard will prompt you for information about your code example, and then save it to the database.  Each posting contains a code example, plus comments about the code.  Next time you refresh this page your new posting will appear.

Learn more about Zamples and play with samples for other APIs. Our Amazon Web Services examples are very popular!

We would love to hear your feedback.

J2SE 5 has both language syntax and keyword changes and API changes.

J2SE 5 Language Changes

Autoboxing

Java's distinction between primitive types and their equivalent Object types was painful.  Fortunately, with the advent of autoboxing, that will become a fading memory.

// automatically convert one type to another
Integer integer = 1;
System.out.println(integer);

// mix Integer and ints in the same expression
int i = integer + 3;
System.out.println(i);

Enhanced for loop

Iterating through an array has never been easier.

int array[] = {1, 2, 3, 4};
int sum = 0;
for (int e : array)  // e is short for element; i would be confusing
    sum += e;
System.out.println(sum);

Enums

Java programmers rejoice with the availability of enums.

Sample output:

clubs
diamonds
hearts
spades

public class EnumTest {
  public static void main(String[] args) {
    for (Suit suit : Suit.values())
      System.out.println(suit);
  }

  public enum Suit { clubs, diamonds, hearts, spades };
}

Here is a more complex example.

Sample output:

penny (1) nickel (5) dime (10) quarter (25)

public class EnumFun {
  private enum Coin {
    penny(1), nickel(5), dime(10), quarter(25);
    Coin(int value) { this.value = value; }
    private final int value;
    public int value() { return value; }
  }

  public static void main(String[] args) {
    for (Coin coin : Coin.values()) 
      System.out.print(coin + " (" + coin.value() + ") ");
  }
}

Generics

The addition of generics to the Java language was a major improvement.  Take a look at how this affected the Collections classes.

Importing Static Members

No longer is it necessary to write

Math.abs(x)     Math.sqrt(x)    Math.max(a, b)

We can import methods once per class.

Sample output:

16.0
4.0
3.3

import static java.lang.Math.*;

public class Import {
    public static void main(String[] args) {
        double x = 16.0, a = 2.2, b = 3.3;
        System.out.println(abs(x));
        System.out.println(sqrt(x));
        System.out.println(max(a, b));
    }
}

Metadata

This is one of Calvin Austin's code examples.

import java.lang.annotation.*;
import java.lang.reflect.*;
                                                                                
@Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @interface debug  {
    boolean  devbuild() default false;
    int counter();
}
                                                                                
public class MetaTest {
    final boolean production=true;

    @debug(devbuild=production,counter=1) public void testMethod()  { }
                                                                               
    public static void main(String[] args) {
        MetaTest mt = new MetaTest();
        try {
            Annotation[] a = mt.getClass().getMethod("testMethod").getAnnotations();
            for (int i=0; i<a.length ; i++)  { 
                System.out.println("a["+i+"]="+a[i]+" "); 
            } 
        } catch(NoSuchMethodException e) { 
            System.out.println(e); 
        } 
    } 
}

Monitoring and Manageability

This is another one of Calvin Austin's code examples.

Monitoring and Manageability is a key component of RAS (Reliability, Availability, Serviceability) in the Java platform.  The following code reports the detailed usage of the memory heaps in the Hotspot JVM.

Sample output (reformatted):

Memory type=Non-heap memory Memory usage=init = 163840(160K) used = 533824(521K) 
   committed = 557056(544K) max = 33554432(32768K)
Memory type=Heap memory Memory usage=init = 524288(512K) used = 205088(200K) 
   committed = 524288(512K) max = 4194304(4096K)
Memory type=Heap memory Memory usage=init = 131072(128K) used = 0(0K) 
   committed = 131072(128K) max = 458752(448K)
Memory type=Heap memory Memory usage=init = 1441792(1408K) used = 0(0K) 
   committed = 1441792(1408K) max = 61997056(60544K)
Memory type=Non-heap memory Memory usage=init = 8388608(8192K) used = 1529696(1493K) 
   committed = 8388608(8192K) max = 67108864(65536K)

import java.lang.management.*;
import java.util.*;

public class MemTest {
     public static void main(String args[]) {
          List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
          for (MemoryPoolMXBean p: pools) {
               System.out.println("Memory type="+p.getType()+" Memory usage="+p.getUsage());
         }
     }
}

import java.lang.management.*;
import java.util.*;
import javax.management.*;

public class MemTest {
    public static void main(String args[]) {
        List pools = ManagementFactory.getMemoryPoolMBeans();
        for (ListIterator i = pools.listIterator(); i.hasNext();) {
            MemoryPoolMBean p = (MemoryPoolMBean) i.next();
            System.out.println("Memory type=" + p.getType() + 
                " Memory usage=" + p.getUsage());
        }
    }
}

Variable Arguments

This is just using ellipses as syntactic sugar for arrays.

Sample output:

3 arguments

public class Test {
    // main() looks different, doesn't it?
    // try changing the runtime arguments above and rerun
    public static void main(String... args) {
        System.out.println(args.length + " arguments");
    }
}

Challenge: Here is a program that reads the name of a class from the command line, followed by a method name.  It instantiates an object of the specified type, and invokes the method.  For example, if fed a command line like java.util.Date toString, this program will print the current date and time.  Of course, this class only works with methods that don't require arguments.  The challenge is to use ellipses to specify the variable arguments to invoke.

J2SE 5 API Changes

Scanner

These examples are taken from the J2SE 5 Javadoc.

Sample output:

1
2
red
blue

String input = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();

Sample output:

1
2
red
blue

String input = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(input);
s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)");
MatchResult result = s.match();
for (int i=1; i<=result.groupCount(); i++)
    System.out.println(result.group(i));
s.close();

Collections

The collections framework is greatly enhanced by generics, which allows collections to be typesafe.

Sample output:

of course my horse 

LinkedList<String>  stringList  = new LinkedList<String>();

stringList.add("of");

stringList.add("course");

stringList.add("my");

stringList.add("horse");



for (String s : stringList)

    System.out.print(s + " ");

LinkedList<String>  stringList  = new LinkedList<String>();
stringList.add("of");
stringList.add("course");
stringList.add("my");
stringList.add("horse");

Iterator<String> iterator = stringList.iterator();
   for (String s : stringList)
       System.out.print(s + " ");

Formatted Output

Developers now have the option of using printf type functionality to generated formatted output.  Most of the common C printf formatters are available.

System.out.printf("name count\n");
String user = "fflintstone";
int total = 123;
System.out.printf("%s is %d years old\n", user, total);

Improved Diagnostic Ability

This is one of Calvin Austin's code examples.

Generating Stack traces has been awkward if no console window has been available.  Two new APIs, getStackTrace and Thread.getAllStackTraces provide this information programmatically.

Sample output:

java.lang.Thread.dumpThreads(Native Method)
java.lang.Thread.getStackTrace(Thread.java:1333)
Class2005.main(Class2005.java:5)
{Thread[Reference Handler,10,system]=[Ljava.lang.StackTraceElement;@130c19b,
 Thread[main,5,main]=[Ljava.lang.StackTraceElement;@1f6a7b9,
 Thread[Signal Dispatcher,10,system]=[Ljava.lang.StackTraceElement;@7d772e,
 Thread[Finalizer,8,system]=[Ljava.lang.StackTraceElement;@11b86e7}

StackTraceElement e[] = Thread.currentThread().getStackTrace();
for (int i=0; i <e.length; i++) 
    System.out.println(e[i]);

System.out.println("\n" + Thread.getAllStackTraces());

Monitoring and Manageability

This is another one of Calvin Austin's code examples.

Monitoring and Manageability is a key component of RAS (Reliability, Availability, Serviceability) in the Java platform.  The following code reports the detailed usage of the memory heaps in the Hotspot JVM.

Sample output (reformatted):

Memory type=Non-heap memory Memory usage=init = 163840(160K) used = 533120(520K) 
   committed = 557056(544K) max = 33554432(32768K)
Memory type=Heap memory Memory usage=init = 524288(512K) used = 195232(190K) 
   committed = 524288(512K) max = 4194304(4096K)
Memory type=Heap memory Memory usage=init = 65536(64K) used = 0(0K) 
   committed = 65536(64K) max = 458752(448K)
Memory type=Heap memory Memory usage=init = 1441792(1408K) used = 0(0K) 
   committed = 1441792(1408K) max = 61997056(60544K)
Memory type=Non-heap memory Memory usage=init = 8388608(8192K) used = 119112(116K) 
   committed = 8388608(8192K) max = 67108864(65536K)
Memory type=Non-heap memory Memory usage=init = 8388608(8192K) used = 5735280(5600K) 
   committed = 8388608(8192K) max = 8388608(8192K)
Memory type=Non-heap memory Memory usage=init = 12582912(12288K) used = 5973320(5833K) 
   committed = 12582912(12288K) max = 12582912(12288K)

import java.lang.management.*;
import java.util.*;

public class MemTest {
     public static void main(String args[]) {
          List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
          for (MemoryPoolMXBean p: pools) {
               System.out.println("Memory type="+p.getType()+" Memory usage="+p.getUsage());
         }
     }
}

import java.lang.management.*;
import java.util.*;
import javax.management.*;

public class MemTest {
    public static void main(String args[]) {
        List pools = ManagementFactory.getMemoryPoolMBeans();
        for (ListIterator i = pools.listIterator(); i.hasNext();) {
            MemoryPoolMBean p = (MemoryPoolMBean) i.next();
            System.out.println("Memory type=" + p.getType() + 
                " Memory usage=" + p.getUsage());
        }
    }
}

Word Frequency Counter

This is Josh Bloch's new and improved word frequency counter.

import java.text.*;
import java.util.*;

public class Freq {
    public static void main(String[] args) {
        Map<String, Integer> m = new TreeMap<String, Integer>();
        for (String word : args) {
            Integer freq = m.get(word);
            m.put(word, (freq == null ? 1 : freq + 1));
        }
        System.out.println(m);
    }
}

Grep

This is one of Sun's NIO examples.  This program has a bug: instead of working from a directory name or accepting wildcards, the only way it works is to specify the exact filename that you are looking for... which defeats the purpose.  Perhaps you'd like to figure out the fix?

We have placed files in the JDK 1.5 shared sandbox called /usr/share/fileXX.data, where XX runs from 1 to 10.  These files have privileges that allow them to be read by users, so this example will be able to generate viewable results.  If you attempt read a file for which you do not have privilege, a java.io.FileNotFoundException error will result.

Sample output

This is file #1
This is file #2
This is file #3
This is file #4
This is file #5
This is file #6
This is file #7
This is file #8
This is file #9
This is file #10

System.nanoTime() and HttpURLConnection()

System.nanoTime() is a new static method that is only good for measuring intervals, and no, it doesn't guarantee nanosecond accuracy.  We confess that we cheated ... HttpURLConnection() is an abstract class, but we didn't want to take advantage of all it's features, so we created an anonymous class.

long startTime = System.nanoTime();
try {
    HttpURLConnection huc = new HttpURLConnection(new URL("http://java.sun.com")) {
        public void connect() {}
        public void disconnect() {}
        public boolean usingProxy() { return false; }
    };
} catch (MalformedURLException ignored) {}
System.out.println((System.nanoTime() - startTime) + " nanoseconds.");

Add New Code Samples Here

If you have code samples that don't fit into any of the topics above which you would like to contribute, please put them here.  We'll sort them out into their own sections as appropriate later.

// now with generics in JDK 5
    List<String> stringList2 = new ArrayList<String>();
    stringList2.add("Java 5.0");
    stringList2.add("with generics");
    // no need for type casting
    String s2 = stringList2.get(0);
    System.out.println(s2.toUpperCase());

// in JDK 1.4
    List stringList1 = new ArrayList();
    stringList1.add("Java 1.0 - 5.0");
    stringList1.add("without generics");*/
    // cast to java.lang.String
   String s1 = (String) stringList1.get(0);
   System.out.println(s1.toUpperCase());
                              
    // now with generics in JDK 5
    List<String> stringList2 = new ArrayList<String>();
    stringList2.add("Java 5.0");
    stringList2.add("with generics");
    // no need for type casting
    String s2 = stringList2.get(0);
    System.out.println(s2.toUpperCase());

© Copyright 2004-2009 Zamples, Inc.  All rights reserved.  Zamples^® is a registered trademark of Zamples, Inc.