0 through 5. Then simply shift this value by adding 1 to produce a number in the range from 1 through 6. The expression is as follows:

Math.abs( r.nextInt() ) % 6 + 1

The calls

r.nextFloat()

r.nextDouble()

generate uniformly distributed values in the range 0.0 <= x < 1.0. The call

r.nextGaussian()

generates a double value with a probability density of a Gaussian (i.e., “normal”) distribution (mean of 0.0 and standard deviation of 1.0).

20.8 Bit Manipulation and the Bitwise Operators

Java provides extensive bit-manipulation capabilities for programmers who need to get down to the so-called “bits-and-bytes” level. Operating systems, test equipment software, networking software and many other kinds of software require that the programmer communicate “directly with the hardware.” In this section and the next, we discuss Java’s bitmanipulation capabilities. We introduce Java’s bitwise operators, and we demonstrate their use in live-code examples.

Computers represent all data internally as sequences of bits. Each bit can assume the value 0 or the value 1. On most systems, a sequence of 8 bits forms a byte—the standard storage unit for a variable of type byte. Other data types are stored in larger numbers of bytes. The bitwise operators can manipulate the bits of integral operands (i.e., those having type byte, char, short, int and long).

Note that the bitwise operator discussions in this section show the binary representations of the integer operands. For a detailed explanation of the binary (also called base 2) number system, see Appendix E, Number Systems.

The bitwise operators are bitwise AND (&), bitwise inclusive OR (|), bitwise exclusive OR (^), left shift (<<), right shift with sign extension (>>), right shift with zero extension

(>>>) and complement (~). The bitwise AND, bitwise inclusive OR and bitwise exclusive OR operators compare their two operands bit by bit. The bitwise AND operator sets each bit in the result to 1 if the corresponding bit in both operands is 1. The bitwise inclusive OR operator sets each bit in the result to 1 if the corresponding bit in either (or both) operand(s) is 1. The bitwise exclusive OR operator sets each bit in the result to 1 if the corresponding bit in exactly one operand is 1. The left shift operator shifts the bits of its left operand to the left by the number of bits specified in its right operand. The right shift operator with sign extension shifts the bits in its left operand to the right by the number of bits specified in its right operand—if the left operand is negative, 1s are shifted in from the left; otherwise, 0s are shifted in from the left. The right shift operator with zero extension shifts the bits in its left operand to the right by the number of bits specified in its right operand—0s are shifted in from the left. The bitwise complement operator sets all 0 bits in its operand to 1 in the result and sets all 1 bits to 0 in the result. Detailed discussions of each bitwise operator appear in the following examples. The bitwise operators are summarized in Fig. 20.5.

7

8 // Java extension packages

9 import javax.swing.*;

10

11public class PrintBits extends JFrame {

12private JTextField outputField;

13

14// set up GUI

15public PrintBits()

16{

17super( "Printing bit representations for numbers" );

19Container container = getContentPane();

20container.setLayout( new FlowLayout() );

22 container.add( new JLabel( "Enter an integer " ) );

23

24// textfield to read value from user

25JTextField inputField = new JTextField( 10 );

38}

39);

41 container.add( inputField );

42

43 container.add( new JLabel( "The integer in bits is" ) );

44

45// textfield to display integer in bitwise form

46outputField = new JTextField( 33 );

47outputField.setEditable( false );

48container.add( outputField );

49

50setSize( 720, 70 );

51setVisible( true );

52}

53

54// display bit representation of specified int value

55private String getBits( int value )

56{

57// create int value with 1 in leftmost bit and 0s elsewhere

58int displayMask = 1 << 31;

59

Fig. 20.6 Printing the bits in an integer (part 2 of 3).

60// buffer to build output

61StringBuffer buffer = new StringBuffer( 35 );

63// for each bit append 0 or 1 to buffer

64for ( int bit = 1; bit <= 32; bit++ ) {

79return buffer.toString();

80}

81

82// execute application

83public static void main( String args[] )

84{

85PrintBits application = new PrintBits();

87 application.setDefaultCloseOperation(

88JFrame.EXIT_ON_CLOSE );

89}

90

91 } // end class PrintBits

Fig. 20.6 Printing the bits in an integer (part 3 of 3).

Lines 68–69 append a 1 or a 0 to a StringBuffer for the current leftmost bit of variable value. Assume that value contains 4000000000 (11101110 01101011 00101000 00000000). When value and displayMask are combined using &, all the bits except the high-order (leftmost) bit in variable value are “masked off” (hidden), because any bit “ANDed” with 0 yields 0. If the leftmost bit is 1, value & displayMask evaluates to a nonzero value and 1 is appended; otherwise, 0 is appended. Then vari-

15 private int value1, value2;

16

17// set up GUI

18public MiscBitOps()

19{

20super( "Bitwise operators" );

22JPanel inputPanel = new JPanel();

23inputPanel.setLayout( new GridLayout( 4, 2 ) );

25inputPanel.add( new JLabel( "Enter 2 ints" ) );

26inputPanel.add( new JLabel( "" ) );

27

28inputPanel.add( new JLabel( "Value 1" ) );

29input1Field = new JTextField( 8 );

30inputPanel.add( input1Field );

31

32inputPanel.add( new JLabel( "Value 2" ) );

33input2Field = new JTextField( 8 );

34inputPanel.add( input2Field );

35

36inputPanel.add( new JLabel( "Result" ) );

37resultField = new JTextField( 8 );

38resultField.setEditable( false );

39inputPanel.add( resultField );

40

41JPanel bitsPanel = new JPanel();

42bitsPanel.setLayout( new GridLayout( 4, 1 ) );

43bitsPanel.add( new JLabel( "Bit representations" ) );

45bits1Field = new JTextField( 33 );

46bits1Field.setEditable( false );

47bitsPanel.add( bits1Field );

48

49bits2Field = new JTextField( 33 );

50bits2Field.setEditable( false );

51bitsPanel.add( bits2Field );

52

53bits3Field = new JTextField( 33 );

54bits3Field.setEditable( false );

55bitsPanel.add( bits3Field );

56

57 JPanel buttonPanel = new JPanel();

58

59// button to perform bitwise AND

60JButton andButton = new JButton( "AND" );

Fig. 20.8 Demonstrating the bitwise AND, bitwise inclusive OR, bitwise exclusive OR and bitwise complement operators (part 2 of 6).

74}

75);

77 buttonPanel.add( andButton );

78

79// button to perform bitwise inclusive OR

80JButton inclusiveOrButton = new JButton( "Inclusive OR" );

94}

95);

114}

115);

117 buttonPanel.add( exclusiveOrButton );

Fig. 20.8 Demonstrating the bitwise AND, bitwise inclusive OR, bitwise exclusive OR and bitwise complement operators (part 3 of 6).

Fig. 20.10 Results of combining two bits with the bitwise exclusive OR operator (^).

The bitwise complement operator (~) sets all 1 bits in its operand to 0 in the result and sets all 0 bits to 1 in the result—otherwise referred to as “taking the one's complement of the value.” The fourth output window for Fig. 20.8 shows the results of taking the one’s complement of the value 21845. The result is -21846.

The program of Fig. 20.11 demonstrates the left shift operator (<<), the right shift operator with sign extension (>>) and the right shift operator with zero extension (>>>). Method getBits (lines 113–138) obtains a String containing the bit representation of the integer values. The program allows the user to enter an integer into a JTextField and press Enter to display the bit representation of the integer in a second JTextField. The the user can press a button representing a shift operation to perform a 1-bit shift and view the results of the shift in both integer and bitwise representation.

1// Fig. 20.11: BitShift.java

2 // Using the bitwise shift operators.

3

4 // Java core packages

5import java.awt.*;

6 import java.awt.event.*;

7

8 // Java extension packages

9 import javax.swing.*;

10

11public class BitShift extends JFrame {

12private JTextField bitsField;

13private JTextField valueField;

14

15// set up GUI

16public BitShift()

17{

18super( "Shifting bits" );

20Container container = getContentPane();

21container.setLayout( new FlowLayout() );

23 container.add( new JLabel( "Integer to shift " ) );

24

25// textfield for user to input integer

26valueField = new JTextField( 12 );

Fig. 20.11 Demonstrating the bitwise shift operators (part 1 of 5).

39}

40);

42// textfield to display bitwise representation of an integer

43bitsField = new JTextField( 33 );

44bitsField.setEditable( false );

45container.add( bitsField );

46

47// button to shift bits left by one position

48JButton leftButton = new JButton( "<<" );

62}

63);

65 container.add( leftButton );

66

67// button to right shift value one position with sign extension

68JButton rightSignButton = new JButton( ">>" );

Fig. 20.11 Demonstrating the bitwise shift operators (part 5 of 5).

The left shift operator (<<) shifts the bits of its left operand to the left by the number of bits specified in its right operand (performed at line 58 in the program). Bits vacated to the right are replaced with 0s; 1s shifted off the left are lost. The first four output windows of Fig. 20.11 demonstrate the left shift operator. Starting with the value 1, the left shift button was pressed twice, resulting in the values 2 and 4, respectively. The fourth output window shows the result of value1 being shifted 31 times. Note that the result is a negative value. That is because a 1 in the high-order bit is used to indicate a negative value in an integer.

The right shift operator with sign extension (>>) shifts the bits of its left operand to the right by the number of bits specified in its right operand (performed at line 78 in the program). Performing a right shift causes the vacated bits at the left to be replaced by 0s if the number is positive or 1s if the number is negative. Any 1s shifted off the right are lost. The fifth and sixth output windows show the results of right shifting (with sign extension) the value in the fourth output window two times.

The right shift operator with zero extension (>>>) shifts the bits of its left operand to the right by the number of bits specified in its right operand (performed at line 98 in the program). Performing a right shift causes the vacated bits at the left to be replaced by 0s. Any 1s shifted off the right are lost. The eighth and ninth output windows show the results of right shifting (with zero extension) the value in the seventh output window two times.

Each bitwise operator (except the bitwise complement operator) has a corresponding assignment operator. These bitwise assignment operators are shown in Fig. 20.12.

The expression

b.size()

returns the size of the BitSet. The expression

b.equals( b1 )

compares the two BitSets for equality. The expression

b.toString()

creates a String representation of the BitSet contents. This is helpful for debugging. Figure 20.13 revisits the Sieve of Eratosthenes for finding prime numbers, which we dis-

cussed in Exercise 7.27. This example uses a BitSet rather than an array to implement the algorithm. The program displays all the prime numbers from 2 to 1023 in a JTextArea and provides a JTextField in which the user can type any number from 2 to 1023 to determine whether that number is prime (in which case a message is displayed in a JLabel).

1// Fig. 20.13: BitSetTest.java

2 // Using a BitSet to demonstrate the Sieve of Eratosthenes.

3

4 // Java core packages

5import java.awt.*;

6 import java.awt.event.*;

7 import java.util.*;

8

9 // Java extension packages

10 import javax.swing.*;

11

12public class BitSetTest extends JFrame {

13private BitSet sieve;

14private JLabel statusLabel;

15private JTextField inputField;

16

17// set up GUI

18public BitSetTest()

19{

20super( "BitSets" );

22 sieve = new BitSet( 1024 );

23

24 Container container = getContentPane();

25

26statusLabel = new JLabel( "" );

27container.add( statusLabel, BorderLayout.SOUTH );

Fig. 20.13 Demonstrating the Sieve of Eratosthenes using a BitSet (part 1 of 3).

91setSize( 600, 450 );

92setVisible( true );

93}

94

95// execute application

96public static void main( String args[] )

97{

98BitSetTest application = new BitSetTest();

100 application.setDefaultCloseOperation(

101JFrame.EXIT_ON_CLOSE );

102}

103

104 } // end class BitSetTest

Fig. 20.13 Demonstrating the Sieve of Eratosthenes using a BitSet (part 3 of 3).

Line 22 creates a BitSet of 1024 bits. We ignore the bit at index 0 in this program. Lines 68–69 set all the bits in the BitSet to on with BitSet method set. Lines 72–79 determine all the prime numbers from 2 to 1023. The integer finalBit specifies when the algorithm is complete. The basic algorithm is that a number is prime if it has no divisors other than 1 and itself. Starting with the number 2, once we know a number is prime, we can eliminate all multiples of that number. The number 2 is only divisible by 1 and itself, so it is prime. Therefore, we can eliminate 4, 6, 8 and so on. Elimination of a value consists

of setting its bit to off with BitSet method clear. The number 3 is divisible by 1 and itself. Therefore, we can eliminate all multiples of 3 (keep in mind that all even numbers have already been eliminated). After the list of primes is displayed, the user can type a value from 2 to 1023 in the textfield and press enter to determine whether the number is prime. Method actionPerformed (lines 42–53) uses BitSet method get (line 46) to determine whether the bit for the number the user entered is set. If so, lines 47–48 display a message indicating that the number is prime. Otherwise, lines 51–52 display a message indicating that the number is not prime.

SUMMARY

•Class Vector manages dynamically resizable arrays. At any time the Vector contains a certain number of elements which is less than or equal to its capacity. The capacity is the space that has been reserved for the array.

•If a Vector needs to grow, it grows by an increment that you specify or by a default assumed by the system. If you do not specify a capacity increment, the system automatically doubles the size of the Vector each time additional capacity is required.

•Vectors store references to Objects. To store values of primitive data types in Vectors, use the type-wrapper classes (Byte, Short, Integer, Long, Float, Double, Boolean and

Character) to create objects containing the primitive data type values.

•Class Vector provides three constructors. The no-argument constructor creates an empty Vector. The constructor that takes one argument creates a Vector with an initial capacity specified by the argument. The constructor that takes two arguments creates a Vector with an initial capacity specified by the first argument and a capacity increment specified by the second argument.

•Vector method addElement adds its argument to the end of the Vector. Method insertElementAt inserts an element at the specified position. Method setElementAt sets the element at a specific position.

•Vector method removeElement removes the first occurrence of its argument. Method removeAllElements removes every element from the Vector. Method removeElementAt removes the element at the specified index.

•Vector method firstElement returns a reference to the first element. Method lastElement returns a reference to the last element.

•Vector method isEmpty determines whether the Vector is empty.

•Vector method contains determines whether the Vector contains the searchKey specified as an argument.

•Vector method indexOf gets the index of the first location of its argument. The method returns –1 if the argument is not found in the Vector.

•Vector method trimToSize cuts the capacity of the Vector to the Vector’s size. Methods size and capacity determine the number of elements currently in the Vector and the number of elements that can be stored in the Vector without allocating more memory, respectively.

•Vector method elements returns a reference to an Enumeration containing the elements of the Vector.

•Enumeration method hasMoreElements determines whether there are more elements. Method nextElement returns a reference to the next element.

•Class Stack extends class Vector. Stack method push adds its argument to the top of the stack. Method pop removes the top element of the stack. Method peek returns an Object ref-

erence to the top element of the stack without removing the element. Stack method empty determines whether the stack is empty.

•A Dictionary transforms keys to values.

•Hashing is a high-speed scheme for converting keys into unique array subscripts for storage and retrieval of information.The load factor is the ratio of the number of occupied cells in a hash table to the size of the hash table. The closer this ratio gets to 1.0, the greater the chance of collisions.

•The no-argument Hashtable constructor creates a Hashtable with a default capacity of 101 elements and a default load factor of .75. The Hashtable constructor that takes one argument specifies the initial capacity; the constructor that takes two arguments specifies the initial capacity and load factor, respectively.

•Hashtable method put adds a key and a value into a Hashtable. Method get locates the value associated with the specified key. Method remove deletes the value associated with the specified key. Method isEmpty determines whether the table is empty.

•Hashtable method containsKey determines whether the key specified as an argument is in the Hashtable (i.e., a value is associated with that key). Method contains determines whether the Object specified as its argument is in the Hashtable. Method clear empties the Hashtable. Method elements obtains an Enumeration of the values. Method keys obtains an Enumeration of the keys.

•A Properties object is a persistent Hashtable object. Class Properties extends Hashtable. Keys and values in a Properties object must be Strings.

•The Properties no-argument constructor creates an empty Properties table with no default properties. There is also an overloaded constructor that is passed a reference to a default Properties object containing default property values.

•Properties method getProperty locates the value of the key specified as an argument. Method store saves the contents of the Properties object to the OutputStream object specified as the first argument. Method load restores the contents of the Properties object from the InputStream object specified as the argument. Method propertyNames obtains an Enumeration of the property names.

•Java provides extensive random-number generation capabilities in class Random. Class Random’s no-argument constructor uses the time to seed its random-number generator differently each time it is called. To create a pseudorandom-number generator with repeatability, use the Random constructor that takes a seed argument.

•Random method setSeed sets the seed. Methods nextInt and nextLong generate uniformly distributed random integers. Methods nextFloat and nextDouble generate uniformly distributed values in the range 0.0 <= x < 1.0.

•The bitwise AND (&) operator sets each bit in the result to 1 if the corresponding bit in both operands is 1.

•The bitwise inclusive OR (|) operator sets each bit in the result to 1 if the corresponding bit in either (or both) operand(s) is 1.

•The bitwise exclusive OR (^) operator sets each bit in the result to 1 if the corresponding bit in exactly one operand is 1.

•The left shift (<<) operator shifts the bits of its left operand to the left by the number of bits specified in its right operand.

•The right shift operator with sign extension (>>) shifts the bits in its left operand to the right by the number of bits specified in its right operand—if the left operand is negative, 1s are shifted in from the left; otherwise, 0s are shifted in from the left.

tor increases, there are fewer available slots relative to the total number of slots, so the chance of selecting an occupied slot (a collision) with a hashing operation increases.

20.3When a program calls pop or peek on an empty Stack object, an EmptyStackException occurs.

20.4a) bitwise AND (&). b) bitwise inclusive OR (|). c) bitwise exclusive OR (^). d) mask. e) left shift operator (<<). f) right shift operator with sign extension (>>), right shift operator with zero extension (>>>).

EXERCISES

20.5Define each of the following terms in the context of hashing:

a)key

b)collision

c)hashing transformation

d)load factor

e)space–time trade-off

f)Hashtable class

g)capacity of a Hashtable

20.6Explain briefly the operation of each of the following methods of class Vector:

a)addElement

b)insertElementAt

c)setElementAt

d)removeElement

e)removeAllElements

f)removeElementAt

g)firstElement

h)lastElement

i)isEmpty

j)contains

k)indexOf

l)trimToSize

m)size

n)capacity

20.7Explain why inserting additional elements into a Vector object whose current size is less than its capacity is a relatively fast operation and why inserting additional elements into a Vector object whose current size is at capacity is a relatively slow operation.

20.8In the text, we state that the default capacity increment of doubling the size of a Vector might seem wasteful of storage, but it is actually an efficient way for Vectors to grow quickly to be “about the right size.” Explain this statement. Explain the pros and cons of this doubling algorithm. What can a program do when it determines that the doubling is wasting space?

20.9Explain the use of the Enumeration interface with objects of class Vector.

20.10By extending class Vector, Java’s designers were able to create class Stack quickly. What are the negative aspects of this use of inheritance, particularly for class Stack?

20.11Explain briefly the operation of each of the following methods of class Hashtable:

a)put

b)get

c)remove

d)isEmpty

e)containsKey

f)contains

g)clear

h)elements

i)keys

20.12Explain how to use the Random class to create pseudorandom numbers with the repeatability required for debugging purposes.

20.13Use a Hashtable to create a reusable class for choosing one of the 13 predefined colors in class Color. The name of the color should be used as keys and the predefined Color objects should be used as values. Place this class in a package that can be imported into any Java program. Use your new class in an application that allows the user to select a color and draw a shape in that color.

20.14Modify your solution to Exercise 13.18—the polymorphic painting program—to store every shape the user draws in a Vector of MyShape objects. For the purpose of this exercise, create your own Vector subclass called ShapeVector that manipulates only MyShape objects. Provide the following capabilities in your program:

a)Allow the user of the program to remove any number of shapes from the Vector by clicking an Undo button.

b)Allow the user to select any shape on the screen and move it to a new location. This requires the addition of a new method to the MyShape hierarchy. The method’s first line should be

public boolean isInside()

This method should be overridden for each subclass of MyShape to determine whether the coordinates where the user pressed the mouse button are inside the shape.

c)Allow the user to select any shape on the screen and change its color.

d)Allow the user to select any shape on the screen that can be filled or unfilled and change its fill state.

20.15What does it mean when we state that a Properties object is a “persistent” Hashtable object? Explain the operation of each of the following methods of the Properties class:

a)load

b)store

c)getProperty

d)propertyNames

e)list

20.16Why might you want to use objects of class BitSet? Explain the operation of each of the following methods of class BitSet:

a)set

b)clear

c)get

d)and

e)or

f)xor

g)size

h)equals

i)clone

j)toString

k)hashCode

20.17Write a program that right shifts an integer variable 4 bits with sign extension and then right shifts the same integer variable 4 bits with zero extension. The program should print the integer in

bits before and after each shift operation. Run your program once with a positive integer and once with a negative integer.

20.18Show how shifting an integer left by 1 can be used to simulate multiplication by 2 and how shifting an integer right by 2 can be used to simulate division by 2. Be careful to consider issues related to the sign of an integer.

20.19Write a program that reverses the order of the bits in an integer value. The program should input the value from the user and call method reverseBits to print the bits in reverse order. Print the value in bits both before and after the bits are reversed to confirm that the bits are reversed properly. You might want to implement both a recursive and an iterative solution.

20.20Modify your solution to Exercise 19.10 to use class Stack.

20.21Modify your solution to Exercise 19.12 to use class Stack.

20.22Modify your solution to Exercise 19.13 to use class Stack.