OReilly java cookbook jan 2001 ISBN 0596001703 pdf

My stupid release 2002J
For all the people which doesn’t have money to buy a good book


Book Description

The Java Cookbook is a comprehensive collection of problems, solutions, and practical
examples for anyone programming in Java. Developers will find hundreds of tried-andtrue Java "recipes" covering all of the major APIs as well as some APIs that aren't as well
documented in other Java books.
The Java Cookbook, like the bestselling Perl Cookbook, covers a lot of ground, and
offers Java developers short, focused pieces of code that can be easily incorporated into
other programs. The idea is to focus on things that are useful, tricky, or both. The book
includes code segments covering many specialized APIs--like media and servlets--and
should serve as a great "jumping-off place" for Java developers who want to get started in
areas outside of their specialization.
The book provides quick solutions to particular problems that can be incorporated into
other programs, but that aren't usually programs in and of themselves.

2


Preface......................................................................................................................... 11
Who This Book Is For ............................................................................................ 12
What's in This Book? ............................................................................................. 12
Platform Notes ........................................................................................................ 14
Other Books ............................................................................................................ 15
Conventions Used in This Book........................................................................... 17
Getting the Source Code....................................................................................... 18
Acknowledgments .................................................................................................. 19
Chapter 1. Getting Started: Compiling, Running, and Debugging ..................... 21
1.1 Introduction ....................................................................................................... 21

1.2 Compiling and Running Java: JDK ............................................................... 22
1.3 Editing and Compili ng with a Color-Highlighting Editor ............................. 26
1.4 Compiling, Running, and Testing with an IDE ............................................ 27
1.5 Using Classes from This Book ...................................................................... 31
1.6 Automating Compilation with jr ...................................................................... 32
1.7 Automating Compilation with make .............................................................. 33
1.8 Automating Compilation with Ant .................................................................. 34
1.9 Running Applets............................................................................................... 36
1.10 Dealing with Deprecation Warnings ........................................................... 38
1.11 Conditional Debugging without #ifdef......................................................... 40
1.12 Debugging Printouts ..................................................................................... 41
1.13 Using a Debugger ......................................................................................... 42
1.14 Unit Testing: Avoid the Need for Debuggers ............................................ 44
1.15 Decompiling Java Class Files ..................................................................... 46
1.16 Preventing Others from Decompiling Your Java Files............................. 48
1.17 Getting Readable Tracebacks..................................................................... 49
1.18 Finding More Java Source Code ................................................................ 50
1.19 Program: Debug ............................................................................................ 52
Chapter 2. Interacting with the Environment.......................................................... 53
2.1 Introduction ....................................................................................................... 53
2.2 Getting Environment Variables...................................................................... 53
2.3 System Properties ........................................................................................... 55
2.4 Writing JDK Release-Dependent Code ....................................................... 56
2.5 Writing Operating System-Dependent Code............................................... 57
2.6 Using CLASSPATH Effectively ..................................................................... 59
2.7 Using Extensions or Other Packaged APIs ................................................. 61
2.8 Parsing Command -Line Arguments ............................................................. 62
Chapter 3. Strings and Things ................................................................................. 66
3.1 Introduction ....................................................................................................... 66
3.2 Taking Strings Apart with Substrings ........................................................... 68

3.3 Taking Strings Apart with StringTokenizer .................................................. 69
3.4 Putting Strings Together with + and StringBuffer ....................................... 72
3.5 Processing a String One Character at a Time ............................................ 73
3.6 Aligning Strings ................................................................................................ 74
3.7 Converting Between Unicode Characters and Strings .............................. 76

3


3.8 Reversing a String by Word or Character.................................................... 78
3.9 Expanding and Compressing Tabs............................................................... 79
3.10 Controlling Case ............................................................................................ 82
3.11 Indenting Text Documents ........................................................................... 83
3.12 Entering Non-Printable Characters............................................................. 85
3.13 Trimming Blanks from the End of a String ................................................. 86
3.14 Parsing Comma-Separated Data ................................................................ 87
3.15 Program: A Simple Text Formatter ............................................................. 91
3.16 Program: Soundex Name Comparisons .................................................... 93
Chapter 4. Pattern Matching with Regular Expressions ...................................... 96
4.1 Introduction ....................................................................................................... 96
4.2 Regular Expression Syntax............................................................................ 98
4.3 How REs Work in Practice ........................................................................... 100
4.4 Using Regular Expressions in Java ............................................................ 101
4.5 Testing REs Interactively.............................................................................. 103
4.6 Finding the Matching Text ............................................................................ 104
4.7 Replacing the Matching Text ....................................................................... 105
4.8 Printing All Occurrences of a Pattern......................................................... 106
4.9 Printing Lines Containing a Pattern............................................................ 107
4.10 Controlling Case in match( ) and subst( ) ................................................ 109
4.11 Precompiling the RE ................................................................................... 109

4.12 Matching Newlines in Text ......................................................................... 110
4.13 Program: Data Mining ................................................................................. 112
4.14 Program: Full Grep...................................................................................... 114
Chapter 5. Numbers................................................................................................. 118
5.1 Introduction ..................................................................................................... 119
5.2 Checking Whether a String Is a Valid Number ......................................... 121
5.3 Storing a Larger Number in a Smaller........................................................ 122
5.4 Taking a Fraction of an Integer Without Using Floating Point ................ 123
5.5 Ensuring the Accuracy of Floating-Point Numbers .................................. 124
5.6 Comparing Floating -Point Numbers ........................................................... 126
5.7 Rounding Floating-Point Numbers.............................................................. 127
5.8 Formatting Numbers ..................................................................................... 128
5.9 Converting Between Binary, Octal, Decimal, and Hexadecimal ............ 130
5.10 Operating on a Series of Integers ............................................................. 131
5.11 Working with Roman Numerals ................................................................. 132
5.12 Formatting with Correct Plurals ................................................................. 136
5.13 Generating Random Numbers .................................................................. 137
5.14 Generating Better Random Numbers....................................................... 138
5.15 Calculating Trigonometric Functions ........................................................ 139
5.16 Taking Logarithms ....................................................................................... 139
5.17 Multiplying Matrixes..................................................................................... 140
5.18 Using Complex Numbers ........................................................................... 142
5.19 Handling Very Large Numbers .................................................................. 144
5.20 Program: TempConverter .......................................................................... 145
5.21 Program: Number Palindromes................................................................. 149

4


Chapter 6. Dates and Times................................................................................... 152

6.1 Introduction ..................................................................................................... 152
6.2 Finding Today's Date .................................................................................... 153
6.3 Printing Date/Time in a Specified Format.................................................. 155
6.4 Representing Dates in Other Epochs ......................................................... 156
6.5 Converting YMDHMS to a Calendar or Epoch Seconds......................... 157
6.6 Parsing Strings into Dates............................................................................ 157
6.7 Converting Epoch Seconds to DMYHMS .................................................. 159
6.8 Adding to or Subtracting from a Date or Calendar................................... 160
6.9 Difference Between Two Dates................................................................... 161
6.10 Comparing Dates......................................................................................... 162
6.11 Day of Week/Month/Year or Week Number............................................ 164
6.12 Calendar Page ............................................................................................. 165
6.13 High-Resolution Timers .............................................................................. 167
6.15 Program: Reminder Service ...................................................................... 170
Chapter 7. Structuring Data with Java .................................................................. 172
7.1 Introduction ..................................................................................................... 172
7.2 Data Structuring Using Arrays ..................................................................... 173
7.3 Resizing an Array .......................................................................................... 174
7.4 Like an Array, but More Dynamic................................................................ 176
7.5 Data-Independent Access with Iterators .................................................... 177
7.6 Structuring Data in a Linked List ................................................................. 178
7.7 Mapping with Hashtable and HashMap ..................................................... 181
7.8 Storing Strings in Properties and Preferences.......................................... 182
7.9 Sorting a Collection....................................................................................... 184
7.10 Sorting in Java 1.1 ....................................................................................... 188
7.11 Avoiding the Urge to Sort ........................................................................... 189
7.12 Sets................................................................................................................ 190
7.13 Finding an Object in a Collection .............................................................. 191
7.14 Converting a Collection to an Array.......................................................... 193
7.15 Rolling Your Own Iterator ........................................................................... 194

7.16 Stack.............................................................................................................. 195
7.17 Multidimensional Structures....................................................................... 196
7.18 Finally, Collections ...................................................................................... 198
7.19 Program: Timing Comparisons ................................................................. 200
Chapter 8. Object-Oriented Techniques ............................................................... 202
8.1 Introduction ..................................................................................................... 202
8.2 Printing Objects: Formatting with toStri ng( ) ............................................. 204
8.3 Overriding the Equals Method ..................................................................... 205
8.4 Overriding the Hashcode Method ............................................................... 207
8.5 The Clone Method ......................................................................................... 209
8.6 The Finalize Method...................................................................................... 211
8.7 Using Inner Classes ...................................................................................... 212
8.8 Providing Callbacks via Interfaces .............................................................. 213
8.9 Polymorphism/Abstract Methods ................................................................ 216
8.10 Passing Values ............................................................................................ 217

5


8.11 Roll Your Own Exceptions ......................................................................... 220
8.12 Program: Plotter........................................................................................... 220
Chapter 9. Input and Output ................................................................................... 224
9.1 Introduction ..................................................................................................... 225
9.2 Reading Standard Input................................................................................ 229
9.3 Writing Standard Output ............................................................................... 231
9.4 Opening a File by Name ............................................................................... 232
9.5 Copying a File ................................................................................................ 233
9.6 Reading a File into a String .......................................................................... 236
9.7 Reassigning the Standard Streams ............................................................ 237
9.8 Duplicating a Stream as It Is Written.......................................................... 238

9.9 Reading/Writing a Different Character Set ................................................ 240
9.10 Those Pesky End-of-Line Characters ...................................................... 241
9.11 Beware Platform-Dependent File Code ................................................... 241
9.12 Reading "Continued" Lines ........................................................................ 242
9.13 Scanning a File ............................................................................................ 247
9.14 Binary Data ................................................................................................... 250
9.15 Seeking ......................................................................................................... 251
9.16 Writing Data Streams from C..................................................................... 252
9.17 Saving and Restoring Serialized Objects ................................................ 254
9.18 Preventing ClassCastExceptions with SerialVersionUID ...................... 255
9.19 Reading and Writing JAR or Zip Archives ............................................... 257
9.20 Reading and Writing Compressed Files .................................................. 260
9.21 Program: Text to PostScript....................................................................... 261
9.22 Program: TarList (File Converter) ............................................................. 264
Chapter 10. Directory and Filesystem Operations .............................................. 276
10.1 Introduction................................................................................................... 276
10.2 Getting File Information .............................................................................. 276
10.3 Creating a File .............................................................................................. 279
10.4 Renaming a File ........................................................................................... 280
10.5 Deleting a File .............................................................................................. 281
10.6 Creating a Transient File ............................................................................ 282
10.7 Changing File Attributes ............................................................................. 284
10.8 Listing a Directory........................................................................................ 285
10.9 Getting the Directory Roots ....................................................................... 287
10.10 Making New Directories ........................................................................... 288
10.11 Program: Find ............................................................................................ 288
Chapter 11. Programming Serial and Parallel Ports........................................... 292
11.1 Introduction................................................................................................... 292
11.2 Choosing a Port ........................................................................................... 294
11.3 Opening a Serial Port ................................................................................. 297

11.4 Opening a Parallel Port .............................................................................. 301
11.5 Resolving Port Conflicts ............................................................................. 304
11.6 Reading and Writing: Lock Step ............................................................... 307
11.7 Reading and Writing: Event-Driven.......................................................... 309
11.8 Reading and Writing: Threads................................................................... 313

6


11.9 Program: Penman Plotter........................................................................... 315
Chapter 12. Graphics and Sound .......................................................................... 320
12.1 Introduction................................................................................................... 320
12.2 Painting with a Graphics Object ................................................................ 321
12.3 Testing Graphical Components................................................................. 322
12.4 Drawing Text ................................................................................................ 323
12.5 Drawing Centered Text in a Component ................................................. 323
12.6 Drawing a Drop Shadow ............................................................................ 324
12.7 Drawing an Image ....................................................................................... 327
12.8 Playing a Sound File ................................................................................... 331
12.9 Displaying a Moving Image with Video .................................................... 332
12.10 Drawing Text with 2D ............................................................................... 335
12.11 Printing: JDK 1.1 ....................................................................................... 337
12.12 Printing: Java 2 .......................................................................................... 339
12.13 Program: PlotterAWT ............................................................................... 342
12.14 Program: Grapher ..................................................................................... 344
Chapter 13. Graphical User Interfaces ................................................................. 348
13.1 Introduction................................................................................................... 348
13.2 Displaying GUI Components ..................................................................... 349
13.3 Designing a Window Layout ...................................................................... 351
13.5 Action Handling: Making Butto ns Work ................................................... 354

13.6 Action Handling Using Anonymous Inner Classes................................. 356
13.7 Terminating a Program with "Window Close" ......................................... 357
13.8 Dialogs: When Later Just Won't Do.......................................................... 361
13.9 Getting Program Output into a Window................................................... 363
13.10 Choosing a File with JFileChooser ......................................................... 366
13.11 Choosing a Color....................................................................................... 369
13.12 Centering a Main Window........................................................................ 371
13.13 Changing a Swing Program's Look and Feel ....................................... 372
13.14 Program: Custom Font Chooser ............................................................. 376
13.15 Program: Custom Layout Manager ........................................................ 381
Chapter 14. Internationalization and Localization............................................... 387
14.1 Introduction................................................................................................... 387
14.2 Creating a Button with I18N Resources................................................... 388
14.3 Listing Available Locales ............................................................................ 389
14.4 Creating a Menu with I18N Resources .................................................... 390
14.5 Writing Internationalization Convenience Routines ............................... 391
14.6 Creating a Dialog with I18N Resources................................................... 393
14.7 Creating a Resource Bundle ..................................................................... 394
14.8 JILTing Your Code ...................................................................................... 395
14.9 Using a Particular Locale ........................................................................... 396
14.10 Setting the Default Locale ........................................................................ 397
14.11 Formatting Messages ............................................................................... 398
14.12 Program: MenuIntl..................................................................................... 400
14.13 Program: BusCard .................................................................................... 402
Chapter 15. Network Clients................................................................................... 406

7


15.1 Introduction................................................................................................... 406

15.2 Contacting a Server .................................................................................... 408
15.3 Finding and Reporting Network Addresses............................................. 409
15.4 Handling Network Errors ............................................................................ 410
15.5 Reading and Writing Textual Data ............................................................ 411
15.6 Reading and Writing Binary Data ............................................................. 414
15.7 Reading and Writing Serialized Data ....................................................... 416
15.8 UDP Datagrams........................................................................................... 417
15.9 Program: TFTP UDP Client ....................................................................... 419
15.10 Program: Telnet Client ............................................................................. 423
15.11 Program: Chat Client ................................................................................ 425
Chapter 16. Server-Side Java: Sockets ............................................................... 431
16.1 Introduction................................................................................................... 431
16.2 Opening a Server for Business ................................................................. 431
16.3 Returning a Response (Stri ng or Binary) ................................................. 434
16.4 Returning Object Information..................................................................... 437
16.5 Handling Multiple Clients............................................................................ 438
16.6 Network Logging .......................................................................................... 443
16.7 Program: A Java Chat Server ................................................................... 446
Chapter 17. Network Clients II: Applets and Web Clients ................................. 452
17.1 Introduction................................................................................................... 452
17.2 Embedding Java in a Web Page............................................................... 452
17.3 Applet Techniques....................................................................................... 454
17.4 Contacting a Server on the Applet Host .................................................. 456
17.5 Making an Applet Show a Document....................................................... 459
17.6 Making an Applet Run a CGI Script ......................................................... 460
17.7 Reading the Contents of a URL ................................................................ 461
17.8 Extracting HTML from a URL .................................................................... 462
17.9 Extracting URLs from a File ....................................................................... 464
17.10 Converting a Filename to a URL ............................................................ 466
17.11 Program: MkIndex..................................................................................... 467

17.12 Program: LinkChecker.............................................................................. 471
Chapter 18. Web Server Java: Servlets and JSP ............................................... 478
18.1 Introduction................................................................................................... 478
18.2 First Servlet: Generating an HTML Page ................................................ 479
18.3 Servlets: Processing Form Parameters ................................................... 482
18.4 Cookies ......................................................................................................... 485
18.5 Session Tracking ......................................................................................... 488
18.6 Generating PDF from a Servlet................................................................. 493
18.7 HTML Meets Java: JSP.............................................................................. 499
18.8 JSP Include/Forward................................................................................... 503
18.9 JavaServer Pages Using a Servlet........................................................... 504
18.10 Simplifying Your JSP with a JavaBean.................................................. 505
18.11 JSP Syntax Summary............................................................................... 508
18.12 Program: CookieCutter............................................................................. 509
18.13 Program: JabaDot Web News Portal..................................................... 510

8


Chapter 19. Java and Electronic Mail ................................................................... 520
19.1 Introduction................................................................................................... 520
19.2 Sending Email: Browser Version .............................................................. 520
19.3 Sending Email: For Real ............................................................................ 525
19.4 Mail-Enabling a Server Program ............................................................... 527
19.5 Sending MIME Mail ..................................................................................... 533
19.6 Providing Mail Settings ............................................................................... 535
19.7 Sending Mail Without Using JavaMail...................................................... 536
19.8 Reading Email.............................................................................................. 540
19.9 Program: MailReaderBean ........................................................................ 544
19.10 Program: MailClient .................................................................................. 548

Chapter 20. Database Access ............................................................................... 559
20.1 Introduction................................................................................................... 559
20.2 Text-File Databases .................................................................................... 560
20.3 DBM Databases........................................................................................... 565
20.4 JDBC Setup and Connection..................................................................... 568
20.5 Connecting to a JDBC Database.............................................................. 570
20.6 Sending a JDBC Query and Getting Results .......................................... 573
20.7 Using JDBC Parameterized Statements ................................................. 575
20.8 Using Stored Procedures with JDBC ....................................................... 579
20.9 Changing Data Using a ResultSet............................................................ 579
20.10 Changing Data Using SQL ...................................................................... 580
20.11 Finding JDBC Metadata ........................................................................... 582
20.12 Program: JDAdmin.................................................................................... 588
Chapter 21. XML ...................................................................................................... 595
21.1 Introduction................................................................................................... 595
21.2 Transforming XML with XSLT ................................................................... 597
21.3 Parsing XML with SAX ............................................................................... 599
21.4 Parsing XML with DOM .............................................................................. 601
21.5 Verifying Structure with a DTD .................................................................. 603
21.6 Generating Your Own XML with DOM ..................................................... 604
21.7 Program: xml2mif ........................................................................................ 606
Chapter 22. Distributed Java: RMI ........................................................................ 609
22.1 Introduction................................................................................................... 609
22.2 Defining the RMI Contract.......................................................................... 610
22.3 RMI Client ..................................................................................................... 612
22.4 RMI Server ................................................................................................... 613
22.5 Deploying RMI Across a Network ............................................................. 615
22.6 Program: RMI Callbacks ............................................................................ 616
22.7 Program: RMIWatch ................................................................................... 620
Chapter 23. Packages and Packaging ................................................................. 626

23.1 Introduction................................................................................................... 626
23.2 Creating a Package..................................................................................... 627
23.3 Documenting Classes with Javadoc......................................................... 627
23.4 Archiving with jar ......................................................................................... 631
23.5 Running an Applet from a JAR.................................................................. 632

9


23.6 Running an Applet with a JDK................................................................... 632
23.7 Running a Program from a JAR................................................................ 636
23.8 Preparing a Class as a JavaBean ............................................................ 636
23.9 Pickling Your Bean into a JAR .................................................................. 640
23.10 Packaging a Servlet into a WAR File ..................................................... 641
23.11 "Write Once, Install Anywhere" ............................................................... 642
23.12 Java Web Start .......................................................................................... 642
23.13 Signing Your JAR File .............................................................................. 648
Chapter 24. Threaded Java .................................................................................... 650
24.1 Introduction................................................................................................... 650
24.2 Running Code in a Different Thread......................................................... 651
24.3 Displaying a Moving Image with Animation............................................. 654
24.4 Stopping a Thread....................................................................................... 657
24.5 Rendezvous and Timeouts ........................................................................ 660
24.6 Thread Communication: Synchronized Code ......................................... 661
24.7 Thread Communication: wait( ) and notifyAll( ) ...................................... 666
24.8 Background Saving in an Editor................................................................ 672
24.9 Threaded Network Server .......................................................................... 673
Chapter 25. Introspection, or "A Class Named Class" ....................................... 682
25.1 Introduction................................................................................................... 682
25.2 Getting a Class Descriptor ......................................................................... 683

25.3 Finding and Using Methods and Fields ................................................... 684
25.4 Loading and Instantiating a Class Dynamically...................................... 687
25.5 Constructing a Class from Scratch ........................................................... 689
25.6 Performance Timing .................................................................................... 691
25.7 Printing Class Information.......................................................................... 693
25.8 Program: CrossRef ..................................................................................... 695
25.9 Program: AppletViewer............................................................................... 700
Chapter 26. Using Java with Other Languages................................................... 707
26.1 Introduction................................................................................................... 707
26.2 Running a Program ..................................................................................... 707
26.3 Running a Program and Capturing Its Output ........................................ 710
26.4 Mixing Java and Scripts with BSF ............................................................ 713
26.5 Blending in Native Code (C/C++) ............................................................. 717
26.6 Calling Java from Native Code.................................................................. 723
26.7 Program: DBM ............................................................................................. 723
Chapter 27. Afterword ............................................................................................. 727
Colophon ................................................................................................................... 728

10


Preface
If you know a little Java™, great. If you know more Java, even better! This book is ideal for
anyone who knows some Java and wants to learn more.
I started programming in C in 1980 while working at the University of Toronto, and C served me
quite well through the 1980s and into the 1990s. In 1995, as the nascent language Oak was
being renamed Java, I had the good fortune to be told about it by my colleague J. Greg Davidson.
I sent an email to the address Greg provided, and got this mail back:
From scndprsn.Eng.Sun.COM!jag Wed Mar 29 19:43:54 1995
Date: Wed, 29 Mar 1995 16:47:51 +0800

From: (James Gosling)
To: ,
Subject: Re: WebRunner
Cc:
Content-Length: 361
Status: RO
X-Lines: 9
>
>
>
>

Hi. A friend told me about
browser. It and Oak(?) its
you please tell me if it's
papers on it are available

WebRunner(?), your extensible network
extention language, sounded neat. Can
available for play yet, and/or if any
for FTP?

Check out
(oak got renamed to java and webrunner got renamed to
hotjava to keep the lawyers happy)
I downloaded HotJava and began to play with it. At first I wasn't sure about this newfangled
language, which looked like a mangled C/C++. I wrote test and demo programs, sticking them a
few at a time into a directory that I called javasrc to keep it separate from my C source (as often
the programs would have the same name). And as I learned more about Java, I began to see its
advantages for many kinds of work, such as the automatic memory reclaim and the elimination of

pointer calculations. The javasrc directory kept growing. I wrote a Java course for Learning Tree,
and the directory kept growing faster, reaching the point where it needed subdirectories. Even
then, it became increasingly difficult to find things, and it soon became evident that some kind of
documentation was needed.
In a sense, this book is the result of a high-speed collision between my javasrc directory and a
documentation framework established for another newcomer language. In O'Reilly's Perl
Cookbook, Tom Christiansen and Nathan Torkington worked out a very successful design,
presenting the material in small, focused articles called "recipes." The original model for such a
book is, of course, the familiar kitchen cookbook. There is a long history of using the term
"cookbook" to refer to an enumeration of how-to recipes relating to computers. On the software
side, Donald Knuth applied the "cookbook" analogy to his book The Art of Computer
Programming (Addison Wesley), first published in 1968. On the hardware side, Don Lancaster
wrote The TTL Cookbook (Sams). (Transistor-transistor logic, or TTL, was the small-scale
building block of electronic circuits at the time.) Tom and Nathan worked out a successful
variation on this, and I recommend their book for anyone who wishes to, as they put it, "learn
more Perl." Indeed, the work you are now reading intends to be a book for the person who wishes
to "learn more Java."

11


The code in each recipe is intended to be self-contained; feel free to borrow bits and pieces of
any of it for use in your own projects.

Who This Book Is For
I'm going to assume that you know the basics of Java. I won't tell you how to println a string
and a number at the same time, or how to write a class that extends Applet and prints your
name in the window. I'll presume you've taken a Java course or studied an introductory book
such as O'Reilly's Learning Java or Java in a Nutshell. However, Chapter 1 covers some
techniques that you might not know very well and that are necessary to understand some of the

later material. Feel free to skip around! Both the printed version of the book and the (eventual)
electronic copy are heavily cross-referenced.

What's in This Book?
Unlike my Perl colleagues Tom and Nathan, I don't have to spend as much time on the oddities
and idioms of the language; Java is refreshingly free of strange quirks. But that doesn't mean it's
trivial to learn well! If it were, there'd be no need for this book. My main approach, then, is to
concentrate on the Java APIs: I'll teach you by example what the APIs are and what they are
good for.
Like Perl, Java is a language that grows on you and with you. And, I confess, I use Java most of
the time nowadays. Things I'd once done in C are now -- except for device drivers and legacy
systems -- done in Java.
But Java is suited to a different range of tasks than Perl. Perl (and other scripting languages such
as awk and Python) are particularly suited to the "one-liner" utility task. As Tom and Nathan
show, Perl excels at things like printing the 42nd line from a file. While it can certainly do these
things, Java, because it is a compiled, object-oriented language, seems more suited to
"development in the large" or enterprise applications development. Indeed, much of the API
material added in Java 2 was aimed at this type of development. However, I will necessarily
illustrate many techniques with shorter examples and even code fragments. Be assured that
every line of code you see here has been compiled and run.
Many of the longer examples in this book are tools that I originally wrote to automate some
mundane task or another. For example, MkIndex (described in Chapter 1) reads the top-level
directory of the place where I keep all my Java example source code and builds a browserfriendly index.html file for that directory. For another example, the body of the book itself was
partly composed in XML, a recent simplification that builds upon a decade of experience in SGML
(the parent standard that led to the tag-based syntax of HTML). It is not clear at this point if XML
will primarily be useful as a publishing format or as a data manipulation format, or if its prevalence
will further blur that distinction, though it seems that the blurring of distinctions is more likely.
However, I used XML here to type in and mark up the original text of some of the chapters of this
book. The text was then converted to FrameMaker input by the XmlForm program. This program
also handles -- by use of another program, GetMark -- full and partial code insertions from the

source directory. XmlForm is discussed in Chapter 21.
Let's go over the organization of this book. I start off Chapter 1 by describing some methods of
compiling your program on different platforms, running them in different environments (browser,
command line, windowed desktop), and debugging. Chapter 2 moves from compiling and
running your program to getting it to adapt to the surrounding countryside -- the other programs
that live in your computer.

12


The next few chapters deal with basic APIs. Chapter 3 concentrates on one of the most basic
but powerful data types in Java, showing you how to assemble, dissect, compare, and rearrange
what you might otherwise think of as ordinary text.
Chapter 4 teaches you how to use the powerful regular expressions technology from Unix in
many string-matching and pattern-matching problem domains. This is the first chapter that covers
a non-standard API -- there is not yet a regular expression API in standard Java -- so I talk about
several regular expression packages.
Chapter 5 deals both with built-in types such as int and double, as well as the corresponding
API classes (Integer, Double, etc.) and the conversion and testing facilities they offer. There is
also brief mention of the "big number" classes. Since Java programmers often need to deal in
dates and times, both locally and internationally, Chapter 6 covers this important topic.
The next two chapters cover data processing. As in most languages, arrays in Java are linear,
indexed collections of similar-kind objects, as discussed in Chapter 7. This chapter goes on to
deal with the many "Collections" classes: powerful ways of storing quantities of objects in the
java.util package. Additional data structuring and programming tips appear in Chapter 8.
The next few chapters deal with aspects of traditional input and output. Chapter 9 details the
rules for reading and writing files. (Don't skip this if you think files are boring, as you'll need some
of this information in later chapters: you'll read and write on serial or parallel ports in Chapter 11
and on a socket-based network connection in Chapter 15!) Chapter 10 shows you everything
else about files -- such as finding their size and last-modified time -- and about reading and

modifying directories, creating temporary files, and renaming files on disk. Chapter 11 shows
how you can use the javax.comm API to read/write on serial and parallel ports without resorting
to coding in C.
Chapter 12 leads us into the GUI development side of things. This chapter is a mix of the lowerlevel details, such as drawing graphics and setting fonts and colors, and very high-level activities,
such as controlling a playing video clip or movie. Then, in Chapter 13 I cover the higher-level
aspects of a GUI, such as buttons, labels, menus, and the like -- the GUI's predefined
components. Once you have a GUI (really, before you actually write it), you'll want to read
Chapter 14 so your programs can work as well in Akbar, Afghanistan, Algiers, Amsterdam, or
Angleterre as they do in Alberta or Arkansas or Alabama . . .
Since Java was originally promulgated as "the programming language for the Internet," it's only
fair that we spend some of our time on networking in Java. Chapter 15, covers the basics of
network programming from the client side, focusing on sockets. We'll then move to the server
side in Chapter 16. In Chapter 17, you'll learn more client-side techniques. Some specialized
server-side techniques for the Web are covered in Chapter 18. Finally, programs on the Net
often need to generate electronic mail, so this section ends with Chapter 19.
Chapter 20 covers the Java Database Connectivity package (JDBC), showing how you can
connect to local or remote relational databases, store and retrieve data, and find out information
about query results or about the database.
Another form of storing and exchanging data is XML. Chapter 21 discusses XML's formats and
some operations you can apply using SAX and DOM, two standard Java APIs.
Chapter 22 takes the distributed notion one step further and discusses Remote Methods
Invocation, Java's standard remote procedure call mechanism. RMI lets you build clients, servers,

13


and even "callback" scenarios, using a standard Java mechanism -- the Interface -- to describe
the contract between client and server.
Chapter 23 shows how to create packages of classes that work together. This chapter also talks
about "deploying" or distributing and installing your software.

Chapter 24 tells you how to write classes that appear to do more than one thing at a time and let
you take advantage of powerful multiprocessor hardware.
Chapter 25 lets you in on such big secrets as how to write API cross reference documents
mechanically and how web browsers are able to load any old applet -- never having seen that
particular class before -- and run it.
Sometimes you already have code written and working in another language that can do part of
your work for you, or you want to use Java as part of a larger package. Chapter 26 shows you
how to run an external program (compiled or script) and also interact directly with "native code" in
C/C++.
There isn't room in an 800-page book for everything I'd like to tell you about Java. The Chapter
27 presents some closing thoughts and a link to my online summary of Java APIs that every Java
developer should know about.
No two programmers or writers will agree on the best order for presenting all the Java topics. To
help you find your way around, there are extensive cross-references, mostly by recipe number.

Platform Notes
In its short history, Java has gone through four major versions. The first official release is known
as Java JDK 1.0, and its last bug-fixed version is 1.0.2. The second major release is Java JDK
1.1, and the latest bug-fixed version is 1.1.9, though it may be up from that by the time you read
this book. The third major release, in December 1998, was to be known as Java JDK 1.2, but the
Sun marketing gremlins abruptly renamed JDK 1.2 at the time of its release to Java 2, and the
implementation is known as Java SDK 1.2. The current version as of this writing is Java 2 SDK
1.3 (JDK 1.3), which was released in 2000. Around the same time, two other packages, one lowend and one high-end, were announced. At the low end, Java Micro Edition (JME) is designed for
tiny devices, such as Palm computers, telephones, and the like. At the high end, the Java 2
Enterprise Edition (J2EE) extends Java 2 by adding additional features for enterprise or largescale distributed commercial applications. One of the key features of the Enterprise Edition is
Enterprise JavaBeans™ (EJB). EJB has little in common with client-side JavaBeans except the
name. Many Java pundits (including myself) believe that EJB will become a significant player in
the development of large commercial applications, perhaps the most significant development of
this era.
As we go to press, Java 2 Version 1.4 is about to appear. It entered beta (which Sun calls "early

access") around the time of the book's completion, so I can only mention it briefly. You should
cast your sights on to see what's new in 1.4 and how it affects the
programs in the book.
This book is aimed at the Java 2 platform. By the time of publication, I expect that all Java
implementations will be fairly close to conforming to the Java 2 specification. I have used four
platforms to test this code for portability. The official "reference platform" is Sun's Java 2 Solaris
Reference Implementation, which I used on a Sun SPARCStation running Solaris. To give a
second Unix flavor, I've tested with Kaffe[1] and with Sun's Linux JDK running under the

14


OpenBSD Unix-like system. For the mass market, I've used Sun's Java 2 Win32 (Windows
95/98/NT) implementation. And, "for the rest of us," I've run some of the programs on Apple's
MacOS Runtime for Java (MRJ) running under MacOS 8 on a Power Macintosh and a few on
MacOS X (which Apple wants you to pronounce "Oh Ess Ten," despite the way they've been
writing it for the last three years). However, since Java is portable, I anticipate that the examples
will work on MacOS X except where extra APIs are required. Not every example has been tested
on every platform, but all have been tested on at least one, and most on more than one.
[1]

Kaffe, the Swedish word for coffee, is an open source (GNU Public License) Java implementation that
runs on just about any Unix or Unix-like system, and has been ported to other platforms such as Win32.

The Java API consists of two parts, core APIs and non-core APIs. The core is, by definition,
what's included in the JDK that you download for free from . Non-core is
everything else. But even this "core" is far from tiny: it weighs in at around 50 packages and well
over a thousand public classes, each with up to 30 or more public methods. Programs that stick
to this core API are reasonably assured of portability to any Java 2 platform.
The non-core APIs are further divided into standard extensions and non-standard extensions. All

standard extensions have package names beginning with javax.,[2] and reference
implementations are available from Sun. A Java licensee (like, say, Apple or Microsoft) is not
required to implement every standard extension, but if they do, the interface of the standard
extension should be adhered to. This book will call your attention to any code that depends on a
standard extension. There is little code that depends on non-standard extensions other than code
listed in the book itself (the major exception is the Regular Expressions API used in Chapter 4).
My own package, com.darwinsys.util, contains some utility classes used here and there;
you will see an import for this at the top of any file that uses classes from it.
[2]

Note that not all packages named javax. are extensions: javax.swing and its sub-packages -- the
Swing GUI packages -- used to be extensions, but are now core.

Other Books
There is a lot of useful information packed into this book. However, due to the breadth of topics, it
is not possible to give book-length treatment to any one topic. Because of this, the book also
contains references to many web sites and other books. This is in keeping with my target
audience: the person who wants to learn more about Java.
O'Reilly & Associates publishes one of the largest -- and, I think, the best -- selection of Java
books on the market. As the API continues to expand, so does the coverage. You can find the
latest versions and ordering information on O'Reilly's Java books in the back pages of this book
or online at , and you can buy them at most bookstores, both physical
and virtual. You can also read them online through a paid subscription service; see
. While many are mentioned at appropriate spots in the book, a few
deserve special mention here.
First and foremost, David Flanagan's Java in a Nutshell offers a brief overview of the language
and API, and a detailed reference to the most essential packages. This is handy to keep beside
your computer.
Learning Java, by Patrick Niemeyer and Joshua Peck, contains a slightly more leisurely
introduction to the language and the APIs.

A definitive (and monumental) description of programming the Swing GUI is Java Swing, by
Robert Eckstein, Marc Loy, and Dave Wood.

15


Java Servlets, by Jason Hunter, and JavaServer Pages, by Hans Bergsten, are both ideal for the
server-side web developer.
Java Virtual Machine, by Jon Meyer and Troy Downing, will intrigue the person who wants to
know more about what's under the hood.
Java Network Programming and Java I/O, by Elliotte Rusty Harold, and Database Programming
with JDBC and Java, by George Reese, are also useful references.
There are many more; see the O'Reilly web site for an up-to-date list.

Other Java Books
Never consider releasing a GUI application unless you have read Sun's official Java Look and
Feel Design Guidelines (Addison Wesley). This work presents the views of a large group of
human factors and user-interface experts at Sun who have worked with the Swing GUI package
since its inception; they tell you how to make it work well.
Finally, while authors at other publishing houses might be afraid to mention a book that their
publisher might think of as competition to their own, I have found Patrick Chan's Java Developer's
Almanac (Addison Wesley) a useful addition to my library and a natural complement to my book.
While my book features much more detail and discussion than his short "examplets," the main
part of Patrick's book is a large alphabetical (by class, not by package) reference to the core API.
As the core part of his book was produced mechanically using Reflection, the book has a
relatively low cover price. By the way, I show you how to generate books like Patrick's (see
Section 25.8), but he doesn't show you how to write a book like mine.

General Programming Books
Donald E. Knuth's The Art of Computer Programming has been a source of inspiration to

students of computing since its first publication by Addison Wesley in 1968. Volume 1 covers
Fundamental Algorithms, Volume 2 is Seminumerical Algorithms, and Volume 3 is Sorting and
Searching. The remaining four volumes in the projected series were never completed. Although
his examples are far from Java (he invented a hypothetical assembly language for his examples),
many of his discussions of algorithms -- of how computers ought to be used to solve real
problems -- are as relevant today as 30 years ago. [3]
[3]

With apologies for algorithm decisions that are less relevant today given the massive changes in
computing power now available.

The Elements of Programming Style, by Kernighan and Plauger, set the style (literally) for a
generation of programmers with examples from various structured programming languages. Brian
Kernighan also wrote (with P. J. Plauger) a pair of books, Software Tools and Software Tools in
Pascal, which demonstrated so much good advice on programming that I used to advise all
programmers to read them. However, these three books are somewhat dated now; many times I
wanted to write a follow-on book in a more modern language, but instead defer to The Practice of
Programming, Brian's follow-on (co-written by Rob Pike) to the Software Tools series. This book
continues the Bell Labs (now part of Lucent) tradition of excellence in software textbooks. I have
even adapted one bit of code from their book, in Section 3.14.

Design Books

16


Peter Coad's Java Design (PTR-PH/Yourdon Press) discusses the issues of object-oriented
analysis and design specifically for Java. Coad is somewhat critical of Java's implementation of
the observable-observer paradigm and offers his own replacement for it.
One of the most famous books on object-oriented design in recent years is Design Patterns, by

Gamma, Helm, Johnson, and Vlissides (Addison Wesley). These authors are often collectively
called "the gang of four," resulting in their book sometimes being referred to as "the GOF book."
One of my colleagues called it "the best book on object-oriented design ever," and I think he's
probably not far off the mark.
Another group of important books on object-oriented design is the UML series by "the Three
Amigos" (Booch, Jacobson, and Rumbaugh). Their major works are the UML User Guide, UML
Process, and others. A smaller and more approachable book in the same series is Martin
Fowler's UML Distilled.

Conventions Used in This Book
This book uses the following conventions.

Programming Conventions
I use the following terminology in this book. A program means either an applet, a servlet, or an
application. An applet is for use in a browser. A servlet is similar to an applet but for use in a
server. An application is any other type of program. A desktop application (a.k.a. client) interacts
with the user. A server program deals with a client indirectly, usually via a network connection.
The examples shown are in two varieties. Those that begin with zero or more import statements,
a Javadoc comment, and a public class statement are complete examples. Those that begin with
a declaration or executable statement, of course, are excerpts. However, the full versions of
these excerpts have been compiled and run, and the online source includes the full versions.
Recipes are numbered by chapter and number, so, for example, Recipe 7.5 refers to the fifth
recipe in Chapter 7.

Typesetting Conventions
The following typographic conventions are used in this book:
Italic
is used for commands, filenames, and sample URLs. It is also used to define new terms
when they first appear in the text.
Constant width

is used in code examples to show partial or complete Java source code program listings.
It is also used for class names, method names, variable names, and other fragments of
Java code.
Many programs are accompanied by an example showing them in action, run from the command
line. These will usually show a prompt ending in either $ for Unix or > for Microsoft, depending on

17


which computer I was using that day. Text before this prompt character can be ignored; it will be
a pathname or a hostname, again depending on the system.
As mentioned earlier, I've tested all the code on at least one of the reference platforms, and most
on several. Still, there may be platform dependencies, or even bugs, in my code or in some
important Java implementation. Please report any errors you find, as well as your suggestions for
future editions, by writing to:
O'Reilly & Associates, Inc.
101 Morris Street
Sebastopol, CA 95472
(800) 998-9938 (in the United States or Canada)
(707) 829-0515 (international or local)
(707) 829-0104 (fax)
To ask technical questions or comment on the book, send email to:

There is an O'Reilly web site for the book, listing errata, examples, or any additional information.
You can access this page at:
/>I also have a personal web site for the book:

Both sites will list errata and plans for future editions. You'll also find the source code for all the
Java code examples to download; please don't waste your time typing them in again! For specific
instructions, see the next section.

Getting the Source Code
From my web site , just follow the Download link and you will
be presented with three choices:
1.
2.
3.

Download the entire source archive as a single large zip file
Download individual source files, indexed alphabetically as well as by chapter
Download the binary JAR file for the com.darwinsys.util package needed to compile
many of the other programs

Most people will choose either #1 or #2, but anyone who wants to compile my code will need #3.
See Section 1.5 for information on using these files.
Downloading the entire source archive (#1) gives a large zip file that contains all the files from the
book (and more). This archive can be unpacked with jar (see Section 23.4), the free zip
program from Info-ZIP, the commercial WinZip or PKZIP, or any compatible tool. The files are
organized into subdirectories by topic; there is one for strings (Chapter 3), regular expressions
(Chapter 4), numbers (Chapter 5) and so on. The archive also contains the index by name and
index by chapter files from the download site, so you can easily find the files you need.

18


Downloading individual files is easy too: simply follow the links either by the file/subdirectory
name or by chapter. Once you see the file you want in your browser, use File->Save or the
equivalent, or just copy and paste it from the browser into an editor or IDE.
The files will be updated periodically, so if there are differences between what's printed in the
book and what you get, be glad, for you'll have received the benefit of hindsight.

Acknowledgments
My life has been touched many times by the flow of the fates bringing me into contact with the
right person to show me the right thing at the right time. Steve Munroe, with whom I've long since
lost touch, introduced me to computers -- in particular an IBM 360/30 at the Toronto Board of
Education that was bigger than a living room, had 32 or 64K of memory, and had perhaps the
power of a PC/XT -- in 1970. (Are you out there somewhere, Steve?) Herb Kugel took me under
his wing at the University of Toronto while I was learning about the larger IBM mainframes that
came later. Terry Wood and Dennis Smith at the University of Toronto introduced me to mini- and
micro-computers before there was an IBM PC. On evenings and weekends, the Toronto Business
Club of Toastmasters International () and Al Lambert's Canada
SCUBA School allowed me to develop my public speaking and instructional abilities. Several
people at the University of Toronto, but especially Geoffrey Collyer, taught me the features and
benefits of the Unix operating system at a time when I was ready to learn it.
Greg Davidson of UCSD taught the first Learning Tree course I attended, and welcomed me as a
Learning Tree instructor. Years later, when the Oak language was about to be released on Sun's
web site, Greg encouraged me to write to James Gosling and find out about it. James's reply of
March 29th, 1995, that the lawyers had made them rename the language to Java and that it was
"just now" available for download, is the prized first entry in my saved Java mailbox. Mike Rozek
took me on as a Learning Tree course author for a Unix course and two Java courses. After
Mike's departure from the company, Francesco Zamboni, Julane Marx, and Jennifer Urick in turn
provided product management of these courses. Jennifer also arranged permission for me to
"reuse some code" in this book that had previously been used in my Java course notes. Finally,
thanks to the many Learning Tree instructors and students who showed me ways of improving
my presentations. I still teach for "The Tree" and recommend their courses for the busy developer
who wants to zero in on one topic in detail over four days. Their web site is
.
Closer to this project, Tim O'Reilly believed in "the little Lint book" when it was just a sample
chapter, enabling my early entry into the circle of O'Reilly authors. Years later, Mike Loukides
encouraged me to keep trying to find a Java book idea that both he and I could work with. And he

stuck by me when I kept falling behind the deadlines. Mike also read the entire manuscript and
made many sensible comments, some of which brought flights of fancy down to earth. Jessamyn
Read turned many faxed and emailed scratchings of dubious legibility into the quality illustrations
you see in this book. And many, many other talented people at O'Reilly & Associates helped put
this book into the form in which you now see it.
I also must thank my reviewers, first and foremost my dear wife Betty Cerar, who may still think
Java is some kind of caffeinated beverage that I drink while programming, but whose passion for
clear expression and correct grammar has benefited much of my writing. Jonathan Knudsen,
Andy Oram, and David Flanagan commented on the outline when it was little more than a list of
chapters and recipes, and yet were able to see the kind of book it could become, and to suggest
ways to make it better. Learning Tree instructor Jim Burgess read most of the book with a very
critical eye on locution, formulation, and code. Bil Lewis and Mike Slinn ()
made helpful comments on multiple drafts of the book. Ron Hitchens () and
Marc Loy carefully read the entire final draft. Editor Sue Miller helped shepherd the manuscript

19


through the somewhat energetic final phases of production. Sarah Slocombe read the XML
chapter in its entirety and made many lucid suggestions, though unfortunately time did not permit
me to include all of them. Each of these people made this book better in many ways, particularly
by suggesting additional recipes or revising existing ones. Any faults that remain are surely my
own.
I've used a variety of tools and operating systems in preparing, compiling, and testing the book.
The developers of OpenBSD (), "the proactively secure Unix-like
system," deserve thanks for making a stable and secure Unix clone that is also closer to
traditional Unix than other freeware systems. I used the vi editor (vi on OpenBSD and vim on MSWindows) while inputting the original manuscript in XML, and Adobe FrameMaker to format the
documents. Each of these is an excellent tool in its own way. If you're wondering how I got from
XML to Frame, the answer will be given in Chapter 21.
No book on Java would be complete without a quadrium[4] of thanks to James Gosling for

inventing the first Unix Emacs, the sc spreadsheet, the NeWS window system, and Java. Thanks
also to his employer Sun Microsystems (NASDAQ SUNW) for creating not only the Java
language but an incredible array of Java tools and API libraries freely available over the Internet.
[4]

It's a good thing he only invented four major technologies, not five, or I'd have to rephrase that to avoid
infringing on an Intel trademark.

Thanks to Tom and Nathan, for the Perl Cookbook . Without them I might never have come up
with the format for this book.
Willi Powell of Apple Canada provided MacOS X access.
Thanks to the Tim Horton's Donuts in Bolton, Ontario for great coffee and for not enforcing the
20-minute table limit on the weird guy with the computer.
To each and every one of you, my sincere thanks.

20


Chapter 1. Getting Started: Compiling, Running,
and Debugging
1.1 Introduction
1.2 Compiling and Running Java: JDK
1.3 Editing and Compiling with a Color-Highlighting Editor
1.4 Compiling, Running, and Testing with an IDE
1.5 Using Classes from This Book
1.6 Automating Compilation with jr
1.7 Automating Compilation with make
1.8 Automating Compilation with Ant
1.9 Running Applets
1.10 Dealing with Deprecation Warnings

1.11 Conditional Debugging without #ifdef
1.12 Debugging Printouts
1.13 Using a Debugger
1.14 Unit Testing: Avoid the Need for Debuggers
1.15 Decompiling Java Class Files
1.16 Preventing Others from Decompiling Your Java Files
1.17 Getting Readable Tracebacks
1.18 Finding More Java Source Code
1.19 Program: Debug

1.1 Introduction

21


This chapter covers some entry-level tasks that you simply need to know how to do before you
can go on -- it is said you must crawl before you can walk, and walk before you can ride a bicycle.
Before you can try out anything else in the book, you need to be able to compile and run your
Java, so I start there, showing several ways: the JDK way, the Mac way, and the Integrated
Development Environment (IDE) way. Then I'll discuss a few details about applets, in case you
are working on them. Deprecation warnings come next, as you're likely to meet them in
maintaining "old" Java code. [1]
[1]

There is humor in the phrase "old Java code," which should be apparent when you realize that Java has
been in circulation for under five years at the time of this book's first printing.

If you're already happy with your IDE, you may wish to skip some or all of this material. It's here
to ensure that everybody can compile and debug their programs before we move on.

1.2 Compiling and Running Java: JDK
1.2.1 Problem
You need to compile and run your Java program.

1.2.2 Solution
This is one of the few areas where your computer's operating system impinges into Java's
portability, so let's get it out of the way first.
1.2.2.1 JDK
Using the command-line Java Development Kit (JDK) may be the best way to keep up with the
very latest improvements from Sun/JavaSoft. This is not the fastest compiler available by any
means; the compiler is written in Java and interpreted at compile time, making it a sensible
bootstrapping solution, but not necessarily optimal for speed of development. Nonetheless, using
Sun's JDK (or Java SDK), the commands are javac to compile and java to run your program. For
example:
C:\javasrc>javac HelloWorld.java
C:\javasrc>java HelloWorld
Hello, World
C:\javasrc>
As you can see from the compiler's (lack of) output, this compiler works on the Unix "no news is
good news" philosophy: if a program was able to do what you asked it to, it shouldn't bother
nattering at you to say that it did so. Many people use this compiler or one of its clones. The javac
and java commands are available with the JDK on both Windows and Unix, and under MacOS X
if you have installed the bundled Developer Tools package.
There is an optional setting called CLASSPATH, discussed in Section 2.6, that controls where
Java looks for classes. CLASSPATH, if set, is used by both javac and java. In older versions of
Java you had to set your CLASSPATH to include "." even to run a simple program from the
current directory; this is no longer true on Sun's current Java implementations. It may be true on
some of the clones.

22

1.2.2.2 Command-line alternatives
Sun's javac compiler is the official reference implementation. But it is itself written in Java, and
hence must be interpreted at runtime. Recognizing the slowness of compilation as a significant
hindrance to developers, Sun's Java folk went back and rewrote the compiler from scratch,
discarding some old baggage and using new language features. This new compiler (still named
javac) was unveiled for early access in May 1999 and released later that year. It is about twice as
fast as the original Java compiler -- a big improvement -- but still slower than some other
compilers. Symantec's Java compiler and Microsoft's J++ (a Java-like language) are written in
C/C++, so they are quite a bit faster than an interpreted Java compiler.
In order to speed up my compilations, I have used Jikes, a freeware compiler written in C++.
Jikes is fast, free, and available both for MS-Windows and for Unix. It's also easy to install. For
MS-Windows (Win32), Linux, and other Unix systems, you can find binaries of the current version
on IBM's Jikes web site. If you are using OpenBSD, NetBSD, or FreeBSD, you should only need
to run:
cd /usr/ports/lang/jikes; sudo make install
or just download the package file and use pkg_add to get it installed. Visit
for Jikes information
and downloads.
A key benefit of Jikes is that it gives much better error messages than the JDK compilers do. It
will alert you to slightly misspelled names, for example. Its messages are often a bit verbose, but
you can use the +E option to make it print them in a shorter format. Jikes has many other
command-line options, many that are the same as the JDK compiler's, but some that go beyond
them. See Jikes's online documentation for details.
An older C++-based Java compiler, Guavac, is not considered finished. Indeed, its author has
stopped maintaining it. Nonetheless, I was able to use Guavac 1.2 to compile many of the
examples in this book (note that the Guavac version number of 1.2 is unrelated to the Sun JDK
version number 1.2). See information on Guavac.
Another alternative technology is Kaffe, a product that Transvirtual

() licenses but also makes available in open source form under
the standard GNU Public License. Kaffe aims to be a complete JDK replacement, though it has
moved rather slowly past the JDK 1.1 level and is, as of this writing, still not quite a complete
Java 2 clone. Again, on OpenBSD there is a port, and on Linux there are RPMs available. Visit
Transvirtual's web site for the latest information on Kaffe.
One last freeware package is Japhar, a Java runtime clone, available from
.
1.2.2.3 MacOS
The JDK is purely command-line-based. At the other end of the spectrum in terms of keyboardversus-visual, we have the Apple Macintosh. Whole books have been written about how great the
Mac is, and I won't step into that debate. I will, however, comment on how lamentable it is that
Apple let its Java implementation lag behind current standards. Users of MacOS 8 and 8.5 have
put up with Java 1.8 for several years. MacOS X (Release 10 of MacOS) is a new technology
base built upon a BSD Unix base. As such, it has a regular command line as well as all the
traditional Mac tools. And it features a full Java 2 implementation, including Swing.

23


For MacOS 8, if you've followed Apple's directions for installing the MacOS Runtime for Java
(MRJ), you can compile by dragging a file to, or double-clicking on, the "javac" icon (I've made
aliases for this icon and friends on my desktop). Once the dialog shown in Figure 1-1 appears,
you can click on "Do Javac" (or just press Enter on the keyboard), first changing any options if
you want.
Figure 1-1. MacOS 8 Javac window

You will then see the Java console window stating that it ran javac (as shown in Figure 1-2).
This javac is a Mac port of the JDK version, so it also runs on "no news is good news." As this is
a Mac, you'll see the resulting class file appear in your destination folder as soon as it's been
created (which happens only if there are no compilation errors).
Figure 1-2. MacOS 8 compilation completed (MRJ)

24


You now have a class file, and you want to run it. That's where the JBindery program comes in.
JBindery can do two things: run a Java class file directly or make it into a "clickable" runnable
program. We'll start it by dragging the class file onto the Jbindery icon; the program starts as
shown in Figure 1-3.
Figure 1-3. MacOS 8 JBindery window

As we are running a simple command-line program rather than a windowed application, after we
click on "Run," the JBindery screen is replaced by a Java Console showing the command output,
as in Figure 1-4.

25