Core Java Technologies Technical Tips

Return-Path: Received: from fort-point-station.mit.edu by po10.mit.edu (8.9.2/4.7) id SAA27734; Tue, 3 Dec 2002 18:39:42 -0500 (EST) Received: from hermes.sun.com (hermes.sun.com [64.124.140.169]) by fort-point-station.mit.edu (8.9.2/8.9.2) with SMTP id SAA15936 for ; Tue, 3 Dec 2002 18:39:42 -0500 (EST) Date: 3 Dec 2002 13:57:12 -0800 From: "JDC Tech Tips" To: alexp@mit.edu Message-Id: <263585151282598993@hermes.sun.com> Subject: Core Java Technologies Tech Tips, Dec. 3, 2002 (BitSet, JSpinner) Mime-Version: 1.0 Content-Type: text/html; charset=us-ascii Content-Transfer-Encoding: 7bit X-Mailer: SunMail 1.0 Core Java Technologies Technical Tips

View this issue as simple text December 3, 2002

In this Issue

Welcome to the Core Java^TM Technologies Tech Tips, December 3, 2002. Here you'll get tips on using core Java technologies and APIs, such as those in Java 2 Platform, Standard Edition (J2SE^TM).

This issue covers:

Using the BitSet Class

Using JSpinner to Choose From an Ordered List

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 Glen McCluskey.

USING THE BITSET CLASS

BitSet is a class you use to represent vectors of bits or true/false values. You can represent bitmaps and similar kinds of structures with BitSet objects. BitSets grow dynamically as new bits are set.

To start the discussion of BitSet, let's look at an example:

    import java.util.BitSet;
    
    public class BitSet1 {
        public static void main(String args[]) {
    
            // create a BitSet
    
            BitSet bitset = new BitSet();
    
            // set the 0th and 1000th bits
    
            bitset.set(0);
            bitset.set(1000);
    
            // display the size, length, 
            // and cardinality
    
            System.out.println(
                "size = " + bitset.size());
            System.out.println(
                "length = " + bitset.length());
            System.out.println("cardinality = " +
                bitset.cardinality());
    
            // list the bits that are set, 
            // using toString()
    
            System.out.println("list #1 = " + bitset);
    
            // list the bits that are set, 
            // using a loop
    
            System.out.print("list #2 = ");
            for (int i = 0, len = bitset.length(); 
                i < len; i++) {
                    if (bitset.get(i)) {
                        System.out.print(i + " ");
                    }
            }
            System.out.println();
    
            // list the bits that are set, 
            // using an iterator
    
            System.out.print("list #3 = ");
            for (int i = bitset.nextSetBit(0); i >= 0;
            i = bitset.nextSetBit(i + 1)) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }

The BitSet1 program creates a BitSet and sets the 0th and 1000th bits to true. Other bits between 0 and 1000 have false values. BitSet allocates enough memory internally to represent the highest set bit. Bits beyond the highest set bit are considered to be false.

One way of thinking about a BitSet is that it's a vector of 2^31 true or false bits, with all of the bits initially set to false. The bits have indices from 0 to Integer.MAX_VALUE, or 2^31 - 1. As bits are set to true, memory is allocated to represent them.

The program prints the size, length, and cardinality of the BitSet. The size is the the actual number of bits used by the BitSet. The length is the index of the highest set bit plus one. The cardinality is the number of bits currently set to true in the BitSet.

The program also illustrates three ways of retrieving a list of the set bits in the BitSet. The first way uses the BitSet.toString method. The second way uses a loop and the get method to check each index in the BitSet. The third way makes use of the BitSet.nextSetBit method to iterate across all the set bits.

When you run the program, the output is:

    size = 1024
    length = 1001
    cardinality = 2
    list #1 = {0, 1000}
    list #2 = 0 1000 
    list #3 = 0 1000

This example also illustrates the idea that internal space to store the bits is dynamically allocated as needed. For example, if the 1000th bit is set, then the BitSet must grow to about 125 bytes.

Here's another example that illustrates this point:

    import java.util.BitSet;
    
    public class BitSet2 {
        public static void main(String args[]) {
            BitSet bitset = new BitSet();
            bitset.set(1000000);
            System.out.println(
                "number of bytes required = " +
                bitset.size() / 8);
        }
    }

This BitSet2 program sets the millionth bit in a BitSet. The output of the program is:

    number of bytes required = 125008

This particular BitSet object must grow to about 125,000 bytes to represent the millionth bit. Note that you can specify the size of the BitSet to the constructor, that is, if you know in advance how big the BitSet is likely to get. Doing this will save time and space reallocation as well as copying. BitSet as currently implemented uses a particular internal data structure (64-bit longs) to represent bits. This representation is not part of the external BitSet interface, however this tip assumes a particular model of memory allocation. This model is based on an array of longs, which represent all bits, true or false, so as to include the highest set bit. However, there are other possible ways to represent sets of bits. Note that the results from the size method might not make much sense if some other type of internal structure is used.

Let's look at another example. This one shows how you can perform common logical operations on a pair of BitSets:

    import java.util.BitSet;
    
    public class BitSet3 {
        public static void main(String args[]) {
    
            // create two sets of bits
    
            BitSet bitset1 = new BitSet();
            bitset1.set(1);
            bitset1.set(5);
            bitset1.set(8);
    
            BitSet bitset2 = new BitSet();
            bitset2.set(2);
            bitset2.set(5);
            bitset2.set(7);
            bitset2.set(11);
    
            // make a copy of the first one and XOR 
            // with the second
    
            BitSet result = (BitSet)bitset1.clone();
            result.xor(bitset2);
    
            System.out.println(bitset1 + " XOR " + 
                bitset2 + " = " + result);
        }
    }

Normally, when you have two BitSets and you do a logical operation like this:

    bitset1.xor(bitset2);

The result of the operation (exclusive-OR) is left in bitset1. But the idea in this example is to leave bitset1 unchanged. So the program makes a copy of bitset1 using the clone method.

When you run this example, the result is:

    {1, 5, 8} XOR {2, 5, 7, 11} = {1, 2, 7, 8, 11}

A bit is set in the result BitSet if it is set in one, but not both, of the operand BitSets. The BitSet class offers similar methods for computing AND, OR, and ANDNOT. The ANDNOT method, which performs the operation a & ~b, is used to mask out bits in a BitSet.

A final example illustrates how you use BitSet features to operate on a range or group of bits:

    import java.util.BitSet;
    
    public class BitSet4 {
        public static void main(String args[]) {
            BitSet bitset1 = new BitSet();
    
            // set bits from 0 (inclusive) 
            // to 99 (exclusive)
    
            bitset1.set(0, 99);
    
            // get bits from 0 (inclusive) 
            // to 9 (exclusive)
    
            BitSet bitset2 = bitset1.get(0, 9);
    
            System.out.println(bitset2);
        }
    }

The BitSet4 program creates a BitSet, and then sets bits 0-98 to true. Then bits 0-8 of this BitSet are copied into a new BitSet. The output is:

    {0, 1, 2, 3, 4, 5, 6, 7, 8}

BitSet is an efficient way to represent and manipulate a large number of true/false values.

For more information about BitSet, see section 17.1, BitSet, in "The Java^TM Programming Language Third Edition" by Arnold, Gosling, and Holmes.

USING JSPINNER TO CHOOSE FROM AN ORDERED LIST

JSpinner is a Swing class you use to display an ordered sequence of items, such as numbers or strings or calendar dates. A user can make a selection from the displayed sequence, or explicitly enter a value. JSpinner is similar to JComboBox, but instead of using a drop-down list to display the items, it employs a couple of tiny arrow keys that allow a user to sequence through a series of values.

Let's look at an example that compares and contrasts JSpinner and JComboBox:

    import java.awt.*;
    import javax.swing.*;
    import javax.swing.event.*;
    
    public class SpinDemo1 {
        public static void main(String args[]) {
    
            // create a JFrame
    
            JFrame frame = new JFrame("SpinDemo1");
            frame.setDefaultCloseOperation(
                JFrame.EXIT_ON_CLOSE);
    
            // create a JSpinner with a range of 
            // values 1-5 and starting value 1 
            // and increment 1
    
            final SpinnerModel sm =
                new SpinnerNumberModel(new Integer(1),
                new Integer(1), new Integer(5), 
                    new Integer(1));
            JSpinner jsp = new JSpinner(sm);
    
            // add a change listener
    
            jsp.addChangeListener(
                new ChangeListener() {
                    public void stateChanged(
                        ChangeEvent e) {
                            System.out.println(
                                "changed: " +
                                sm.getValue());
                    }
                });
    
            // create a JComboBox
    
            Object list[] = {new Integer(1), 
                new Integer(2), new Integer(3), 
                new Integer(4), new Integer(5)};
            JComboBox jcb = new JComboBox(list);
            jcb.setEditable(true);
    
            // create a JPanel
    
            JPanel panel = new JPanel();
            panel.setPreferredSize(
                new Dimension(300, 300));
            panel.add(jsp);
            panel.add(jcb);
            frame.getContentPane().add(panel);
    
            // display the frame
    
            frame.pack();
            frame.setVisible(true);
        }
    }

This SpinDemo1 program sets up a JPanel containing a JSpinner and a JComboBox. Both of these display the Integer wrapper values 1-5. Both JSpinner and JComboBox also allow you to enter your own value. But the JComboBox pull-down list uses a lot more window space when it displays its list of values. If there is another GUI item such as a label or input area just below the JComboBox, it will be temporarily obscured when the list of values is displayed. So JSpinner has an advantage in operating within a more constrained area of the window.

The example highlights another difference between JSpinner and JComboBox. A JSpinner uses an ordered set of values called the model. In the SpinDemo1 program the model is represented by a SpinnerNumberModel object. Minimum and maximum values as well as a starting value and an increment/decrement are set for the model. The JSpinner uses the model to validate its input. For example, if you enter "7" for the example above, it will not be accepted. You can literally type "7" in the JSpinner input field, but it will not be treated as a legal value. You can tell this by the change listener that is called when the value changes.

By contrast, JComboBox lets you type in any value you want, whether or not it's in the list specified to the JComboBox constructor. This functionality might be just what you need -- it all depends on your particular application.

Here's another example, one that uses JSpinner with a list of strings:

    import java.awt.*;
    import javax.swing.*;
    import javax.swing.event.*;
    
    public class SpinDemo2 {
        public static void main(String args[]) {
    
            // create a JFrame
    
            JFrame frame = new JFrame("SpinDemo2");
            frame.setDefaultCloseOperation(
                JFrame.EXIT_ON_CLOSE);
    
            // create a JSpinner 
            // based on a list of strings
    
            Object list[] = {"string1", "string2", 
                "string3"};
            SpinnerModel sm = 
                new SpinnerListModel(list);
            JSpinner jsp = new JSpinner(sm);
    
            // create a JPanel
    
            JPanel panel = new JPanel();
            panel.setPreferredSize(
                new Dimension(300, 300));
            panel.add(jsp);
            frame.getContentPane().add(panel);
    
            // display the frame
    
            frame.pack();
            frame.setVisible(true);
        }
    }

As with the previous example, any input typed by the user is validated against the specified list of strings.

Let's look at a slightly more complicated example, one where you specify a starting calendar date and then step through dates in one-minute intervals:

    import java.util.*;
    import java.awt.*;
    import javax.swing.*;
    import javax.swing.event.*;
   
    public class SpinDemo3 {
        public static void main(String args[]) {
   
            // create a JFrame
   
            JFrame frame = new JFrame("SpinDemo3");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
            // create a JSpinner set to the current
            // date, with increment/decrement
            // set to minutes
   
            final SpinnerModel sm =
                new SpinnerDateModel(new Date(),
                null, null, Calendar.MINUTE);
            JSpinner jsp = new JSpinner(sm);
   
            // add a change listener for the JSpinner
   
            jsp.addChangeListener(
                new ChangeListener() {
                    public void stateChanged(
                        ChangeEvent e) {
                            Date d = (Date)sm.getValue();
                            System.out.println(
                                "new date: " + d);
                }
            });
   
            // create a JPanel
   
            JPanel panel = new JPanel();
            panel.setPreferredSize(
                new Dimension(300, 300));
            panel.add(jsp);
            frame.getContentPane().add(panel);
   
            // display the frame
   
            frame.pack();
            frame.setVisible(true);
        }
    }

In the first example, SpinDemo1, the program specified a range of values 1-5, a starting value of 1, and an increment/decrement of 1. In the SpinDemo3 example, the program starts with the current date, sets no minimum or maximum date values, and sets the increment/decrement to one minute. A user presented with the display can step through calendar dates in one-minute increments, or enter a date as desired. The change listener shows how to retrieve the current Date value from the underlying model used by the JSpinner object.

You may notice that the change listener is called twice the first time you increment or decrement the date in the JSpinner field. This behavior occurs because the displayed calendar date does not represent the full precision of the date stored internally, and rounding of the internal date will occur to match the displayed date. The first call to the change listener happens because of this rounding.

JSpinner is useful in situations where you'd like to let the user choose from an ordered sequence of values, and have input validation. JSpinner is also useful in situations where you want to economize on the use of window space.

For more information about JSpinner, see "JSpinner - A Simple Sequence Container".

Reader Feedback

Very worth reading Worth reading Not worth reading

If you have other comments or ideas for future technical tips, please type them here:

Have a question about Java^TM programming? Use Java Online Support.

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

Comments? Send your feedback on the Core Java^TM Technologies Tech Tips to: jdc-webmaster@sun.com

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^TM).
- Wireless Developer Tech Tips. Get tips on using wireless Java technologies and APIs, such as those in the Java 2 Platform, Micro Edition (J2ME^TM).

To subscribe to these and other JDC publications:
- Go to the JDC Newsletters and Publications page, choose the newsletters you want to subscribe to and click "Update".
- To unsubscribe, go to the subscriptions page, uncheck the appropriate checkbox, and click "Update".

ARCHIVES: You'll find the Core Java Technologies Tech Tips archives at:
http://java.sun.com/jdc/TechTips/index.html

Copyright 2002 Sun Microsystems, Inc. All rights reserved.
901 San Antonio Road, Palo Alto, California 94303 USA.

This document is protected by copyright. For more information, see:
http://java.sun.com/jdc/copyright.html

Sun, Sun Microsystems, Java, Java Developer Connection, J2SE, J2EE, and J2ME are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries.

Please send me newsletters in text.
Please unsubscribe me from this newsletter.