Java Examples in a Nutshell

( 1 )


The author of the best-selling Java in a Nutshell has created an entire book of real-world Java programming examples that you can learn from. If you learn best "by example," this is the book for you.This third edition covers Java 1.4 and contains 193 complete, practical examples: over 21,900 lines of densely commented, professionally written Java code, covering 20 distinct client-side and server-side APIs. It includes new chapters on the Java Sound API and the New I/O API. The chapters on XML and servlets have ...

See more details below
Paperback (Third Edition)
$29.22 price
(Save 26%)$39.95 List Price
Other sellers (Paperback)
  • All (14) from $1.99   
  • New (7) from $15.82   
  • Used (7) from $1.99   
Java Examples in a Nutshell

Available on NOOK devices and apps  
  • NOOK Devices
  • Samsung Galaxy Tab 4 NOOK 7.0
  • Samsung Galaxy Tab 4 NOOK 10.1
  • NOOK HD Tablet
  • NOOK HD+ Tablet
  • NOOK eReaders
  • NOOK Color
  • NOOK Tablet
  • Tablet/Phone
  • NOOK for Windows 8 Tablet
  • NOOK for iOS
  • NOOK for Android
  • NOOK Kids for iPad
  • PC/Mac
  • NOOK for Windows 8
  • NOOK for PC
  • NOOK for Mac
  • NOOK for Web

Want a NOOK? Explore Now

NOOK Book (eBook)
$17.99 price
(Save 43%)$31.99 List Price


The author of the best-selling Java in a Nutshell has created an entire book of real-world Java programming examples that you can learn from. If you learn best "by example," this is the book for you.This third edition covers Java 1.4 and contains 193 complete, practical examples: over 21,900 lines of densely commented, professionally written Java code, covering 20 distinct client-side and server-side APIs. It includes new chapters on the Java Sound API and the New I/O API. The chapters on XML and servlets have been rewritten to cover the latest versions of the specifications and to demonstrate best practices for Java 1.4. New and updated examples throughout the book demonstrate many other new Java features and APIs.Java Examples in a Nutshell is a companion volume to Java in a Nutshell, Java Foundation Classes in a Nutshell, and Java Enterprise in a Nutshell. It picks up where those quick references leave off, providing a wealth of examples for both novices and experts. This book doesn't hold your hand; it simply delivers well-commented working examples with succinct explanations to help you learn and explore Java and its APIs.Java Examples in a Nutshell contains examples that demonstrate:

  • Core APIs, including I/O, New I/O, threads, networking, security, serialization, and reflection
  • Desktop APIs, highlighting Swing GUIs, Java 2D graphics, preferences, printing, drag-and-drop, JavaBeans, applets, and sound
  • Enterprise APIs, including JDBC (database access), JAXP (XML parsing and transformation), Servlets 2.4, JSP 2.0 (JavaServer Pages), and RMI
The book begins with introductory examples demonstrating structured and object-oriented programming techniques for new Java programmers. A special index at the end of the book makes it easy to look up examples that use a particular Java class or accomplish a desired task. In between, each chapter includes exercises that challenge readers and suggest further avenues for exploration.

Designed to accompany Java in a Nutshell, this companion tutorial provides practical, real-world Java programming examples. Intended for novice and advanced Java programmers, the book is grouped by skill level.

Read More Show Less

Editorial Reviews

From Barnes & Noble

Fatbrain Review

Designed to accompany Java in a Nutshell, this companion tutorial provides practical, real-world Java programming examples. Intended for novice and advanced Java programmers, the book is grouped by skill level.

Like his previous Java books, author David Flanagan maintains his cut-to-the-chase approach. He teaches by example, and he doesn't include detailed documentation of the exact syntax and behavior of Java statements. Instead, he includes examples from the first and the second (Java 1.1) editions of Java in a Nutshell. He also covers the new AWT event handling model, the JavaBeans API, internationalization, reflection and object serialization. You will find new programming examples for RMI, database connectivity and security. There are also practical examples for I/O, networking and GUIs. The appendix contains Swing, a set of new, cross-platform, lightweight components that form part of the forthcoming Java Foundation Classes (JFC). The end-of-the-chapter exercises provide further avenues for exploring the Java programming.

Read More Show Less

Product Details

  • ISBN-13: 9780596006204
  • Publisher: O'Reilly Media, Incorporated
  • Publication date: 1/9/2004
  • Series: In a Nutshell (O'Reilly) Series
  • Edition description: Third Edition
  • Edition number: 3
  • Pages: 722
  • Product dimensions: 5.92 (w) x 8.94 (h) x 1.24 (d)

Meet the Author

David Flanagan is a computer programmer who spends most of his time writing about JavaScript and Java. His books with O'Reilly include Java in a Nutshell, Java Examples in a Nutshell, Java Foundation Classes in a Nutshell, JavaScript: The Definitive Guide, and JavaScript Pocket Reference. David has a degree in computer science and engineering from the Massachusetts Institute of Technology. He lives with his wife and son in the U.S. Pacific Northwest bewteen the cities of Seattle, Washington and Vancouver, British Columbia. David has a simple website at

Read More Show Less

Read an Excerpt

Chapter 11: Java Beans

Defining a Simple Property Editor
A bean can also provide an auxiliary Property Editor for use by a beanbox tool. PropertyEditor is a flexible interface that allows a bean to tell a beanbox how to display and edit the values of certain types of properties.

A beanbox tool always provides simple property editors for common property types such as strings, numbers, fonts, and colors. If your bean has properties of a non-standard type, however, you should register a property editor for that type. The easiest way to "register" a property, editor is through a simple naming convention. If your type is defined by the class X, the editor for it should be defined in the class XEditor. Alternatively, you can register a property editor by calling the PropertyEditorManager.registerEditor( ) method, probably from the constructor of your BeanInfo class. If you call this method from the bean itself, the bean then depends on the property editor class, so the editor has to be bundled with the bean in applications, which is not desirable.

In our YesNoDialog example, we don't define any new data types, but we still have two individual properties that need custom editors. In this case, we register the property editors for individual properties by specifying them in the Property-Descriptor objects returned by the getPropertyDescriptors( ) method of our BeanInfo class.

The PropertyEditor interface can seem confusing at first. Its methods allow you to define three techniques for displaying the value of a property and two techniques for allowing the user to edit the value of a property. The value of a property can he displayed:

  • As a string. If you define the qetAsText( ) method, a beanbox can convert a property to a string and display that string to the user.
  • As an enumerated value. If a property can only take on values from a fixed set of values, you can define the getTags( ) method to allow a beanbox to display a dropdown menu of allowed values for the property.
  • In a graphical display. If you define paintValue( ), a beanbox can ask the property editor to display the value using some natural graphical format, such as a color swatch for colors. You also need to define isPaintable( ) to specify that a graphical format is supported.
The two editing techniques are:
  • String editing If you define the setAsText( ) method, a beanbox knows it can simply have the user type a value into a text field and pass that value to setAsText( ). If your property editor defines getTags( ), it should also define setAsText( ) so that a beanbox can set the property value using the individual tag values.
  • Custom editing if your property editor defines getCustomEditor( ), a bean-box can call it to obtain some kind of AWT component that can be displayed in a dialog box and serve as a custom editor for the property. You also need to define supportsCustomEditor( ) to specify that custom editing is supported.
The setValue( ) method of a PropertyEditor is called to specify the current value of the property. It is this value that should be converted to a string or graphical representation by getAsText( ) or paintValue( ).

A property editor must maintain a list of event listeners that are interested in changes to the value of the property. The addPropertyChangeListener( ) and removePropertyChangeListener( ) methods are standard event listener registration and removal methods. When a property editor changes the value of a property, either through setAsText( ) or through a custom editor, it must send a PropertychangeEvent to all registered listeners.

PropertyEditor defines the getJavaInitializationString( ) for use by beanbox tools that generate Java code. This method should return a fragment of Java code that can be used to initialize variable to the current property value.

Finally, a class that implements the PropertyEditor interface must have a no-argument constructor, So that it can be dynamically loaded and instantiated by a beanbox.

Most property editors can be much simpler than this detailed description would suggest. In many cases, you can subclass PropertyEditorSupport instead of implementing the PropertyEditor! interface directly. This useful class provides no-op implementations of most PropertyEditor methods. It also implements the methods for adding and removing event listeners.

A property that has an enumerated value requires a simple property editor. The alignment property of the YesNoDialog bean is an example of this common type of property. The property is defined as an int, but it has only three legal values, defined by the constants LEFT, CENTER, and RIGHT. By default, a beanbox only knows that the property is an int, so it displays the property as a number and allows the user to enter any integer as a property value. Instead, we would like the beanbox to display one of the strings "left." "center" or "right" as the value, and allow the user to choose from these values when setting the property. This can be done with getTags( ) and setAsText( ) methods of a property editor, as shown in Example 11-6.

This example creates the YesNoDialogAlignmentEditor class, which is registered as a PropertyEditor for the alignnment property by the YesNoDialogBeanInfo class shown in Example 11-5. The property editor subclasses PropertyEditorSupport, so it is relatively short. Notice that it passes Integer objects in the calls to set-Value( ) that are made from the setAsText( ) method. You need to use wrapper objects for any primitive-type properties. The use of the Integer class is also apparent in the definition of getJavaInitializationString( ). The setValue( ) method of PropertyEditorSupport handles notifying registered PropertyChange-Listener objects about changes in the value of the property, so this simple property editor does not need to be aware of the existence of such listeners.

Read More Show Less

Table of Contents

New in This Edition;
Java Examples Online;
Related Books from O'Reilly;
Conventions Used in This Book;
Request for Comments;
Part I: Learning Java;
Chapter 1: Java Basics;
1.1 Hello World;
1.2 FizzBuzz;
1.3 The Fibonacci Series;
1.4 Using Command-Line Arguments;
1.5 Echo in Reverse;
1.6 FizzBuzz Switched;
1.7 Computing Factorials;
1.8 Recursive Factorials;
1.9 Caching Factorials;
1.10 Computing Big Factorials;
1.11 Handling Exceptions;
1.12 Interactive Input;
1.13 Using a StringBuffer;
1.14 Sorting Numbers;
1.15 Computing Primes;
1.16 Exercises;
Chapter 2: Objects, Classes, and Interfaces;
2.1 A Rectangle Class;
2.2 Testing the Rect Class;
2.3 A Rect Subclass;
2.4 Another Subclass;
2.5 Complex Numbers;
2.6 Computing Statistics;
2.7 An Integer List;
2.8 Tokenizing Text;
2.9 Exercises;
Part II: Core Java APIs;
Chapter 3: Input/Output;
3.1 Files and Streams;
3.2 Working with Files;
3.3 Copying File Contents;
3.4 Reading and Displaying Text Files;
3.5 Listing Directory and File Information;
3.6 Compressing Files and Directories;
3.7 Filtering Character Streams;
3.8 Tokenizing a Character Stream;
3.9 Random Access to Files;
3.10 Exercises;
Chapter 4: Threads;
4.1 Thread Basics;
4.2 Thread-Safe Classes;
4.3 Threads and Thread Groups;
4.4 Deadlock;
4.5 Timers;
4.6 Exercises;
Chapter 5: Networking;
5.1 Downloading the Contents of a URL;
5.2 Using a URLConnection;
5.3 Sending Email Through a URLConnection;
5.4 A Simple Network Client;
5.5 A Generic Client;
5.6 An HTTP Client;
5.7 A POP Client;
5.8 A Simple Web Server;
5.9 A Proxy Server;
5.10 A Generic Multithreaded Server;
5.11 Sending Datagrams;
5.12 Receiving Datagrams;
5.13 Exercises;
Chapter 6: New I/O;
6.1 Locking Files;
6.2 Copying Files;
6.3 Regular Expressions and Character Decoding;
6.4 File Copying with Buffers;
6.5 Advanced Byte-to-Character Conversion;
6.6 Tokenizing Byte Buffers;
6.7 A Simple HTTP Client;
6.8 The Daytime Service;
6.9 A Multiplexed Server;
6.10 A Multiplexed Network Client;
6.11 Exercises;
Chapter 7: Security and Cryptography;
7.1 Running Untrusted Code;
7.2 Loading Untrusted Code;
7.3 Message Digests and Digital Signatures;
7.4 Cryptography;
7.5 Exercises;
Chapter 8: Internationalization;
8.1 A Word About Locales;
8.2 Unicode;
8.3 Character Encodings;
8.4 Handling Local Customs;
8.5 Localizing User-Visible Messages;
8.6 Formatted Messages;
8.7 Exercises;
Chapter 9: Reflection;
9.1 Obtaining Class and Member Information;
9.2 Invoking a Named Method;
9.3 Proxy Objects;
9.4 Exercises;
Chapter 10: Object Serialization;
10.1 Simple Serialization;
10.2 Custom Serialization;
10.3 Externalizable Classes;
10.4 Serialization and Class Versioning;
10.5 Exercises;
Part III: Desktop Java APIs;
Chapter 11: Graphical User Interfaces;
11.1 Components;
11.2 Containers;
11.3 Layout Management;
11.4 Event Handling;
11.5 A Complete GUI;
11.6 Actions and Reflection;
11.7 Custom Dialogs;
11.8 An Error Handler Dialog;
11.9 Displaying Tables;
11.10 Displaying Trees;
11.11 A Simple Web Browser;
11.12 Describing GUIs with Properties;
11.13 Themes and the Metal Look-and-Feel;
11.14 Look-and-Feel Preferences;
11.15 The ShowBean Program;
11.16 Exercises;
Chapter 12: Graphics;
12.1 Graphics Before Java 1.2;
12.2 The Java 2D API;
12.3 Drawing and Filling Shapes;
12.4 Transforms;
12.5 Line Styles with BasicStroke;
12.6 Stroking Lines;
12.7 Filling Shapes with Paint;
12.8 Antialiasing;
12.9 Combining Colors with AlphaComposite;
12.10 Image Processing;
12.11 Image I/O;
12.12 Custom Shapes;
12.13 Custom Strokes;
12.14 Custom Paint;
12.15 Advanced Animation;
12.16 Displaying Graphics Examples;
12.17 Exercises;
Chapter 13: Printing;
13.1 Printing with the Java 1.1 API;
13.2 Printing with the Java 1.2 API;
13.3 Printing with the Java 1.4 API;
13.4 Printing Multipage Text Documents;
13.5 Advanced Printing with Java 1.4;
13.6 Exercises;
Chapter 14: Data Transfer;
14.1 Simple Swing Data Transfer;
14.2 A Clock with Drag and Copy Support;
14.3 Data Transfer Architecture;
14.4 Dropping Multiple Datatypes;
14.5 A Transferable Shape;
14.6 Custom Data Transfer;
14.7 Exercises;
Chapter 15: JavaBeans;
15.1 Bean Basics;
15.2 A Simple Bean;
15.3 A More Complex Bean;
15.4 Custom Events;
15.5 Specifying Bean Information;
15.6 Defining a Simple Property Editor;
15.7 Defining a Complex Property Editor;
15.8 Defining a Bean Customizer;
15.9 Manipulating Beans;
15.10 Exercises;
Chapter 16: Applets;
16.1 Introduction to Applets;
16.2 A First Applet;
16.3 A Clock Applet;
16.4 A Timer Applet;
16.5 Applets and the Java 1.0 Event Model;
16.6 Exercises;
Chapter 17: Sound;
17.1 Ringing the Bell;
17.2 Swing Aural Cues;
17.3 Playing Sounds with AudioClip;
17.4 Playing Sounds with javax.sound;
17.5 Streaming Sounds with javax.sound;
17.6 Synthesizing a MIDI Sequence;
17.7 Real-Time MIDI Sounds;
17.8 Exercises;
Part IV: Enterprise Java APIs;
Chapter 18: Database Access with SQL;
18.1 Accessing a Database;
18.2 Using Database Metadata;
18.3 Building a Database;
18.4 Using the API Database;
18.5 Atomic Transactions;
18.6 Exercises;
Chapter 19: XML;
19.1 Parsing with JAXP and SAX;
19.2 Parsing and Manipulating with JAXP and DOM;
19.3 Transforming XML with XSLT;
19.4 An XML Pull Parser;
19.5 Exercises;
Chapter 20: Servlets and JavaServer Pages;
20.1 Servlet Setup;
20.2 A Hello World Servlet;
20.3 Another Simple Servlet;
20.4 Servlet Initialization and Persistence: A Counter Servlet;
20.5 Hello JSP;
20.6 Hello JSP2;
20.7 Hello XML;
20.8 The MVC Paradigm for Web Applications;
20.9 ListManager Model Classes;
20.10 ListManager Controller;
20.11 ListManager Views;
20.12 Custom Tags in JSP 2.0;
20.13 Packaging a Web Application;
20.14 Exercises;
Chapter 21: Remote Method Invocation;
21.1 Remote Banking;
21.2 A Bank Server;
21.3 A Persistent Bank Server;
21.4 A Multiuser Domain;
21.5 Remote MUD Interfaces;
21.6 The MUD Server;
21.7 The MudPlace Class;
21.8 The MudPerson Class;
21.9 A MUD Client;
21.10 Advanced RMI;
21.11 Exercises;
Chapter 22: Example Index;
22.1 Symbols;
22.2 A;
22.3 B;
22.4 C;
22.5 D;
22.6 E;
22.7 F;
22.8 G;
22.9 H;
22.10 I;
22.11 J;
22.12 K;
22.13 L;
22.14 M;
22.15 N;
22.16 O;
22.17 P;
22.18 Q;
22.19 R;
22.20 S;
22.21 T;
22.22 U;
22.23 V;
22.24 W;
22.25 X;
22.26 Y;
22.27 Z;

Read More Show Less

Customer Reviews

Average Rating 5
( 1 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing 1 Customer Reviews
  • Anonymous

    Posted April 29, 2000

    Java Examples in a Nutshell review

    Great Book! Although it does have its place in learning java. First of all its not a referenece manual and not ment to teach you everything. Although a great book otherwise and it fits nicely with Java in a Nutshell which should be purchased first. Then I would definitaly get Java Examples second to help put up where the first book left off.. Its really an extension of the first half of Java in a Nutshell. (The second half of Java in a Nutshell is all reference)

    1 out of 1 people found this review helpful.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing 1 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)