Core Java Technologies Tech Tips

Launch Java Applications from Assembly Language Programs

2008-07-02T15:21:27-07:00

Java Native Interface (JNI) is a mechanism that can be used to establish communication between native language programs and the Java virtual machine. The documentation for JNI and the technical literature on JNI deal extensively with interactions between the JVM and C/C++ code. The Java SDK even provides a utility to generate a header file to facilitate calling C/C++ programs from Java code. However, there is hardly any mention of Java and assembly language code working together. In an earlier article I showed how assembly language programs can be called from Java applications. Here I deal with the technique for invoking Java programs from an ASM process through a demo application that calls a Java method from assembly language code. The Java method brings up a Swing JDialog to show that it has, indeed, been launched.

Why Java with ASM?

JNI is essential to the implementation of Java, since the JVM needs to interact with the native platform to implement some of its functionality. Apart from that, however, use of Java classes can often be an attractive supplement to applications written in other languages, as Java offers a wide selection of APIs that makes implementation of advanced functions very simple.

Some time ago, I was associated with an application to collect real-time data from a number of sources and save them in circular buffers so that new data would overwrite old data once the buffer got filled up. If a designated trigger event was sensed through a digital input, a fixed number of data samples would be saved in the buffers so that a snapshot of pre- and post-trigger data would be available. The original application was written in assembly language. After the application was used for a few months, it was felt that it would be very useful to have the application mail the snapshots to authorized supervisors whenever the trigger event occurred. Of course, it would have been possible to write this extension in assembly, but the team felt that in that particular instance it was easier to write that extension in Java and hook it up with the ASM program. As I had earlier worked with ASM-oriented JNI, I knew this could be done and, indeed, the project was implemented quickly and successfully.

I am sure there are many legacy applications written in assembly language that could benefit from such add-ons. However, it is not only for old applications in need of renovation that JNI can prove useful. Although it may seem unlikely to some of us, assembly language is still used for writing selected portions of new programs. In an article published not very long ago, the author says, "I have found that many of Sun's partners still use assembly language in their products to ensure that hot code paths are as efficient as possible. While compilers are able to generate much more efficient code today, the resulting code still doesn't always compete with hand-coded assembly written by an engineer that knows how to squeeze performance out of each microprocessor instruction. Assembly language remains a powerful tool for optimization, granting the programmer greater control, and with judicious use can enhance performance." Clearly, in such "mixed language" applications the ability to use Java with ASM can be useful.

Note that the technique shown here can also be used to call Java code from languages other than ASM. If JInvoke is rewritten as a .dll, code written in FORTRAN, for instance, can link to it and call a Java method.

I have used JNI with legacy ASM code in two ways:

Functional enhancement: Mail-enabling an existing ASM application, as mentioned earlier.
Interface enhancement: Adding interactive user interface (mostly AWT, but some Swing as well).

These enhanced applications have run on Windows 2000 and XP. The Java versions used were 1.3, 1.4, and 1.6. In all cases the applications worked smoothly.

Read the rest of this article . . .

Add Logging at Class Load Time with Java Instrumentation

2008-06-16T08:17:05-07:00

by Thorbjørn Ravn Andersen

When you're trying to analyze why a program failed, a very valuable piece of information is what the program was actually doing when it failed. In many cases, this can be determined with a stack trace, but frequently that information is not available, or perhaps what you need is information about the data that was being processed at the time of failure.

Traditionally this means using a logging framework like log4j or the Java Logging API, and then writing and maintaining all necessary log statements manually. This is very tedious and error-prone, and well-suited for automation. Java 5 added the Java Instrumentation mechanism, which allows you to provide "Java agents" that can inspect and modify the byte code of the classes as they are loaded.

This article will show how to implement such a Java agent, which transparently will add entry and exit logging to all methods in all your classes with the standard Java Logging API. The example used is Hello World:

public class HelloWorld {
    public static void main(String args[]) {
        System.out.println("Hello World");
    }
}

And here is the same program with entry and exit log statements added:

import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;

public class LoggingHelloWorld {
    final static Logger _log = Logger.getLogger(LoggingHelloWorld.class.getName());

    public static void main(String args[]) {
        if (_log.isLoggable(Level.INFO)) {
            _log.info("> main(args=" + Arrays.asList(args) + ")");
        }
        System.out.println("Hello World");
        if (_log.isLoggable(Level.INFO)) {
            _log.info("< main()");
        }
    }
}

The default logger format generates output similar to:

2007-12-22 22:08:52 LoggingHelloWorld main
INFO: > main(args=[])
Hello World
2007-12-22 22:08:52 LoggingHelloWorld main
INFO: < main()

Note that each log statement is printed on two lines. First, a line with a time stamp, the provided log name, and the method in which the call was made, and then a line with the provided log text.

The rest of the article will demonstrate how to make the original Hello World program behave like the logging Hello World by manipulating the byte code when it is loaded. The manipulation mechanism is the Java Instrumentation API added in Java 5.

Read the rest of this article.

Source Code Analysis Using Java 6 APIs

2008-05-20T12:06:52-07:00

by Seema Richard, Deepa Sobhana

Have you ever thought of how tools like Checkstyle or FindBugs perform a static code analysis, or how Integrated Development Environments (IDEs) like NetBeans or Eclipse execute quick code fixes or find the exact references of a field declared in your code? In many cases, IDEs have their own APIs to parse the source code and generate a standard tree structure, called an Abstract Syntax Tree (AST) or "parse tree," which can be used for deeper analysis of the source elements. The good news is that it is now possible to accomplish the said tasks plus a lot more with the help of three new APIs introduced in Java as part of the Java Standard Edition 6 release. The APIs that might be of interest to developers of Java applications that need to perform source code analysis are the Java Compiler API (JSR 199), the Pluggable Annotation Processing API (JSR 269), and the Compiler Tree API.

In this article, we explore the features of each of these APIs and go on to develop a simple demo application that verifies certain Java coding rules on a set of source code files supplied as input. This utility also shows the coding violation messages as well as the location of violated source code as output. Consider a simple Java class that overrides the equals() method of the Object class. The coding rule to be verified is that every class that implements the equals() method should also override the hashcode() method with the proper signature. You can see that the TestClass class below does not define the hashcode() method, even though it has the equals() method.

public class TestClass implements Serializable {
 int num;

 @Override
  public boolean equals(Object obj) {
        if (this == obj)
                return true;
        if ((obj == null) || (obj.getClass() != this.getClass()))
                return false;
        TestClass test = (TestClass) obj;
        return num == test.num;
  }
}

Let us go on and analyze this class as part of the build process with the help of these three APIs.

Invoking the Compiler from Code: The Java Compiler API

We all use the javac command-line tool for compiling Java source files to class files. Then why do we need an API to compile Java files? Well, the answer is quite simple: as the name describes, this new standard API lets us invoke the compiler from our own Java applications; i.e., you can programmatically interact with the compiler and thereby make compilation part of application-level services. Some typical uses of this API are listed below.

The compiler API helps application servers to minimize the time taken to deploy applications, for example, by avoiding the overhead of using an external compiler for compiling the servlet sources generated from the JSP pages.
Developer tools like IDEs and code analyzers can invoke the compiler from within the editor or build tools that significantly reduce the compile time.

The Java compiler classes are packaged under the javax.tools package. The ToolProvider class of this package provides a method called getSystemJavaCompiler() that returns an instance of some class that implements the JavaCompiler interface. This compiler instance can be used to create a compilation task that will perform the actual compilation. The Java source files to be compiled will be then passed to the compilation task. For this, the compiler API provides a file manager abstraction called JavaFileManager, which allows Java files to be retrieved from various sources, such as the file system, databases, memory, and so on. In this sample, we use StandardFileManager, a file manager based on java.io.File. The standard file manager can be acquired by calling the getStandardFileManager() method of the JavaCompiler instance. The code snippet for the above-mentioned steps is shown below:

//Get an instance of java compiler
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

//Get a new instance of the standard file manager implementation
StandardJavaFileManager fileManager = compiler.
        getStandardFileManager(null, null, null);
        
// Get the list of java file objects, in this case we have only 
// one file, TestClass.java
Iterable compilationUnits1 = 
        fileManager.getJavaFileObjectsFromFiles("TestClass.java");

A diagnostic listener can be optionally passed to the getStandardFileManager() method to produce diagnostic reports of any non-fatal problems. In this code snippet, we pass null values, since we are not collecting the diagnostics from the tool. For details of the other parameters passed to these methods, please refer to the Java 6 API. The getJavaFileObjectsfromFiles() method of the StandardJavaFileManager returns all the JavaFileObject instances that correspond to the supplied Java source files.

Read the rest of this article

Nimbus Look and Feel in Java SE 6 Update 10 Beta

2008-04-24T09:41:41-07:00

By Ethan Nicholas

When the venerable Metal look and feel for Swing first debuted, its main aesthetic competition was the Windows 95 interface. Given the state of graphical user interfaces a decade ago, Metal was an attractive and elegant alternative to the other common interfaces of the time.

The updated Ocean theme in Java SE 5 helped to keep Metal a viable choice up to the present day, but it's time for Swing's cross-platform look and feel to get an overhaul.

Enter the Nimbus Look and Feel. A brand new, modern look and feel based on Synth, Nimbus provides a polished look to applications which choose to use it. And because Nimbus is drawn entirely using Java 2D vector graphics, rather than static bitmaps, it's tiny (only 56KB!) and can be rendered at arbitrary resolutions.

Figure 3: SwingSet3 in Metal

Figure 4: SwingSet3 in Nimbus

For compatibility reasons, Metal is still the default Swing look and feel, but updating applications to use Nimbus couldn't be simpler. It only takes a single line of code:

UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");

You can also force Nimbus to be the default look and feel by specifying -Dswing.defaultlaf=com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel. on the command line. A more permanent way to set the property is to add

swing.defaultlaf=com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel

to the file <JAVA_HOME>/lib/swing.properties. You will have to create the swing.properties file if it does not already exist.

For further reading about Nimbus, take a look at the Nimbus early access page.

JSlider Appearance Improvements

2008-04-04T13:34:02-07:00

by John Zukowsi

The JSlider component is a popular component for selecting a value from a numerical range. While some people might think of a JScrollBar for numerical input, that really serves the purpose of scrolling around a viewport, not data input. By default, the input range of a JSlider is 0 to 100, with an initial value of 50. You can change any of the three defaults, the direction of the scrollbar, and whether tick marks should appear and what to show next to them. You'll look at all of these possible features.

First off is the basic JSlider, just creating it and adding it to a screen, preserving all the defaults. Nothing fancy here, but builds the basics for what to build on for the remaining examples. The SliderSample program actually has four sliders; two horizontal and two vertical.

import javax.swing.*;
import java.awt.*;

public class SliderSample {
  public static void main(final String args[]) {
    Runnable runner = new Runnable() {
      public void run() {
        JFrame frame = new JFrame("Sample Sliders");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JSlider js1 = new JSlider();
        JSlider js2 = new JSlider();
        js2.setInverted(true);
        JSlider js3 = new JSlider(JSlider.VERTICAL);
        js3.setPaintLabels(true);
        JSlider js4 = new JSlider(JSlider.VERTICAL);
        js4.setInverted(true);
        frame.add(js1, BorderLayout.NORTH);
        frame.add(js2, BorderLayout.SOUTH);
        frame.add(js3, BorderLayout.WEST);
        frame.add(js4, BorderLayout.EAST);
        frame.setSize(300, 200);
        frame.setVisible(true);
      }
    };
    EventQueue.invokeLater(runner);
  }
}

Compiling and running the program shows a screen with four sliders on it. While you cannot tell from the screen, the ones in the EAST and SOUTH regions of the BorderLayout are actually inverted. So, for the horizontal sliders, 0 is on the left for the top one and 100 is on the left for the inverted bottom one. For the vertical sliders, 0 is on the bottom for the left one and on the top for the inverted right one.

By default, there is no indicator on the slider for what its value is. Instead, you would just ask the slider its value at some later time, or attach a listener to the control to be told the value upon movement. Ignoring the import lines, here is a listener that reports the value when the user stops dragging the slider knob. The getValueIsAdjusting() method reports true while the user still has the knob selected with the mouse.

 public class SliderChangeListener implements ChangeListener {
    public void stateChanged(ChangeEvent changeEvent) { 
      Object source = changeEvent.getSource();
      JSlider theJSlider = (JSlider)source;
      if (!theJSlider.getValueIsAdjusting()) { 
        System.out.println ("Slider changed: " + theJSlider.getValue());
      } 
    } 
  }

Not showing a value on the slider makes it somewhat useless, though you can certainly work with it where the exact value doesn't matter and the user can see results based upon relative position. To help in making the slider more useful, you can show tick marks with labels. There are two classes of tick marks, major and minor ones. Major and minor are just classifications for the length and positioning of the lines drawn for the tick mark, where major tick marks are longer than minor ones. To enable tick marks, you have to call setPaintTicks(true), and, say how far apart the tick marks should appear. By default, the spacing is zero, resulting in no tick marks drawn, even when paint ticks is true. Adding the appropriate lines to the earlier program will show tick marks on the top and left sliders, with major ticks every 10 and minor ones at the midpoint between them.

  
  js1.setPaintTicks(true);
  js1.setMajorTickSpacing(10);
  js1.setMinorTickSpacing(5);

  js3.setPaintTicks(true);
  js3.setMajorTickSpacing(10);
  js3.setMinorTickSpacing(5);

Showing tick marks certainly helps, but showing labels makes things most useful. Adding setPaintLabels(true) calls will show labels at the major tick marks. By default, the labels are their respective cardinal numbers, so with a major tick mark at value 0, the associated label is string "0," and so on for "10,", "20,", all the way to "100."

Instead of showing the cardinal numbers, you can provide a label table: setLabelTable(Dictionary labels). In the table, you would map integer values to different components to show as the label. In generic-speak, that would be Dictionary<Integer, JComponent>, though the method isn't explicitly defined to require the key-value pair to be such. Typically, the mapping is Integer object to JLabel. As the Swing component set predates the Collections framework, the method takes a Dictionary, not a Map, so remember to use a Hashtable for the label table. Here's one label table setup that shows text roughly every eleven positions. At the ends are colored diamond icons, instead of text, to help show that that are labels not text strings that can go at each position.

   Hashtable<Integer, JComponent> table =
      new Hashtable<Integer, JComponent>();
    table.put(new Integer(0), new JLabel(
      new DiamondIcon(Color.RED)));
    table.put(new Integer(11), new JLabel("Eleven"));
    table.put(new Integer(22), new JLabel("Twenty-Two"));
    table.put(new Integer(33), new JLabel("Thirty-Three"));
    table.put(new Integer(44), new JLabel("Fourty-Four"));
    table.put(new Integer(55), new JLabel("Fifty-Five"));
    table.put(new Integer(66), new JLabel("Sixty-Six"));
    table.put(new Integer(77), new JLabel("Seventy-Seven"));
    table.put(new Integer(88), new JLabel("Eighty-Eight"));
    table.put(new Integer(100), new JLabel(
      new DiamondIcon(Color.BLACK)));
     js4.setLabelTable(table);
     js4.setPaintLabels(true);

The definition for the DiamondIcon will be shown at end with the full class definition.

Notice that the slider in the eastern area of the screen was used for the label table. Had the southern slider been used instead, the label text would overlap. Keep that in mind when you work with slider labels.

One last thing you can do to affect the display. You can hide the track that the knob slides on. Just call the setPaintTrack() method, with a setting of false. Here, the bottom slider has its track hidden.

There isn't that much more you can do to customize the look of the JSlider, but as you've seen there is certainly quite a bit you can do. From adding tick marks and labels to hiding the track, you've seen the most significant features. If you want to get really fancy, consider creating a custom UI for the component and show it as a dial instead of a line. Sounds like an idea for a future tip.

Here's the final and complete source used to generate the samples. You will need to work backwards to remove code sections to return back to the first screen shot.

import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.util.Hashtable;

public class SliderSample {
  public static void main(final String args[]) {
    Runnable runner = new Runnable() {
      public void run() {
        JFrame frame = new JFrame("Sample Sliders");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        ChangeListener listener = new SliderChangeListener();
        JSlider js1 = new JSlider();
        js1.setPaintLabels(true);
        js1.setPaintTicks(true);
        js1.setMajorTickSpacing(10);
        js1.setMinorTickSpacing(5);
        js1.addChangeListener(listener);
        JSlider js2 = new JSlider();
        js2.setInverted(true);
	js2.setPaintTrack(false);
        js2.addChangeListener(listener);
        JSlider js3 = new JSlider(JSlider.VERTICAL);
        js3.setPaintLabels(true);
        js3.setPaintTicks(true);
        js3.setMajorTickSpacing(10);
        js3.setMinorTickSpacing(5);
        js3.addChangeListener(listener);
        JSlider js4 = new JSlider(JSlider.VERTICAL);
        js4.setInverted(true);
        Hashtable<Integer, JComponent> table =
          new Hashtable<Integer, JComponent>();
        table.put(new Integer(0), new JLabel(
          new DiamondIcon(Color.RED)));
        table.put(new Integer(11), new JLabel("Eleven"));
        table.put(new Integer(22), new JLabel("Twenty-Two"));
        table.put(new Integer(33), new JLabel("Thirty-Three"));
        table.put(new Integer(44), new JLabel("Fourty-Four"));
        table.put(new Integer(55), new JLabel("Fifty-Five"));
        table.put(new Integer(66), new JLabel("Sixty-Six"));
        table.put(new Integer(77), new JLabel("Seventy-Seven"));
        table.put(new Integer(88), new JLabel("Eighty-Eight"));
        table.put(new Integer(100), new JLabel(
          new DiamondIcon(Color.BLACK)));
        js4.setLabelTable(table);
        js4.setPaintLabels(true);
        js4.addChangeListener(listener);
        frame.add(js1, BorderLayout.NORTH);
        frame.add(js2, BorderLayout.SOUTH);
        frame.add(js3, BorderLayout.WEST);
        frame.add(js4, BorderLayout.EAST);
        frame.setSize(400, 300);
        frame.setVisible(true);
      }
    };
    EventQueue.invokeLater(runner);
  }
  public static class SliderChangeListener implements ChangeListener {
    public void stateChanged(ChangeEvent changeEvent) { 
      Object source = changeEvent.getSource();
      JSlider theJSlider = (JSlider)source;
      if (!theJSlider.getValueIsAdjusting()) { 
        System.out.println ("Slider changed: " + theJSlider.getValue());
      } 
    } 
  }
  public static class DiamondIcon implements Icon {
    private Color color;
    private boolean selected;
    private int width;
    private int height;
    private Polygon poly;
    private static final int DEFAULT_WIDTH = 10;
    private static final int DEFAULT_HEIGHT = 10;

    public DiamondIcon(Color color) {
      this(color, true, DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public DiamondIcon(Color color, boolean selected) {
      this(color, selected, DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public DiamondIcon(Color color, boolean selected,
        int width, int height) {
      this.color = color;
      this.selected = selected;
      this.width = width;
      this.height = height;
      initPolygon();
    }

    private void initPolygon() {
      poly = new Polygon();
      int halfWidth = width / 2;
      int halfHeight = height / 2;
      poly.addPoint(0, halfHeight);
      poly.addPoint(halfWidth, 0);
      poly.addPoint(width, halfHeight);
      poly.addPoint(halfWidth, height);
    }

    public int getIconHeight() {
      return height;
    }

    public int getIconWidth() {
      return width;
    }

    public void paintIcon(Component c, Graphics g, int x, int y) {
      g.setColor(color);
      g.translate(x, y);
      if (selected) {
        g.fillPolygon(poly);
      } else {
        g.drawPolygon(poly);
      }
      g.translate(-x, -y);
    }
  }
}

Using Generics With Wildcards and Extends

2008-03-10T16:56:23-07:00

By John Zukowski

Java 2 Platform, Standard Edition 5.0 (J2SE 5.0) introduced generics to the Java programming language and platform. In the simplest case and typical usage, generics allow for the identification of what you want to store in a collection. So instead of saying that your program has a List of Objects, you can now specify that you have a List of String objects or some other class type. Then, if you accidentally try to add something to the List that is of the wrong type, the compiler notifies you of the error and it can be fixed at compile time, rather than having to wait until you run the program and the program reaches the point in code where the fetch operation produces a runtime casting exception.

This brings up a second benefit of generics. Iterators now become typesafe. The next() method of the Iterator interface returns the typesafe version of the next element of the collection.

But this is not a tip about the use of generics, which a 2005 Core Java Technologies Tip explained. Most people don't fully understand the use of the extends keyword when using generics. A typical example shown to explain the use of extends has to do with drawing shapes. Instead, this tech tip will use an example that uses Swing components so that you do not have to create extra new classes. In a very limited case, the class hierarchy for Swing button components is shown here, with Object as the real root:

Component
|- Container
   |- JComponent
      |- AbstractButton
         |- JButton
         |- JMenuItem
            |- JCheckBoxMenuItem
            |- JMenu
            |- JRadioButtonMenuItem
         |- JToggleButton
            |- JCheckBox
            |- JRadioButton

One thing that all AbstractButton subclasses share in common is a getText() method. So in the spirit of generics, you can define a method that takes a List of AbstractButton items and return a List of the String labels of those buttons. Here's the first version of such a method:

  public static List<String> getLabels(List<AbstractButton> list) {
    List<String> labelList = new ArrayList<String>(list.size());
    for (AbstractButton button: list) {
      labelList.add(button.getText());
    }
    return labelList;
  }

And here is how you might use the method. First, define a List of AbstractButton types, fill it up, and call the method:

  List<AbstractButton> buttonList =
      new ArrayList<AbstractButton>();
  buttonList.add(new JButton("Hello"));
  buttonList.add(new JCheckBox("World"));
  buttonList.add(new JRadioButton("Hola"));
  buttonList.add(new JMenuItem("Mundo"));

  List labels = getLabels(buttonList);
  System.out.println(labels);

"Hola, Mundo" is the Spanish translation of "Hello, World," according to Google. The results of the println() call is as follows:

[Hello, World, Hola, Mundo]

With a List of AbstractButtons, everything functions fine, but this breaks down when the List is of something else, specifically a subclass. One would logically think that with a List of JButton items, everything would work fine, because JButton is a subclass of AbstractButton. Shouldn't you be able to call getLabels(List<AbstractButton>) with a List of a subclass of AbstractButton?

  List<JButton> buttonList = ...
  // ... Fill list ...
  List<String> labels = getLabels(buttonList);

Well, that isn't the case. Because this is a compile-time check, and because the definition of getLabels() is defined to accept only an AbstractButton List, you cannot pass anything else to it. The compilation-time error message follows:

GetList.java:13: getLabels(java.util.List<javax.swing.AbstractButton>)
  in GetList cannot be applied to (java.util.List<javax.swing.JButton>)

    List<String> labels = getLabels(buttonList);
                          ^
1 error

And this is where the extends keyword comes in handy. Instead of defining the getLabels() method to accept only an AbstractButton list, define it to accept any List of AbstractButton subclasses:

    public static List<String> getLabels(
      List<? extends AbstractButton> list) {

The wildcard ? here says that the method doesn't care what the exact class type is, as long as it is a subclass of AbstractButton. Here's a complete example that puts all the pieces together:

import java.util.*;
import javax.swing.*;

public class GetList {
  public static void main(String args[]) {
    List<JButton> buttonList =
      new ArrayList<JButton>();
    buttonList.add(new JButton("Hello"));
    buttonList.add(new JButton("World"));
    buttonList.add(new JButton("Hola"));
    buttonList.add(new JButton("Mundo"));

    List labels = getLabels(buttonList);
    System.out.println(labels);

  }

  public static List<String> getLabels(
        List<? extends AbstractButton> list) {
    List<String> labelList = new ArrayList<String>(list.size());
    for (AbstractButton button: list) {
      labelList.add(button.getText());
    }
    return labelList;
  }
}

Now, when you are defining your own classes and methods with generics and are thinking of accepting an abstract class as the generic argument, or any superclass, remember to use wildcards so that the same method works best with subclasses too.

For more information on generics, see two earlier tutorials by Gilad Bracha: a 2004 tutorial (PDF) and the generics lesson in the online Java Tutorial.

Getting to Know BoxLayout

2008-02-12T15:37:33-08:00

One of the standard layout managers that come with the Java platform is BoxLayout. This allows you to layout a single row or column of components in a container. This may sound like a not-so-complicated layout manager, but with the help of Box and its glue and struts, you'd think that would be enough, but there is even more. The vertical and horizontal alignment of the underlying components allows even more control of the positioning of components within the container. Here, we'll look at all these aspects.

Typical Usage

BoxLayout is unlike most layout managers which just require you to create the layout manager, and associate the layout manager with the Container. Instead, the BoxLayout constructor requires you to pass the Container into the constructor of the layout manager, thus having a reference to the other component in each of them. This can be awkward sometimes, and makes the use of the Box container more popular, since all you have to do is ask for a horizontally or vertically laid out Box through one of its static methods:

  Box vertical = Box.createVerticalBox();
  Box horizontal = Box.createHorizontalBox();

Both are using BoxLayout under the covers, placing added components on the proper access, depending upon direction. A vertical box places everything into a single column, whereas a horizontal box places everything in a row. Comparing BoxLayout (and thus Box) to GridLayout requires a quick comment. When placing a bunch of components in a GridLayout controlled container, all the components are expected to be the same size. With BoxLayout, that isn't the case, and the maximum preferred size of the component is honored.

Struts and Glue

The Box class offers the creation of two supporting components, one a strut, or fixed-size filler area, the other glue for an expandable area. The use of these allows you to place components within a container, either a fixed-distance apart with a strut, or a growing/shrinking area based upon available space, with glue. The same task can be done with GridBagConstraints and GridBagLayout, though not as easily.

To demonstrate, this first program creates a 25 pixel strut between the top two components and a 10 pixel strut between the bottom two.

import java.awt.*;
import javax.swing.*;
public class VerticalBoxTest {
  public static void main(String args[]) {
    JFrame frame = new JFrame("Vertical Box");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Box box = Box.createVerticalBox(); 
    box.add(new Button("Top"));
    box.add(Box.createVerticalStrut(25));
    box.add(new Button("Middle"));
    box.add(Box.createVerticalStrut(10));
    box.add(new Button("Bottom"));
    frame.add(box, BorderLayout.CENTER);
    frame.setSize(300, 200);
    frame.setVisible(true);
  }
}

Once you compile and run it, notice how the components change in size when the window size increased or decreased. The distance between the components remain unchanged, to match the reserved strut space. This example uses a <code>Button</code> instead of a JButton to avoid an explanation of component alignment until a little later.

Working with a horizontal box and glue produces similar results, though this time the glue grows in size to take up added space, instead of staying a fixed size, with the strut.

import java.awt.*;
import javax.swing.*;
public class HorizontalBoxTest {
  public static void main(String args[]) {
    JFrame frame = new JFrame("Horizontal Box");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Box box = Box.createHorizontalBox();
    box.add(Box.createHorizontalGlue());
    box.add(new JButton("Left"));
    box.add(new JButton("Right"));
    frame.add(box, BorderLayout.NORTH);
    box = Box.createHorizontalBox();
    box.add(new JButton("Left"));
    box.add(Box.createHorizontalGlue());
    box.add(new JButton("Right"));
    frame.add(box, BorderLayout.CENTER);
    box = Box.createHorizontalBox();
    box.add(new JButton("Left"));
    box.add(new JButton("Right"));
    box.add(Box.createHorizontalGlue());
    frame.add(box, BorderLayout.SOUTH);
    frame.setSize(300, 200);
    frame.setVisible(true);
  }
}

Trying not to confuse you too much, but the example is back to using JButton components.

Alignment

Life gets interesting with Box/BoxLayout when the components within the container are a different size or the height/width of the container is wider than necessary for a vertical box or taller than necessary with a horizontal one. In other words, if you have a tall column, where do components of a different width end up? And, if you have a wide row with components of a different height, how about them?

This is where the different alignments of a component come into play. Each Swing component has an X-alignment setting and a Y-alignment setting thanks to its get/setAlignmentX() and get/setAlignmentY() methods. The range of each setting is from 0 to 1.0, inclusive, where 0 represents left or top alignment and 1 represents right or bottom alignment, depending upon direction of BoxLayout. There are constants available in the Component class so you don't really need to know what the values are for right and left alignment. However, it does help to know if you might want something in between.

To demonstrate the right, left, center nature of different size buttons in a vertical box, the following program creates three boxes, one each filled with left, center, and right aligned buttons.

import java.awt.*;
import javax.swing.*;

public class AlignX {

  private static Container makeIt(String labelChar, float alignment) {
    Box box = Box.createVerticalBox();

    for (int i=1; i<6; i++) {
      String label = makeLabel(labelChar, i*2);
      JButton button = new JButton(label);
      button.setAlignmentX(alignment);
      box.add(button);
    }
    return box;
  }

  private static String makeLabel(String s, int length) {
    StringBuffer buff = new StringBuffer(length);
    for (int i=0; i<length; i++) {
      buff.append(s);
    }
    return buff.toString();
  }

  public static void main(String args[]) {
    JFrame frame = new JFrame("X Alignment");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    Container panel1 = makeIt("L", Component.LEFT_ALIGNMENT);
    Container panel2 = makeIt("C", Component.CENTER_ALIGNMENT);
    Container panel3 = makeIt("R", Component.RIGHT_ALIGNMENT);

    frame.setLayout(new FlowLayout());
    frame.add(panel1);
    frame.add(panel2);
    frame.add(panel3);

    frame.pack();
    frame.setVisible(true);
  }
}

Now, let us mix things up a little and have one vertical box with three buttons, one for each alignment. The screen width will be wide, to make sure there is extra space available. Conceptually thinking, one would expect the component with left alignment to be aligned to the left of the container and the one with right alignment to be aligned to the right of the container. That would be wrong though. When there are different component alignments, they are aligned to the center of the container. So, for left alignment, that component will have its left edge on the invisible center line of the container. For right alignment, it is the right edge.

Here's the program to demonstrate:

import java.awt.*;
import javax.swing.*;

public class AlignX2 {

  public static void main(String args[]) {
    JFrame frame = new JFrame("X Alignment");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    Box box = Box.createVerticalBox();
    JButton button = new JButton("LL");
    button.setAlignmentX(Component.LEFT_ALIGNMENT);
    box.add(button);
    button = new JButton("CC");
    button.setAlignmentX(Component.CENTER_ALIGNMENT);
    box.add(button);
    button = new JButton("RR");
    button.setAlignmentX(Component.RIGHT_ALIGNMENT);
    box.add(button);
    frame.add(box, BorderLayout.CENTER);

    frame.setSize(300, 200);
    frame.setVisible(true);}
}

And, the corroborating screen:

Working in the other direction has top alignment aligning the top of the component to the imaginary center line, or in other words below the center.

Mixing up alignments in this fashion works fine, but just takes some getting used to, as the alignment isn't necessarily where you would expect it to be, unless all the alignments are the same, and then it does align to the container border, as opposed to the container center line.

If you are still confused, feel free to modify the earlier programs and try even more combinations of x and y alignment. Of course, if all this baffles you, there is always GridBagLayout.

******

SDN Chat: Meet the Writers of java.sun.com
Please join us in Sun's Developer Playground in Second Life on Thursday, February 14 at 10am PST to meet the writers of java.sun.com. Ed Ort, Dana Nourie, Janice Heiss, and Laureen Hudson will be inworld to discuss their adventures in writing for one of the industry's most popular websites and to share the technologies and trends they'll be keeping their eyes on in 2008. And, for the first time, SMI Press is pleased to offer attendees one of three new SMI Press books for free!

Sorting Strings

2008-01-23T13:41:51-08:00

by John Zukowski

Sorting strings with the Java platform can be thought of as an easy task, but there is much more thought that should be put into it when developing programs for an international market. If you're stuck in the English-only mindset, and you think your program works fine because it shows that the string tomorrow comes after today, you might think all is great. But, once you have a Spanish user who wants mañana to be sorted properly, if all you use is the default compare() method of String for sorting, the ñ character will come after the z character and will not be the natural Spanish ordering, between the n character and o character. That's where the Collator class of the java.text package comes into play.

Imagine a list of words

first
mañana
man
many
maxi
next

Using the default sorting mechanism of String, its compare() method, this will result in a sorted list of:

first
man
many
maxi
mañana
next

Here, mañana comes between maxi and next. In the Spanish world, what should happen is mañana should come between many and maxi as the ñ character (pronounced eñe) comes after the n in that alphabet. While you could write your own custom sort routine to handle the ñ, what happens to your program when a German user comes around and wants to use their own diacritical marks, or what about just a list of design patterns with façade? Do you want façade before or after factory? (Essentially treating the ç with the little cedilla hook the same as c or different.)

That's where the Collator class comes in handy. The Collator class takes into account language-sensitive sorting issues and doesn't just try to sort words based upon their ASCII/Unicode character values. Using Collator requires understanding one additional property before you can fully utilize its features, and that is something called strength. The strength setting of the Collator determines how strong (or weak) a match is used for ordering. There are four possible values for the property: PRIMARY, SECONDARY, TERTIARY, and IDENTICAL. What actually happens with each is dependent on the locale. Typically what happens is as follows. In reverse order, IDENTICAL strength means just that, the characters must be identical for them to be treated the same. TERTIARY typically is for ignoring case differences. SECONDARY is for ignoring diacritical marks, like n vs. ñ. PRIMARY is like IDENTICAL for base letter differences, but has some differences when handling control characters and accents. See the Collator javadoc for more information on these differences and decomposition mode rules.

To work with Collator, you need to start by getting one. You can either call getInstance() to get one for the default locale, or pass the specific Locale to the getInstance() method to get a locale for the one provided. For instance, to get one for the Spanish language, you would create a Spanish Locale with new Locale("es") and then pass that into getInstance():

 Collator esCollator =
   Collator.getInstance(new Locale("es"));

Assuming the default Collator strength for the locale is sufficient, which happens to be SECONDARY for Spanish, you would then pass the Collator like any Comparator into the sort() routine of Collections to get your sorted List:

 Collections.sort(list, esCollator);

Working with the earlier list, that now gives you a proper sorting with the Spanish alphabet:

first
man
many
mañana
maxi
next

Had you instead used the US Locale for the Collator, mañana would appear between man and many since the ñ is not its own letter.

Here's a quick example that shows off the differences.

import java.awt.*;
import java.text.*;
import java.util.*;
import java.util.List; // Explicit import required
import javax.swing.*;

public class Sort {
 public static void main(String args[]) {
   Runnable runner = new Runnable() {
     public void run() {
       String words[] = {"first", "mañana", "man",
                         "many", "maxi", "next"};
       List list = Arrays.asList(words);
       JFrame frame = new JFrame("Sorting");
       frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
       Box box = Box.createVerticalBox();
       frame.setContentPane(box);
       JLabel label = new JLabel("Word List:");
       box.add(label);
       JTextArea textArea = new JTextArea( list.toString());
       box.add(textArea);
       Collections.sort(list);
       label = new JLabel("Sorted Word List:");
       box.add(label);
       textArea = new JTextArea(list.toString ());
       box.add(textArea);
       Collator esCollator = Collator.getInstance(new Locale("es"));
       Collections.sort(list, esCollator);
       label = new JLabel("Collated Word List:");
       box.add(label);
       textArea = new JTextArea(list.toString());
       box.add(textArea);
       frame.setSize(400, 200);
       frame.setVisible(true);
     }
   };
   EventQueue.invokeLater (runner);
 }
}

One last little bit of information about collation. The Collator returned by the getInstance() call is typically an instance of RuleBasedCollator for the supported languages. You can use RuleBasedCollator to define your own collation sequences. The javadoc for the class describes the rule syntax more completely, but lets say you had a four character alphabet and wanted the order of the letters to be CAFE instead of ACEF, your rule would look something like:

 String rule =
   "< c, C < a, A < f, F < e, E";
 RuleBasedCollator collator = new RuleBasedCollator(rule);

This defines the explicit order as cafe, with the different letter cases shown. Now, for a list of words of ace, cafe, ef, and face, the resultant sort order is cafe, ace, face, and ef with the new rules:

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

public class Rule {
 public static void main(String args[]) throws ParseException {
   String words[] = {"ace", "cafe", "ef", "face"};
   String rule ="< c, C < a, A < f, F < e, E";
   RuleBasedCollator collator = new RuleBasedCollator(rule);
   List list = Arrays.asList(words);
   Collections.sort(list, collator);
   System.out.println(list);
 }
}

After compiling and running, you see the words sorted with the new rules:

> javac Rule.java
> java Rule
[cafe, ace, face, ef]

After reading the rule syntax some more in the javadocs, try to expand the alphabet and work with the different diacritical marks, too.

Now, when developing programs for the global world, your programs can be better prepared to suit the local user. Be sure to keep strings in resource bundles, too, as shown in an earlier tip:

Earlier tip

*********

Connect and Participate With GlassFish
Try GlassFish for a chance to win an iPhone. This sweepstakes ends on March 23, 2008. Submit your entry today.

Foote on Blu-ray Disc Java In this video interview, Sun's Blu-ray Disc Java (BDJ) architect Bill Foote talks about this powerful technology and shows some examples of BDJ code and applications. Download the code

Quiz Answers

2008-01-08T09:38:25-08:00

Answers

1. Given two objects one and two of BigDecimal type, how do you multiply the two factors to calculate a product in object three? Answer: D
To generate the product of two variables of BigDecimal type, use the multiply() method of BigDecimal. This was shown in "The Need for BigDecimal" (July 2007), which also discussed formatting and rounding issues.

2. In order to write the line System.out.println("Pi = " + PI), what must the import statement be so that the compiler will locate PI in the Math class? Answer: C
Use static import statements to tell the compiler about constants and methods you wish to use without explicitly specifying the class they come from. See "Using Static Imports for Constants and Methods" (October 2004) for more information on working with static imports.

3. When using an enhanced for loop (also known as a foreach statement), what interface must the element following the colon (:) implement in order for the construct to compile and execute appropriately? Answer: B
The argument must implement the Iterable interface, which consists of a single method, to get an iterator:

Iterator iterator()

"The Enhanced For Loop" (May 2005) started the discussion of using the enhanced for loop. The use of Iterable was discussed later in "Using Enhanced For-Loops With Your Classes" (September 2007).

4. When two Swing components overlap in their display area, how do you control which component is drawn on top? Answer: C
Z-order represents the layering of the components on the screen, where x and y coordinates are for horizontal and vertical positioning, respectively. By calling the setComponentZOrder() method of the Container for each component that overlaps, you can explicitly control which components are drawn on top of which other components. See "Let There Be Z-Order" tip (January 2005) for additional information on controlling the z-order layering.

5. What is the best way to monitor the progress of image reading when using the Java Image I/O API? Answer: C
Although you can certainly display progress with a Progress Monitor, the best way to set up notification of such progress is by using a IIOReadProgressListener. "Monitoring Image I/O Events" (February 2007) covered this notification as well as region-update notifications.

January 2008 Core Java Tech Tips Quiz

2008-01-08T09:37:29-08:00

by John Zukowski

We've made it through another year, and it's time for another tech tips quiz. The last two -- June 2006 and September 2005 -- were popular refreshers of past tips and tricks. Here are another five questions for you. Don't look too far ahead, as the answers are at the end of this entry.

1. Given two objects one and two of BigDecimal type, how do you multiply the two factors to calculate a product in object three?

a. BigDecimal three = one * two;
b. BigDecimal three = one.*(two);
c. BigDecimal three = one.times(two);
d. BigDecimal three = one.multiply(two);



2. In order to write the line System.out.println("Pi = " + PI), what must the import statement be so that the compiler will locate PI in the Math class?


 a. import java.lang.Math;

 b. import java.lang.Math.PI;

 c. import static java.lang.Math.PI;

 d. import final java.lang.Math.PI;



3. When using an enhanced for loop (also known as a foreach statement), what interface must the element following the colon (:) implement in order for the construct to compile and execute appropriately?


 a. Enumeration

 b. Iterable

 c. Iterator

 d. Collection



4. When two Swing components overlap in their display area, how do you control which component is drawn on top?


 a. The component added to the container first is drawn on top.

 b. The component added to the container last is drawn on top.

 c. You call the setComponentZOrder() method of the container.

 d. You call the setComponentZOrder() method for each component.



5. What is the best way to monitor the progress of image reading when using the Java Image I/O API?


 a. Create a FilteredReader subclass to count the bytes.

 b. Attach a ProgressMonitorListener to the ImageReader to report progress.

 c. Attach an IIOReadProgressListener to the ImageReader for progress reporting.

 d. Register a Runnable with the ImageReader and tell it how frequently to execute.


Check your answers here.



Placing Components on Tabs
2008-01-02T11:36:08-08:00

by John Zukowski

The JTabbedPane component is a special Swing
container that accepts components to be placed within a panel for
each tab. Select a tab to see that tab's components. Technically
speaking, one component is associated with each tab. However, that
component is typically a panel that contains others. Identification
for each tab is done with title text and an icon, settable per tab.
The first Core Java Technologies Tech Tip to discuss the
JTabbedPane component was published in July 2001, with
a simple introductory tip. 

The methods of JTabbedPane to support the use of
components on tabs are as follows: 


public void setTabComponentAt(int index, Component component)
public Component getTabComponentAt(int index)
public int indexOfTabComponent(Component tabComponent)


The first method associates the component with a tab; the second
gets it back; and the last one tells you which tab is associated
with the component, if any. Typically, you use only the first
method, but the others are available. 

To get started with the task at hand, it is helpful to have an
Icon implementation that draws a little x on it. You could just use
the letter x as the button label, but you should avoid that option.
Typically, when a user sees an x in a box, this
signals a command to close a window, so it serves as a good
indicator for closing a tab. 

class CloseIcon implements Icon {
  public void paintIcon(Component c, Graphics g, int x, int y) {
    g.setColor(Color.RED);
    g.drawLine(6, 6, getIconWidth() - 7, getIconHeight() - 7);
    g.drawLine(getIconWidth() - 7, 6, 6, getIconHeight() - 7);
  }
  public int getIconWidth() {
    return 17;
  }
  public int getIconHeight() {
    return 17;
  }
}


Before creating the special tab component, let's put together the
program's framework, one that creates a frame with a
JTabbedPane on it and adds a number of tabs:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class CloseTabs {
  public static void main(String args[]) {
    Runnable runner = new Runnable() {
      public void run() {
        JFrame frame = new JFrame("JTabbedPane");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JTabbedPane jtp = new JTabbedPane();
        frame.add(jtp, BorderLayout.CENTER);
        for (int i=0; i<5; i++) {
          JButton button = new JButton("Card " + i);
          jtp.add("Btn " + i, button);
          // new CloseTabButton(jtp, i);
        }
        frame.setSize(400, 200);
        frame.setVisible(true);
      }
    };
    EventQueue.invokeLater(runner);
  }
}


 This program creates five tabs, each with a JButton
on it. The tab title is "Btn" followed by the tab position.  





The program will run fine without doing anything else, but it
doesn't have the close button on each tab. To add a close button to
the tab, you need to retain the tab's title text and icon, while
adding a button with the CloseIcon previously shown.
(The
example does not use the tab's icon, but the class definition
includes one so that it can be reused beyond this example.) As the
final part of the definition, you need an
ActionListener for the button to handle when it is
pressed, so that when the user presses the button, the tab is
removed from the pane. 

class CloseTabButton extends JPanel implements ActionListener {
  private JTabbedPane pane;
  public CloseTabButton(JTabbedPane pane, int index) {
    this.pane = pane;
    setOpaque(false);
    add(new JLabel(
        pane.getTitleAt(index),
        pane.getIconAt(index),
        JLabel.LEFT));
    Icon closeIcon = new CloseIcon();
    JButton btClose = new JButton(closeIcon);
    btClose.setPreferredSize(new Dimension(
        closeIcon.getIconWidth(), closeIcon.getIconHeight()));
    add(btClose);
    btClose.addActionListener(this);
    pane.setTabComponentAt(index, this);
  }
  public void actionPerformed(ActionEvent e) {
    int i = pane.indexOfTabComponent(this);
    if (i != -1) {
      pane.remove(i);
    }
  }
}


You can now reuse the CloseTabButton in your own
tabbed panes. 






For more information on the use of tabbed panes, see the How to Use Tabbed
Panes lesson in The Java Tutorial.




Tech Days Comes Back to the USA
2007-12-12T13:45:35-08:00
On January 9 & 10, the Tech Days Conference will be in Atlanta Georgia. (FREE!)


Advance your development ability and shape your future with cutting-edge technical education; Sun Tech Days are loaded with practical information, examples of real-world solutions, and hands-on training. Whatever your focus, you'll find sessions to take your skills to the next level and advance your career.


In addition, Tech Days has hands-on labs to ensure you can use specific technologies, and so you can ask the questions you need to. There will also be a Q & A session with James Gosling, and a Featured Keynote by Jeet Kaul.


The sessions that will be covered:


     Java Development Tracks

      Java EE 6 and GlassFish
    
 Java SE 6 Top 10 features, Java SE 7 and OpenJDK
    
 Next Generation Web and Java Server Faces
    
 Consumer JRE: Java on Every Desktop OR Java Performance Myths
    
 Java ME: Extreme GUI Makeover for Mobile Phones
    
 SOA using OpenESB and JCAP
    
 Java Scripting: JavaFX Script and JRuby 


    Solaris Development Track 
    
 What Makes Solaris Interesting?
    
 Sun Studio Tools
    
 OpenSolaris Security Frameworks
    
 Integrating ZFS Into Your Applications
    
 Security Features in Solaris
    
 How To Develop Solaris Parallel Applications
    
 Solaris Networking For Developers 


If you're not familiar with Tech Days and want to learn more, check out the website. In addition to information on this particular event in Georgia, there is also information and resources from previous Tech Days events, including videos, presentations, and more.


Sun Tech Days



New Certification Courses
2007-12-10T10:46:11-08:00
New Certification Courses

Sun Certified Programmer for the Java Platform, Standard Edition 6-- The Sun Certified Programmer for Java Platform, Standard Edition 6 certification exam is for programmers experienced using the Java programming language. Achieving this certification provides clear evidence that a programmer understands the basic syntax and structure of the Java programming language and can create Java technology applications that run on server and desktop systems using Java SE 6.

Sun Certified Programmer for the Java Platform, Standard Edition 6 Upgrade Exam (CX-310-066)-- The Sun Certified Programmer for Java Platform, Standard Edition 6 certification exam is for programmers experienced using the Java programming language. Achieving this certification provides evidence that a programmer understands the basic syntax and structure of the Java programming language and can create Java technology applications that run on server and desktop systems using Java Platform, Standard Edition 6 Sun strongly recommends that all new candidates interested in becoming a Sun Certified Java Programmer (SCJP) take this new version of the certification exam, rather than a previous version. In this way, candidates can demonstrate that they are knowledgeable in the latest technology. Sun also recommends that those certified on a previous version of SCJP update their credentials by taking the SCJP 6 Upgrade exam.


******



Sun Microsystems Developer Playground

Join Dana Nourie December 18th, Tues 9 AM PST and 7 PM PST, in Second Life at the Sun Microsystems Developer Playground to discover how easy it is to learn the Java platform through web programming. Watch a demo and have your questions answered.

******


Using Callable to Return Results From Runnables
2007-12-03T14:59:53-08:00
by John Zukowski

The Runnable interface has been around since the
beginning of time for the Java platform. It allows you to define a
task to be completed by a thread. As most people probably know
already, it offers a single method run() that accepts
no arguments and returns no values, nor can it throw any checked
exceptions. If you need to get a value back from the now-completed
task, you must use a method outside the interface and wait for some
kind of notification message that the task completed. For example,
the following demonstrates what you might do for just such a
scenario:

  Runnable runnable = ...;
  Thread t = new Thread(runnable);
  t.start();
  t.join();
  String value = someMethodtoGetSavedValue()


Nothing is inherently wrong with this code, but it can be done
differently now, thanks to the Callable interface
introduced in J2SE 5.0. Instead of having a run()
method, the Callable interface offers a
call() method, which can return an Object or, more
specifically, any type that is introduced in the genericized form:

  public interface Callable<V> {
     V call() throws Exception;
  }


Because you cannot pass a Callable into a
Thread to execute, you instead use the
ExecutorService to execute the Callable
object. The service accepts Callable objects to run by
way of the submit() method:

  <T> Future<T> submit(Callable<T> task)


As the method definition shows, submitting a Callable object to
the ExecutorService returns a Future
object. The get() method of Future will
then block until the task is completed. This is the equivalent of
the join() call in the first example. Actually, it is
the equivalent of both the join() call and the get
value call as get() returns the value calculated by the
Callable instance.

To demonstrate, the following example creates separate
Callable instances for each word passed in on the
command line and sums up their length. Each Callable
will just calculate the sum of its individual word. The set of
Future objects are saved to acquire the calculated
value from each. If the order of the returned values needed to be
preserved, a List could be used instead.

import java.util.*;
import java.util.concurrent.*;

public class CallableExample {

  public static class WordLengthCallable
        implements Callable {
    private String word;
    public WordLengthCallable(String word) {
      this.word = word;
    }
    public Integer call() {
      return Integer.valueOf(word.length());
    }
  }

  public static void main(String args[]) throws Exception {
    ExecutorService pool = Executors.newFixedThreadPool(3);
    Set<Future<Integer>> set = new HashSet<Future≶Integer>>();
    for (String word: args) {
      Callable<Integer> callable = new WordLengthCallable(word);
      Future<Integer> future = pool.submit(callable);
      set.add(future);
    }
    int sum = 0;
    for (Future<Integer> future : set) {
      sum += future.get();
    }
    System.out.printf("The sum of lengths is %s%n", sum);
    System.exit(sum);
  }
}


The WordLengthCallable saves each word and uses the
word's length as the value returned by the call()
method. This value could take some time to generate but in this case
is known immediately. The only requirement of call() is
the value is returned at the end of the call. When the
get() method of Future is later called,
the Future will either have the value immediately if
the task runs quickly, as in this case, or will wait until the value
is done generating. Multiple calls to get() will not
cause the task to be rerun in the thread.

Because the goal of the program is to calculate the sum of all
word lengths, it doesn't matter in which order the
Callable tasks finish. It is perfectly OK if the last
task completes before the first three. The first get()
call to Future will just wait for the first task in the
Set to complete. This does not block other tasks from
running to completion separately. It is just waiting for that one
thread or task to complete.

This particular example uses a fixed-size thread pool for the
ExecutorService, but any available service will do.

For more information on the use of executors and thread pools,
see the Executors lesson in the Java Tutorial. The
SwingWorker class is another example of a
Runnable object that works with a Future,
though in a slightly different way. See the 
Worker Threads and SwingWorker lesson for more information on
that.





************


NetBeans 6.0 Integrated Development Environment (IDE) increases developer productivity with a smarter, faster editor, Ruby/JRuby/Ruby on Rails support, enhancements for improved Swing development, a new Visual Game Designer, updated Data Binding support, integrated Profiling, and more. Download NetBeans 6.0