also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/ institutional sales department: 800-998-9938 or email@example.com.
Editors: Mike Loukides and Meghan Blanchette Production Editor: Melanie Yarbrough Copyeditor: Kim Cofer Proofreader: Jasmine Kwityn June 2014:
Indexer: Lucie Haskins Cover Designer: Randy Comer Interior Designer: David Futato Illustrator: Rebecca Demarest
Revision History for the Third Edition: 2014-06-20: First release See http://oreilly.com/catalog/errata.csp?isbn=9781449337049 for release details. Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly Media, Inc. Java Cookbook, the cover image of a domestic chicken, and related trade dress are trademarks of O’Reilly Media, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly Media, Inc. was aware of a trademark claim, the designations have been printed in caps or initial caps. While every precaution has been taken in the preparation of this book, the publisher and author assume no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein.
1.2. Editing and Compiling with a Syntax-Highlighting Editor 1.3. Compiling, Running, and Testing with an IDE 1.4. Using CLASSPATH Effectively 1.5. Downloading and Using the Code Examples 1.6. Automating Compilation with Apache Ant 1.7. Automating Dependencies, Compilation, Testing, and Deployment with Apache Maven 1.8. Automating Dependencies, Compilation, Testing, and Deployment with Gradle 1.9. Dealing with Deprecation Warnings 1.10. Conditional Debugging Without #ifdef 1.11. Maintaining Program Correctness with Assertions 1.12. Debugging with JDB 1.13. Avoiding the Need for Debuggers with Unit Testing 1.14. Maintaining Your Code with Continuous Integration 1.15. Getting Readable Tracebacks 1.16. Finding More Java Source Code: Programs, Frameworks, Libraries
2 3 4 14 17 22 25 29 31 33 35 36 38 41 45 46
2. Interacting with the Environment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 2.1. Getting Environment Variables 2.2. Getting Information from System Properties 2.3. Learning About the Current JDK Release 2.4. Dealing with Operating System–Dependent Variations 2.5. Using Extensions or Other Packaged APIs
51 52 54 55 58
2.6. Parsing Command-Line Arguments
3. Strings and Things. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 3.1. Taking Strings Apart with Substrings 3.2. Breaking Strings Into Words 3.3. Putting Strings Together with StringBuilder 3.4. Processing a String One Character at a Time 3.5. Aligning Strings 3.6. Converting Between Unicode Characters and Strings 3.7. Reversing a String by Word or by Character 3.8. Expanding and Compressing Tabs 3.9. Controlling Case 3.10. Indenting Text Documents 3.11. Entering Nonprintable Characters 3.12. Trimming Blanks from the End of a String 3.13. Parsing Comma-Separated Data 3.14. Program: A Simple Text Formatter 3.15. Program: Soundex Name Comparisons
69 70 74 76 78 81 83 84 89 90 91 92 93 98 100
4. Pattern Matching with Regular Expressions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 4.1. Regular Expression Syntax 4.2. Using regexes in Java: Test for a Pattern 4.3. Finding the Matching Text 4.4. Replacing the Matched Text 4.5. Printing All Occurrences of a Pattern 4.6. Printing Lines Containing a Pattern 4.7. Controlling Case in Regular Expressions 4.8. Matching “Accented” or Composite Characters 4.9. Matching Newlines in Text 4.10. Program: Apache Logfile Parsing 4.11. Program: Data Mining 4.12. Program: Full Grep
107 114 117 120 121 123 125 126 127 129 131 133
5. Numbers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 5.1. Checking Whether a String Is a Valid Number 5.2. Storing a Larger Number in a Smaller Number 5.3. Converting Numbers to Objects and Vice Versa 5.4. Taking a Fraction of an Integer Without Using Floating Point 5.5. Ensuring the Accuracy of Floating-Point Numbers 5.6. Comparing Floating-Point Numbers 5.7. Rounding Floating-Point Numbers 5.8. Formatting Numbers
Table of Contents
141 143 144 146 147 149 151 152
5.9. Converting Between Binary, Octal, Decimal, and Hexadecimal 5.10. Operating on a Series of Integers 5.11. Working with Roman Numerals 5.12. Formatting with Correct Plurals 5.13. Generating Random Numbers 5.14. Calculating Trigonometric Functions 5.15. Taking Logarithms 5.16. Multiplying Matrices 5.17. Using Complex Numbers 5.18. Handling Very Large Numbers 5.19. Program: TempConverter 5.20. Program: Number Palindromes
154 155 157 161 163 165 166 167 169 171 174 175
6. Dates and Times—New API. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 6.1. Finding Today’s Date 6.2. Formatting Dates and Times 6.3. Converting Among Dates/Times, YMDHMS, and Epoch Seconds 6.4. Parsing Strings into Dates 6.5. Difference Between Two Dates 6.6. Adding to or Subtracting from a Date or Calendar 6.7. Interfacing with Legacy Date and Calendar Classes
182 183 185 186 187 188 189
7. Structuring Data with Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 7.1. Using Arrays for Data Structuring 7.2. Resizing an Array 7.3. The Collections Framework 7.4. Like an Array, but More Dynamic 7.5. Using Generic Collections 7.6. Avoid Casting by Using Generics 7.7. How Shall I Iterate Thee? Let Me Enumerate the Ways 7.8. Eschewing Duplicates with a Set 7.9. Using Iterators or Enumerations for Data-Independent Access 7.10. Structuring Data in a Linked List 7.11. Mapping with Hashtable and HashMap 7.12. Storing Strings in Properties and Preferences 7.13. Sorting a Collection 7.14. Avoiding the Urge to Sort 7.15. Finding an Object in a Collection 7.16. Converting a Collection to an Array 7.17. Rolling Your Own Iterator 7.18. Stack 7.19. Multidimensional Structures
8. Object-Oriented Techniques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 8.1. Formatting Objects for Printing with toString() 8.2. Overriding the equals() and hashCode() Methods 8.3. Using Shutdown Hooks for Application Cleanup 8.4. Using Inner Classes 8.5. Providing Callbacks via Interfaces 8.6. Polymorphism/Abstract Methods 8.7. Passing Values 8.8. Using Typesafe Enumerations 8.9. Enforcing the Singleton Pattern 8.10. Roll Your Own Exceptions 8.11. Using Dependency Injection 8.12. Program: Plotter
241 243 248 250 251 255 256 259 263 266 267 270
9. Functional Programming Techniques: Functional Interfaces, Streams, Parallel Collections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 9.1. Using Lambdas/Closures Instead of Inner Classes 9.2. Using Lambda Predefined Interfaces Instead of Your Own 9.3. Simplifying Processing with Streams 9.4. Improving Throughput with Parallel Streams and Collections 9.5. Creating Your Own Functional Interfaces 9.6. Using Existing Code as Functional with Method References 9.7. Java Mixins: Mixing in Methods
278 282 283 285 286 289 293
10. Input and Output. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 10.1. Reading Standard Input 10.2. Reading from the Console or Controlling Terminal; Reading Passwords Without Echoing 10.3. Writing Standard Output or Standard Error 10.4. Printing with Formatter and printf 10.5. Scanning Input with StreamTokenizer 10.6. Scanning Input with the Scanner Class 10.7. Scanning Input with Grammatical Structure 10.8. Opening a File by Name 10.9. Copying a File 10.10. Reading a File into a String 10.11. Reassigning the Standard Streams 10.12. Duplicating a Stream as It Is Written 10.13. Reading/Writing a Different Character Set 10.14. Those Pesky End-of-Line Characters
10.15. Beware Platform-Dependent File Code 10.16. Reading “Continued” Lines 10.17. Reading/Writing Binary Data 10.18. Seeking to a Position within a File 10.19. Writing Data Streams from C 10.20. Saving and Restoring Java Objects 10.21. Preventing ClassCastExceptions with SerialVersionUID 10.22. Reading and Writing JAR or ZIP Archives 10.23. Finding Files in a Filesystem-Neutral Way with getResource() and getResourceAsStream() 10.24. Reading and Writing Compressed Files 10.25. Learning about the Communications API for Serial and Parallel Ports 10.26. Save User Data to Disk 10.27. Program: Text to PostScript
11. Directory and Filesystem Operations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365 11.1. Getting File Information 11.2. Creating a File 11.3. Renaming a File 11.4. Deleting a File 11.5. Creating a Transient File 11.6. Changing File Attributes 11.7. Listing a Directory 11.8. Getting the Directory Roots 11.9. Creating New Directories 11.10. Using Path instead of File 11.11. Using the FileWatcher Service to Get Notified about File Changes 11.12. Program: Find
365 368 369 370 372 373 375 377 378 379 380 382
12. Media: Graphics, Audio, Video. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 12.1. Painting with a Graphics Object 12.2. Showing Graphical Components Without Writing Main 12.3. Drawing Text 12.4. Drawing Centered Text in a Component 12.5. Drawing a Drop Shadow 12.6. Drawing Text with 2D 12.7. Drawing Text with an Application Font 12.8. Drawing an Image 12.9. Reading and Writing Images with javax.imageio 12.10. Playing an Audio/Sound File 12.11. Playing a Video File 12.12. Printing in Java
14. Graphical User Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457 14.1. Displaying GUI Components 14.2. Run Your GUI on the Event Dispatching Thread 14.3. Designing a Window Layout 14.4. A Tabbed View of Life 14.5. Action Handling: Making Buttons Work 14.6. Action Handling Using Anonymous Inner Classes 14.7. Action Handling Using Lambdas 14.8. Terminating a Program with “Window Close” 14.9. Dialogs: When Later Just Won’t Do 14.10. Catching and Formatting GUI Exceptions 14.11. Getting Program Output into a Window 14.12. Choosing a Value with JSpinner 14.13. Choosing a File with JFileChooser 14.14. Choosing a Color 14.15. Formatting JComponents with HTML 14.16. Centering a Main Window 14.17. Changing a Swing Program’s Look and Feel 14.18. Enhancing Your Swing GUI for Mac OS X 14.19. Building Your GUI Application with JavaFX 14.20. Program: Custom Font Chooser
18.2. JDBC Setup and Connection 18.3. Connecting to a JDBC Database 18.4. Sending a JDBC Query and Getting Results 18.5. Using JDBC Prepared Statements 18.6. Using Stored Procedures with JDBC 18.7. Changing Data Using a ResultSet 18.8. Storing Results in a RowSet 18.9. Changing Data Using SQL 18.10. Finding JDBC Metadata 18.11. Program: SQLRunner
20. Processing XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661 20.1. Converting Between Objects and XML with JAXB 20.2. Converting Between Objects and XML with Serializers 20.3. Transforming XML with XSLT 20.4. Parsing XML with SAX 20.5. Parsing XML with DOM 20.6. Finding XML Elements with XPath 20.7. Verifying Structure with Schema or DTD 20.8. Generating Your Own XML with DOM and the XML Transformer 20.9. Program: xml2mif
664 667 668 671 673 677 678 681 683
21. Packages and Packaging. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687 21.1. Creating a Package 21.2. Documenting Classes with Javadoc 21.3. Beyond Javadoc: Annotations/Metadata 21.4. Archiving with jar 21.5. Running a Program from a JAR 21.6. Preparing a Class as a JavaBean 21.7. Pickling Your Bean into a JAR 21.8. Packaging a Servlet into a WAR File 21.9. “Write Once, Install Anywhere” 21.10. “Write Once, Install on Mac OS X” 21.11. Java Web Start 21.12. Signing Your JAR File
22.1. Running Code in a Different Thread 22.2. Displaying a Moving Image with Animation 22.3. Stopping a Thread 22.4. Rendezvous and Timeouts 22.5. Synchronizing Threads with the synchronized Keyword 22.6. Simplifying Synchronization with Locks 22.7. Synchronizing Threads the Hard Way with wait( ) and notifyAll( ) 22.8. Simplifying Producer/Consumer with the Queue Interface 22.9. Optimizing Parallel Processing with Fork/Join 22.10. Background Saving in an Editor 22.11. Program: Threaded Network Server 22.12. Simplifying Servers Using the Concurrency Utilities
719 724 728 731 732 738 742 748 750 754 755 762
23. Reflection, or “A Class Named Class”. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765 23.1. Getting a Class Descriptor 23.2. Finding and Using Methods and Fields 23.3. Accessing Private Methods and Fields via Reflection 23.4. Loading and Instantiating a Class Dynamically 23.5. Constructing a Class from Scratch with a ClassLoader 23.6. Performance Timing 23.7. Printing Class Information 23.8. Listing Classes in a Package 23.9. Using and Defining Annotations 23.10. Finding Plug-in-like Classes via Annotations 23.11. Program: CrossRef 23.12. Program: AppletViewer
766 767 771 772 774 776 780 782 784 789 791 794
24. Using Java with Other Languages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801 24.1. Running an External Program from Java 24.2. Running a Program and Capturing Its Output 24.3. Calling Other Languages via javax.script 24.4. Roll Your Own Scripting Engine 24.5. Marrying Java and Perl 24.6. Calling Other Languages via Native Code 24.7. Calling Java from Native Code
Preface to the Third Edition Java 8 is the new kid on the block. Java 7 was a significant but incremental improvement over its predecessors. So much has changed since the previous edition of this book! What was “new in Java 5” has become ubiquitous in Java: annotations, generic types, concurrency utilities, and more. APIs have come and gone across the entire tableau of Java: JavaME is pretty much dead now that BlackBerry has abandoned it; JSF is (slowly) replacing JSP in parts of Enterprise Java; and Spring continues to expand its reach. Many people seem to think that “desktop Java” is dead or even that “Java is dying,” but it is definitely not rolling over yet; Swing, JavaFX, Java Enterprise, and (despite a major lawsuit by Oracle) Android are keeping the Java language very much alive. Additionally, a renewed interest in other “JVM languages” such as Groovy, JRuby, Jython, Scala, and Clojure is keeping the platform in the forefront of the development world. Indeed, the main challenge in preparing this third edition has been narrowing down the popular APIs, keeping my own excitement and biases in check, to make a book that will fit into the size constraints established by the O’Reilly Cookbook series and my own previous editions. The book has to remain around 900 pages in length, and it certainly would not were I to try to fit in “all that glistens.” I’ve also removed certain APIs that were in the previous editions. Most notable is the chapter on serial and parallel ports (pared down to one recipe in Chapter 10); computers generally don’t ship with these anymore, and hardly anybody is using them: the main attention has moved to USB, and there doesn’t seem to be a standard API for Java yet (nor, frankly, much real interest among developers).
Preface to Previous Editions 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. If you don’t know any Java yet, you should start with one of the more introductory books, such as Head First xiii
Java (O’Reilly) or Learning Java (O’Reilly) if you’re new to this family of languages, or Java in a Nutshell (O’Reilly) if you’re an experienced C programmer. 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 of being told about it by my colleague J. Greg Davidson. I sent an email to the address Greg provided, and got this mail back from James Gosling, Java’s inventor, in March 1995: | | | |
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 extension language, sounded neat. Can available for play yet, and/or if any for FTP?
Check out http://java.sun.com (oak got renamed to java and webrunner got renamed to hotjava to keep the lawyers happy)
So Oak became Java1 before I could get started with it. 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 (because 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 (“garbage collection”) and the elimination of pointer calculations. The javasrc directory kept growing. I wrote a Java course for Learning Tree,2 and the directory grew 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’Reil‐ ly’s Perl Cookbook, Tom Christiansen and Nathan Torkington worked out a very suc‐ cessful design, presenting the material in small, focused articles called “recipes,” for the then-new Perl language. The original model for such a book is, of course, the familiar kitchen cookbook. Using the term “cookbook” to refer to an enumeration of how-to recipes relating to computers has a long history. 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 1. Editor’s note: the “other Oak” that triggered this renaming was not a computer language, as is sometimes supposed, but Oak Technology, makers of video cards and the cdrom.sys file that was on every DOS/Windows PC at one point. 2. One of the world’s leading high-tech, vendor-independent training companies; see http://www.learning tree.com/.
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 strives to be the book for the person who wishes to “learn more Java.” The code in each recipe is intended to be largely self-contained; feel free to borrow bits and pieces of any of it for use in your own projects. The code is distributed with a Berkeley-style copyright, just to discourage wholesale reproduction.
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 JFrame and prints your name in the window. I’ll presume you’ve taken a Java course or studied an introductory book such as Head First Java, Learning Java, or Java in a Nutshell (O’Reil‐ ly). 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 electronic copy are heavily crossreferenced.
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.3 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 important 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 once did in C—except for device drivers and legacy systems—I now do in Java. Java is suited to a different range of tasks than Perl, however. Perl (and other scripting languages, such as awk and Python) is 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. Although Java can certainly do these things, it seems more suited to “development in the large,” or enterprise applications development, because it is a compiled, objectoriented language. 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 fragment of code you see here (except for some one- or two-liners) has been compiled and run.
3. Well, not completely. See the Java Puzzlers books by Joshua Bloch and Neal Gafter for the actual quirks.
Some of the longer examples in this book are tools that I originally wrote to automate some mundane task or another. For example, a tool called MkIndex (in the javasrc repository) reads the top-level directory of the place where I keep all my Java example source code and builds a browser-friendly index.html file for that directory. For another example, the body of the first edition was partly composed in XML (see Chapter 20); I used XML to type in and mark up the original text of some of the chapters of this book, and text was then converted to the publishing software format by the XmlForm program. This program also handled—by use of another program, GetMark—full and partial code insertions from the javasrc directory into the book manuscript. XmlForm is discussed in Chapter 20.
Organization of This Book Let’s go over the organization of this book. I start off Chapter 1, Getting Started: Compil‐ ing, Running, and Debugging 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, Interacting with the Environment moves from compiling and running your program to getting it to adapt to the surrounding countryside—the other programs that live in your computer. The next few chapters deal with basic APIs. Chapter 3, Strings and Things 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, Pattern Matching with Regular Expressions teaches you how to use the pow‐ erful regular expressions technology from Unix in many string-matching and patternmatching problem domains. “Regex” processing has been standard in Java for years, but if you don’t know how to use it, you may be “reinventing the flat tire.” Chapter 5, Numbers deals both with built-in numeric 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. Because Java programmers often need to deal in dates and times, both locally and in‐ ternationally, Chapter 6, Dates and Times—New API 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, Structuring Data with Java. This chapter goes on to deal with the many “Collections” classes: pow‐ erful ways of storing quantities of objects in the java.util package, including use of “Java Generics.”
Despite some syntactic resemblance to procedural languages such as C, Java is at heart an object-oriented programming (OOP) language. Chapter 8, Object-Oriented Techni‐ ques discusses some of the key notions of OOP as it applies to Java, including the com‐ monly overridden methods of java.lang.Object and the important issue of design patterns. Java is not, and never will be, a pure “functional programming” (FP) language. However, it is possible to use some aspects of FP, increasingly so with Java 8 and its support of “lambda expressions” (a.k.a. “closures”). This is discussed in Chapter 9, Functional Pro‐ gramming Techniques: Functional Interfaces, Streams, Parallel Collections. The next few chapters deal with aspects of traditional input and output. Chapter 10, Input and Output details the rules for reading and writing files (don’t skip this if you think files are boring; you’ll need some of this information in later chapters: you’ll read and write on serial or parallel ports in this chapter, and on a socket-based network connection in Chapter 13, Network Clients!). Chapter 11, Directory and Filesystem Op‐ erations shows you everything else about files—such as finding their size and lastmodified time—and about reading and modifying directories, creating temporary files, and renaming files on disk. Chapter 12, Media: Graphics, Audio, Video leads us into the GUI development side of things. This chapter is a mix of the lower-level details (such as drawing graphics and setting fonts and colors), and very high-level activities (such as controlling a video clip or movie). In Chapter 14, Graphical User Interfaces, 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 15, Internationalization and Localization so your programs can work as well in Akbar, Afghanistan, Algiers, Amsterdam, and Angleterre as they do in Alberta, Arkansas, and Alabama. Because Java was originally promulgated as “the programming language for the Inter‐ net,” it’s only fair that we spend some of our time on networking in Java. Chapter 13, Network Clients covers the basics of network programming from the client side, focusing on sockets. For the third edition, Chapter 13, Network Clients has been refocused from applets and web clients to emphasize web service clients instead. Today so many appli‐ cations need to access a web service, primarily RESTful web services, that this seemed to be necessary. We’ll then move to the server side in Chapter 16, Server-Side Java, wherein you’ll learn some server-side programming techniques. Programs on the Net often need to generate or process electronic mail, so Chapter 17, Java and Electronic Mail covers this topic. Chapter 18, Database Access covers the essentials of the higher-level database access (JPA and Hibernate) and the lower-level Java Database Connectivity (JDBC), showing
Platform Notes Java has gone through many major versions as discussed in Appendix A. This book is aimed at the Java 7 and 8 platforms. By the time of publication, I expect that all Java projects in development will be using Java 6 or 7, with a few stragglers wedded to earlier versions for historical reasons (note that Java 6 has been in “end of life” status for about a year prior to this edition’s publication). I have compiled all the code in the javasrc
archive on several combinations of operating systems and Java versions to test this code for portability. The Java API consists of two parts: core APIs and noncore APIs. The core is, by defi‐ nition, what’s included in the JDK that you download free from the Java website. Non‐ core is everything else. But even this “core” is far from tiny: it weighs in at around 50 packages and well over 3,000 public classes, averaging around a dozen public methods each. Programs that stick to this core API are reasonably assured of portability to any standard Java platform. Java’s noncore APIs are further divided into standard extensions and nonstandard ex‐ tensions. All standard extensions have package names beginning with javax. But note that not all packages named javax are extensions: javax.swing and its subpackages— the Swing GUI packages—used to be extensions, but are now core. A Java licensee (such as Apple or IBM) is not required to implement every standard extension, but if it does, the interface of the standard extension should be adhered to. This book calls your at‐ tention to any code that depends on a standard extension. Little code here depends on nonstandard extensions, other than code listed in the book itself. My own package, com.darwinsys, 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. In addition, two other platforms, Java ME and Java EE, are standardized. Java Micro Edition (Java ME) is concerned with small devices such as handhelds, cell phones, fax machines, and the like. Within Java ME are various “profiles” for different classes of devices. At the other end, the Java Enterprise Edition (Java EE) is concerned with build‐ ing large, scalable, distributed applications. Servlets, JavaServer Pages, JavaServer Faces, CORBA, RMI, JavaMail, Enterprise JavaBeans (EJBs), Transactions, and other APIs are part of Java EE. Java ME and Java EE packages normally begin with “javax” because they are not core packages. This book does not cover these at all, but includes a few of the EE APIs that are also useful on the client side, such as JavaMail. As mentioned earlier, coverage of Servlets and JSPs from the first edition of this book has been removed because there is now a Java Servlet and JSP Cookbook. Speaking of cell phones and mobile devices, you probably know that Android uses Java as its language. What is comforting to Java developers is that Android also uses most of the core Java API, except for Swing and AWT, for which it provides Android-specific replacements. The Java developer who wants to learn Android may consider looking at my Android Cookbook, or the book’s website.
Java Books A lot of useful information is 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 websites and other books. This is in keeping with my target audience: the person who wants to learn more about Java. O’Reilly publishes, in my opinion, the best selection of Java books on the market. As the API continues to expand, so does the coverage. Check out the latest versions and ordering information from O’Reilly’s collection of Java books; you can buy them at most bookstores, both physical and virtual. You can also read them online through Safari, a paid subscription service. And, of course, most are now available in ebook format; O’Reilly eBooks are DRM free so you don’t have to worry about their copy-protection scheme locking you into a particular device or system, as you do with certain other publishers. Though many books are mentioned at appropriate spots in the book, a few deserve special mention here. First and foremost, David Flanagan’s Java in a Nutshell (O’Reilly) 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. Head First Java offers a much more whimsical introduction to the language and is recommended for the less experienced developer. A definitive (and monumental) description of programming the Swing GUI is Java Swing by Marc Loy, Robert Eckstein, Dave Wood, James Elliott, and Brian Cole (O’Reil‐ ly). Java Virtual Machine, by Jon Meyer and Troy Downing (O’Reilly), will intrigue the person who wants to know more about what’s under the hood. This book is out of print but can be found used and in libraries. Java Network Programming and Java I/O, both by Elliotte Rusty Harold (O’Reilly), are also useful references. For Java Database work, Database Programming with JDBC and Java by George Reese, and Pro JPA 2: Mastering the Java Persistence API by Mike Keith and Merrick Schincariol (Apress), are recommended. Although this book doesn’t have much coverage of the Java EE, I’d like to mention two books on that topic: • Arun Gupta’s Java EE 7 Essentials covers the latest incarnation of the Enterprise Edition. • Adam Bien’s Real World Java EE Patterns: Rethinking Best Practices offers useful insights in designing and implementing an Enterprise application. You can find many more at the O’Reilly website. Before building and releasing a GUI application you should read Sun’s official Java Look and Feel Design Guidelines (Addison-Wesley). This work presents the views of the hu‐ man factors and user-interface experts at Sun (before the Oracle takeover) who worked with the Swing GUI package since its inception; they tell you how to make it work well. xx
Finally, although it’s not a book, Oracle has a great deal of Java information on the Web. Part of this web page is a large diagram showing all the components of Java in a “con‐ ceptual diagram.” An early version of this is shown in Figure P-1; each colored box is a clickable link to details on that particular technology. Note the useful “Java SE API” link at the right, which takes you to the javadoc pages for the entire Java SE API.
Figure P-1. Java conceptual diagram—Oracle Web
General Programming Books Donald E. Knuth’s The Art of Computer Programming has been a source of inspiration to generations of computing students since its first publication by Addison-Wesley in 1968. Volume 1 covers Fundamental Algorithms, Volume 2 is Seminumerical Algo‐ rithms, and Volume 3 is Sorting and Searching. The remaining four volumes in the projected series are still not 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 rel‐ evant today as they were years ago.4 Though its code examples are quite dated now, the book 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. Kernighan and Plaug‐ er also wrote 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 program‐ mers to read them. However, these three books are 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—cowritten with Rob Pike—to the Software Tools ser‐ ies. This book continues the Bell Labs (now part of Lucent) tradition of excellence in software textbooks. In Recipe 3.13, I have even adapted one bit of code from their book. See also The Pragmatic Programmer by Andrew Hunt and David Thomas (AddisonWesley).
Design Books Peter Coad’s Java Design (PTR-PH/Yourdon Press) discusses the issues of objectoriented 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 Pat‐ terns, 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 objectoriented design ever,” and I agree; at the very least, it’s among the best. Refactoring, by Martin Fowler, covers a lot of “coding cleanups” that can be applied to code to improve readability and maintainability. Just as the GoF book introduced new terminology that helps developers and others communicate about how code is to be designed, Fowler’s book provided a vocabulary for discussing how it is to be improved. But this book may be less useful than others; many of the “refactorings” now appear in the Refactoring Menu of the Eclipse IDE (see Recipe 1.3). Two important streams of methodology theories are currently in circulation. The first is collectively known as Agile Methods, and its best-known members are Scrum and Extreme Programming (XP). XP (the methodology, not last year’s flavor of Microsoft’s OS) is presented in a series of small, short, readable texts led by its designer, Kent Beck.
4. With apologies for algorithm decisions that are less relevant today given the massive changes in computing power now available.
The first book in the XP series is Extreme Programming Explained. A good overview of all the Agile methods is Highsmith’s Agile Software Development Ecosystems. Another group of important books on methodology, covering the more traditional object-oriented design, is the UML series led 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 any unit of code that can be run: an applet, a servlet, or an application. An applet is a Java program for use in a browser. A servlet is a Java component for use in a server, normally via HTTP. 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 (and usually HTTP/HTTPS these days). 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 8.5 refers to the fifth recipe in Chapter 8.
Typesetting Conventions The following typographic conventions are used in this book: Italic Used for commands, filenames, and example URLs. It is also used to define new terms when they first appear in the text. Constant width
Used in code examples to show partial or complete Java source code program list‐ ings. It is also used for class names, method names, variable names, and other frag‐ ments of Java code. Constant width bold
Used for user input, such as commands that you type on the command line. Preface