Core Java Technologies Tech Tips


                      Tips, Techniques, and Sample Code


Welcome to the Core Java Technologies Tech Tips for October 21, 
2003. Here you'll get tips on using core Java technologies and 
APIs, such as those in Java 2 Platform, Standard Edition (J2SE).

This issue covers:

         * Converting Between Old and New Collections
         * Choosers Outside Dialogs
                  
These tips were developed using Java 2 SDK, Standard Edition, 
v 1.4. 

This issue of the Core Java Technologies Tech Tips is written by 
John Zukowski, president of JZ Ventures, Inc. 
(http://www.jzventures.com).

You can view this issue of the Tech Tips on the Web at
http://java.sun.com/jdc/JDCTechTips/2003/tt1021.html.

See the Subscribe/Unsubscribe note at the end of this newsletter
to subscribe to Tech Tips that focus on technologies and products 
in other Java platforms.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CONVERTING BETWEEN OLD AND NEW COLLECTIONS

The introduction of the Java 2 Platform, Standard Edition version 
1.2 offered a new standard library for dealing with collections 
of objects. That library is known as the Java Collections 
Framework. A base series of four interfaces and a set of about 20 
support classes provide the whole framework. With some additions 
in the 1.4 release of the Java 2 Platform, Standard Edition, you 
get the current framework.

People who use the framework frequently hear about the "old" and 
"new" collection classes. The old classes essentially define the 
original framework as released with version 1.0 of the Java 
platform. The classes are:

o Vector
o Hashtable
o Enumeration

The new framework did some retrofitting of the old classes so 
that they work in the new world, but it also added a new set of 
classes and interfaces that work well with the old set, but 
follow a new design model. The new interfaces are:

o Set
o List
o Map
o Iterator

It's common when developing applications that you need to mix the 
old and new frameworks. Thankfully, when the new framework was 
developed, various support classes and methods were provided to 
simplify mixing the old and new frameworks. This tip describes
various aspects of converting between the old and new frameworks. 

Converting From Legacy to New Collections

The Vector and Hashtable classes are the main worker classes for
collections in the old framework. Vector offers a dynamically 
resizable array, and Hashtable is a key-value lookup table. If 
you need to use implementations of these classes with the new 
framework, you can use them through the following new interfaces:

   List list = new Vector();
   Map map = new Hashtable();

The important difference between using the old classes in this 
way, and the new implementations of the new interfaces, such as 
LinkedList, is that all the access methods of the data structure 
are synchronized in the legacy classes.

Arrays are a core part of the Java programming language, and they
haven't changed with the new framework. However, if you need to 
use them within the new framework, you can convert an array to 
a List with the asList method of Arrays:

   public static void main (String args[]) {
     List list = Arrays.asList(args);
     ...
   }

In this way, you can readily use any array as part of the new 
collections framework.

The Enumeration interface is what allows you to walk through the 
elements of a legacy collection. In the new framework, the 
Iterator interface is used for stepping through the elements. 
There is no built-in support for converting an Enumeration 
implementation to an Iterator. Typically, what you need to do is 
go back to the original collection and get an Iterator from there.
You can do that in a way similar to the following:

Old code:

   Vector v = new Vector();
   ...
   Enumeration enum = v.elements();

New code:

   List list = new Vector();
   ...
   Iterator iter = list.iterator();

Another option is to provide a simple Iterator implementation 
that does the Enumeration conversion for you. The following class 
maps the methods from the one interface into the other. In the 
case of the remove method of Iterator, there is no support. 
Notice that an UnsupportedOperationException is thrown there.

   import java.util.*;

   public class EnumerationIterator {
     public static Iterator iterator(
                             final Enumeration enum) {
       return new Iterator() {
         public boolean hasNext() {
           return enum.hasMoreElements();
         }

         public Object next() {
           return enum.nextElement();
         }

         public void remove() {
           throw new UnsupportedOperationException();
         }
       };
     }
     public static void main (String args[]) {
       Vector v = new Vector(Arrays.asList(args));
       Enumeration enum = v.elements();
       Iterator itor = 
                    EnumerationIterator.iterator(enum);
       while (itor.hasNext()) {
         System.out.println(itor.next());
       }
     }
   }

The EnumerationIterator program:

o Converts command line arguments to a Vector
o Gets the vector's elements as an Enumeration
o Converts that enumeration to an Iterator
o Prints each element on its own line. 

If you run the program with the following command:

   java EnumerationIterator one two three

you should see the the following output:

   one
   two
   three

Converting From New to Legacy Collections

The more interesting conversions are those that go from new to 
legacy collections. There are some third party libraries that 
still use the older collections classes. Because newer 
applications use the newer collections framework, you might need 
to retrofit some newer code to work in the older framework.

The first of these new-to-legacy conversions involves going from 
newer collections to Vector and Hashtable. Here, the conversion 
is handled by requiring all implementations of the collection 
classes to provide a copy constructor. That means that you can 
pass any Collection into the Vector constructor, and get a second 
collection with the same set of elements. You can also pass a Map 
into the Hashtable constructor to get a Hashtable with an 
equivalent set of elements. Keep in mind that this is a shallow 
copy of the collection. Only the element references are copied 
into the new collection, not the objects themselves.

For arrays, going from array to collection is easy, using the 
asList method of Array. Going from new collection to array is 
just as simple. Each of the collection implementations of the Set 
and List interfaces (the Collection implementations, not the Map 
implementations) provides two toArray methods for converting from 
Collection to an array:

   public Object[] toArray()
   Object[] toArray(Object type[])

By using either of these methods, you can get the current set of 
elements in the Collection as an array. The first toArray method
creates a new Object array, sized to fit the number of elements 
in the collection. The second array method allows you to define 
what type of array to return. If sized correctly, the input array 
is also used as the value returned. However, if the size is too 
small, a new array of the argument type is returned. 

The following program, ArrayConv, illustrates how you might 
convert a String array to a List and then back to a String array. 
Notice that the array passed into toArray is sized exactly to the 
list's size. This eliminates the need to create a second array to 
return. Also notice that you must cast the returned array to the 
appropriate type.

   import java.util.*;

   public class ArrayConv {
     public static void main(String args[]) {
       List list = Arrays.asList(args);
       String newargs[] =
         (String[])list.toArray(
                             new String[list.size()]);
       for (int i=0, n=newargs.length; i<n; i++) {
         System.out.println(newargs[i]);
       }
     }
   }

You can't convert a Map directly to an array. You can however 
convert a Map's set of keys, values, or entries to an array:

   Object keys[] = map.keySet().toArray();

The final conversion is from a Collection to an Enumeration. This 
is as simple as converting an array to a List. The 
java.util.Collections class offers an enumeration method for just
such a conversion. Given any Collection, this method converts it 
into an Enumeration:

   List l = Arrays.asList(args));
   Enumeration enum = Collections.enumeration(l);

As with the toArray() method, if you want to convert a Map to an 
Enumeration, you need to work with the map's specific set of 
entries, keys, or values:

   Enumeration enum = 
     Collections.enumeration(map.entrySet());

For more information on the Collections Framework, see the
Collections trail (http://java.sun.com/tutorial/collections/) in
the Java Tutorial. Also see the publication Java Collections
(http://www.apress.com/book/bookDisplay.html?bID=36).

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
CHOOSERS OUTSIDE DIALOGS

Common choosers such as file chooser and color chooser are 
typically displayed in a dialog window apart from the main 
application window. This is what users typically expect. Under 
normal circumstances, that is the only way you need to display 
these choosers. However, the JColorChooser and JFileChooser 
components are exactly that -- components. They are not windows. 
They become modal windows when their appropriate methods are 
called. For JColorChooser the appropriate method is showDialog, 
for JFileChooser, it's showDialog, showOpenDialog, or 
showSaveDialog. 

What if you don't want a new modal window to open for choosing
a color or for picking a file name (or directory)? The 
JColorChooser and JFileChooser components offer ways to provide 
for choosing without opening a modal window.

Working With Non-Modal Color Choosers

There are two ways of working with JColorChooser that don't 
involve a modal JDialog. A modal dialog is one that blocks input 
to the main program. If you don't want to block input to the main 
program, you can manage the JDialog yourself with the static 
createDialog method of JColorChooser. Alternatively, don't put 
the JColorChooser in a JDialog, and include it as part of your 
own window.

The createDialog technique creates a JDialog with OK, Cancel, and 
Reset buttons. When a user selects OK or Cancel, it automatically
hides the dialog. It is then your responsibility to fetch the 
selected color with getColor and respond accordingly. You must 
provide your own action listeners for both OK and Cancel 
selections. For non-modality, be sure to pass in an argument of 
false for modal.

  JDialog createDialog(Component c,
                       String title,
                       boolean modal,
                       JColorChooser chooserPane,
                       ActionListener okListener,
                       ActionListener cancelListener)
                         throws HeadlessException

Here's a simple example that creates non-modal JColorChooser 
components. Each time a user presses the button on the screen, 
it creates a new JColorChooser. The ActionListener for the OK 
button changes the button's background. The ActionListener for 
the Cancel button is null (that's because you don't need to do 
anything extra there, though you could). The default listeners 
only hide the JDialog, so if you wanted to reuse the chooser 
dialog, you could.

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

   public class ChangeColor {
     public static void main(String args[]) {
       final JFrame frame = new JFrame(
                             "Change Color");
       frame.setDefaultCloseOperation(
                                 JFrame.EXIT_ON_CLOSE);
       Container contentPane = frame.getContentPane();
       final JButton button = new JButton("Pick Me");
       ActionListener buttonListener = 
                                 new ActionListener() {
         public void actionPerformed(ActionEvent e) {
           final JColorChooser chooser =
             new JColorChooser(button.getBackground());
           ActionListener okListener = 
                                 new ActionListener() {
             public void actionPerformed(
                                       ActionEvent e) {
               button.setBackground(
                                   chooser.getColor());
             }
           };
           JDialog dialog = JColorChooser.createDialog(
             frame, "Pick Color", false, chooser, 
             okListener, null);
            dialog.show();
         }
      };
       button.addActionListener(buttonListener);
       contentPane.add(button, BorderLayout.CENTER);
       frame.setSize(200, 100);
       frame.show();
     }
   }

A more interesting use of a JColorChooser is to not place it in 
a JDialog. You can simply add the component to your own program's 
window. There are no OK, Cancel, or Reset buttons though. What 
you can do is respond to color selection. The JColorChooser 
manages its selected color through the ColorSelectionModel class
(http://java.sun.com/j2se/1.4.2/docs/api/javax/swing/colorchooser/
ColorSelectionModel.html). By attaching a ChangeListener to the 
model, you can respond to changes within the chooser.

   chooser.getSelectionModel().addChangeListener(...);
   ...
   // Within the listener
   public void stateChanged(ChangeEvent e) {
     Color color = chooser.getColor();
     // use new color
   }

To demonstrate, the following program, ChangeLabel, presents 
a screen with a label and a checkbox. It also presents an 
embedded JColorChooser. When a user makes a selection in the 
JColorChooser, the background and foreground colors of the label 
change. When the checkbox is checked, the background color 
changes, when unchecked, the foreground color changes.

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

   public class ChangeLabel {
     public static void main(String args[]) {
       final JFrame frame =
        new JFrame("Change Label");
        frame.setDefaultCloseOperation(
         JFrame.EXIT_ON_CLOSE);
       Container contentPane = frame.getContentPane();
       final JLabel label =
         new JLabel("Change my color now!");
         label.setFont(new Font("Serif", 
         Font.BOLD | Font.ITALIC, 18));
       label.setOpaque(true);
       final JCheckBox check =
         new JCheckBox("Change background?");
       JPanel panel = new JPanel();
       panel.add(check);
       panel.add(label);
       contentPane.add(panel, BorderLayout.NORTH);
       final JColorChooser chooser = 
                              new JColorChooser();
       ChangeListener changeListener = 
                                new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
           Color color = chooser.getColor();
           if (check.isSelected()) {
             label.setBackground(color);
           } else {
             label.setForeground(color);
           }
         }
       };
       chooser.getSelectionModel().
         addChangeListener(changeListener);
       contentPane.add(chooser, BorderLayout.CENTER);
       frame.pack();
       frame.show();
     }
   }

If you don't want to see the preview pane at the bottom of the 
screen (because your text is at the top), you can remove the 
preview pane by adding an empty one:

   chooser.setPreviewPanel(new JPanel());

Getting JFileChooser to be non-modal is similar to getting 
JColorChooser to be non-modal. However, a user might consider 
a non-modal JFileChooser to be a bit odd. What does it really mean 
to show a JFileChooser in the middle of an application window? 
So make a JFileChooser non-modal only after careful consideration.
In most cases, without customizing the component, it is not 
advisable to make a UI component look much different than the 
normal dialog chooser window.

The createDialog method of JFileChooser is protected, so the 
only way to create a non-modal JFileChooser is to add the 
JComponent into your own window. Create and add the component 
like any other component. Another way that JFileChooser is 
different than JColorChooser is that the Open and Cancel buttons
are always there (although you can change the Open button text). 
To respond to selection of either of these buttons, you must 
attach an ActionListener to the component. You determine which of 
the two buttons is selected, by checking the action command 
property of the ActionEvent passed into the ActionListener. For 
the Open button, the command is JFileChooser.APPROVE_SELECTION. 
For the Cancel button, the command is 
JFileChooser.CANCEL_SELECTION.

To demonstrate, the following program, ChooseFile, presents 
a JFileChooser in the main window of the program. A read-only 
text area is at the top of the screen. If a user presses Open in 
the JFileChooser, it changes the text field contents to the file 
name that the user selects. If the user presses Cancel, it clears 
the text field.

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

   public class ChooseFile {
     public static void main(String args[]) {
       final JFrame frame = new JFrame("Choose File");
       frame.setDefaultCloseOperation(
                                 JFrame.EXIT_ON_CLOSE);
       Container contentPane = frame.getContentPane();
       Box box = Box.createHorizontalBox();
       JLabel label = new JLabel("Name: ");
       box.add(label);
       final JTextField text = new JTextField();
       text.setEditable(false);
       box.add(text);
       contentPane.add(box, BorderLayout.NORTH);
       final JFileChooser chooser = new JFileChooser();
       ActionListener actionListener = 
                                 new ActionListener() {
         public void actionPerformed(ActionEvent e) {
           String command = e.getActionCommand();
           if (command.equals(
                     JFileChooser.APPROVE_SELECTION)) {
             String name = 
                   chooser.getSelectedFile().getName();
             text.setText(name);
           } else if (command.equals(
                      JFileChooser.CANCEL_SELECTION)) {
             text.setText("");
           }
         }
       };
       chooser.addActionListener(actionListener);
       contentPane.add(chooser, BorderLayout.CENTER);
       frame.pack();
       frame.show();
     }
   }

In deciding whether you want to add a JFileChooser to your 
application window, you need to keep in mind the user's expected 
behavior. As demonstrated in the previous example, you can add
a JFileChooser to an application window. In addition, adding 
an ActionListner to the component does allow you to respond to 
file selection. However, it's more common to add an Accessory 
component to the JFileChooser. This makes it easy to respond to 
selection of a file and to do things like preview an image or 
sample an audio file.

For more information on working with JColorChooser and 
JFileChooser, see  "How to Use Color Choosers"
(http://java.sun.com/tutorial/uiswing/components/colorchooser.html)
and "How to Use File Choosers"
(http://java.sun.com/tutorial/uiswing/components/filechooser.html)
in the Java Tutorial. 

.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

IMPORTANT: Please read our Terms of Use, Privacy, and Licensing 
policies:
http://www.sun.com/share/text/termsofuse.html
http://www.sun.com/privacy/
http://developer.java.sun.com/berkeley_license.html

* FEEDBACK
  Comments? Please enter your feedback on the Tech Tips at: 
  
     http://developers.sun.com/contact/feedback.jsp?category=sdn
  

* SUBSCRIBE/UNSUBSCRIBE

  Subscribe to other Java developer Tech Tips:
  
  - Enterprise Java Technologies Tech Tips. Get tips on using
    enterprise Java technologies and APIs, such as those in the
    Java 2 Platform, Enterprise Edition (J2EE).    
  - Wireless Developer Tech Tips. Get tips on using wireless
    Java technologies and APIs, such as those in the Java 2 
    Platform, Micro Edition (J2ME).
    
  To subscribe to these and other JDC publications:
  - Go to the JDC Newsletters and Publications page,
    (https://softwarereg.sun.com/registration/developer/en_US/subscriptions), 
    choose the newsletters you want to subscribe to and click 
    "Update".
  - To unsubscribe, go to the subscriptions page,
    (https://softwarereg.sun.com/registration/developer/en_US/subscriptions), 
    uncheck the appropriate checkbox, and click "Update".
  - To use our one-click unsubscribe facility, see the link at 
    the end of this email:
    
- ARCHIVES
You'll find the Core Java Technologies Tech Tips archives at:

http://java.sun.com/jdc/TechTips/index.html


- COPYRIGHT
Copyright 2003 Sun Microsystems, Inc. All rights reserved.
4150 Network Circle, Santa Clara, California 95054 USA.

This document is protected by copyright. For more information, see:

http://java.sun.com/jdc/copyright.html


Core Java Technologies Tech Tips 
October 21, 2003

Trademark Information: http://www.sun.com/suntrademarks/
Java, J2SE, J2EE, J2ME, and all Java-based marks are trademarks 
or registered trademarks of Sun Microsystems, Inc. in the 
United States and other countries.