Java Examples in a Nutshell, 3rd Edition

Book Description

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.

Customer Reviews:

Great bang for your buck with useful, very well explained examples........2006-10-05

This book rocks. I started learning Java about 2 months ago with the Head First Java book, which is AMAZINGLY helpful (even if you know absolutely nothing beforehand). Once I got through that all that I began writing small apps on my own, but found in many cases that the API (Javadoc) was hard to understand because my limited Java knowledge leaves me with no context in many cases. I would think, "ok, it says this class can do this using these methods, and that's what I want, but how exactly do I put this into practice." Java Examples in a Nutshell fills this need perfectly with excellent examples(!), explanations, and clarifications. There's only so much that it can cover, but what it does cover, it covers really well.

I might also add that I bought this book after *returning* Java In A Nutshell because for me it really just seemed like a $50 printout of the API you can read for free at [....].

What I want to say is that, from my own experience, if you are pretty new to Java, and you are clicking well with it, and want a boost to propel you forward even faster, this is an excellent book to buy.

Summary of Java.......2006-02-23

Great overall summary of Java with examples. Replaces short surveys, tutorials and cookbooks of Java.

Very good book of examples of specific Java concepts.......2006-01-24

This book should not be expected to substitute as a tutorial for people looking to learn the Java language. Instead, it is a book full of short programs that each illustrate specific concepts in the Java language. If you are needing a tutorial on the Java language in general, I suggest "Head First Java", which is also published by O'Reilly and Associates. You can either read the appropriate chapters of this book in parallel with that one, or look through this book after you finish the Head First Java book. If you already know Java, keeping an updated edition of this book around as a reference is a great idea.
The first four chapters of this book cover the basics of Java, objects, classes, interfaces, input/output, and threads. Thus these chapters remain largely unchanged from the previous edition. Chapter 5, on networking, has been updated to reflect the changes in the language since the last edition, and contains examples of a simple network client, an HTTP client, and a POP client in addition to the programs of the previous edition. Chapter six is a new chapter on The new I/O (NIO) APIs introduced in version 1.4. These provide new features and improved performance in the areas of buffer management, scalable network and file I/O, character-set support, and regular-expression matching. The NIO APIs supplement the I/O facilities in the java.io package, and this chapter does a good job of demonstrating the APIs in action. The next chapter that has had a major overhaul is the chapter on printing. Printing in JDK1.4 was updated considerably and allows you to list specific printers with specific capabilities, query printer status, spool text or image files directly to a printer, and convert image files to Postscript files. There are examples of all of these upgrades in this chapter. The chapter on data transfer has largely been rewritten to reflect that Swing has added support for data transfer between applications. When adding data transfer support to Swing, the goal was to make it easy for developers using Swing components to add clipboard transfer as well as drag and drop to an application. The examples in this chapter demonstrate these concepts very well. There is a completely new chapter on the Java Sound API reflecting the capabilities of that API. In addition to simply playing sounds and sequences, the chapter demonstrates synthesizing MIDI and also real-time MIDI. Finally, the last part of the book on the Enterprise API's has been completely rewritten to reflect all of the changes that have taken place in those API's since the last edition due to the popularity of the Java language in enterprise applications.
Currently, this book is two years old, which is getting a bit long in the tooth for a computer book. This is especially true if you consider the fact that JDK 1.5 has been released since this book was published with its own set of upgrades and nuances, and that JDK 1.6 is scheduled for release in the fall of 2006. I don't know if a fourth edition is planned for the immediate future, so if you can get the 3rd edition used for a low price it might still be worth the investment. If you are a Java novice, it is definitely worth your time and money.

Pompous annoying examples.Think twice there are better books.......2005-06-11

While writing this I can already imagine the shock and dismay of the Fan crowd with my review. I don't have much time so let me get to the point.
The 1 star I've given it (bcs I had to, preferable I'd rate it 0 stars) mostly pertains to the GUI section of the book. Instead of providing the reader with abundant and clear examples, this author wants to impress the Java geeks by writing an 'smart' generic class that shows all the different aspects of the java GUI elements. Aside from just lame, this is also done most likely because of laziness. I can imagine it's not very exciting to write up the core program structure for every GUI example. But that's just the way a decent author would go about. No need to waste pages by explicitly mentioning everything more then once. Such things can be saved for the example source right ? But mr Flanagan does not share that view. He sits back with his (admittedly entertaining) 'showcomponent' program that loads in all the gui program code (classes) and displays the material. So, again, his 'Java examples' are merely small files with therein declared a certain class without any(!) surrounding program code. (basically similar to what you'd see in the Swing lang spec). All these compiled examples need to be read in (from the command line no less, by his showcomponent class which then actually does all the work of creating the frame, displaying it etc etc etc.

And then cometh the reader, . . . . The moment you have to incorporate some of these lay-out en control components in you're own program this entire structure is obviously useless. Hence you have to struggle to get every component to work after all. The exact thing one is trying to avoid by buying a book. (No, you can't just copy & paste several separate sources together :) ). Basically you end up doing all the work yourself in the end anyway. Henceforth this book, particularly the part of GUI's , dialog's and event handling is of little practical use. I guess it would qualify as some sort of java coffee table book. Interesting functions, a clever introspective class here and there, things you can sit back and debate about with you're friends.
Not with you're collegue(s) when you fighting the deadlines.
While I'm not very proficient in Java, I've coded in c/c++ for far too long. Hence I don't need trivial lectures on what a ip port is. I just need to see some _completed_ (as in finished) programs, to get up and running with particular Java idiosyncrasies & components. If you are in a hurry, and simply have to get something up and running, keep running. Away from this piece of trash.
Go with "Core Java" or some of the Swing books. it'll get you there much much faster.

Edit: Took the flames out of the review. I was rather disappointed with this title at first. (now it's just collecting dust, but at least it doesn't aggravate me either).
If you're a programmer, (like me) you can read the spec by yourself. It's the little things on the outside of the program (event & message que's ,window trickery etc.) that differ from platform to platform. Those are the exact things the author glosses over with this text.

Real working Code examples.......2005-01-30

Just type these in and learn, learn, learn. Good examples across the board.

Average customer rating:

Java Review
Excellent book if you know a few things about programming
Ahh a delight for your mind
Good survey style introduction to Java technologies
This isn't just a tutorial for beginners

Learning Java
Pat Niemeyer , and Jonathan Knudsen
Manufacturer: O'Reilly Media, Inc.
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Java | Programming | O'Reilly | By Publisher | Books

General | Programming | O'Reilly | By Publisher | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 0596008732

Amazon.com

Java is the language du jour, and plenty of books have been written about it. But with so many books available, new offerings should be something special. This one isn't.

Learning Java starts at the beginning with a "hello world"-style program that demonstrates using Sun's Java tools. Throughout, the book introduces features using examples--all thoroughly discussed and explained in as straightforward and jargon-free a manner as practicable.

A tricky aspect of Java is the way classes are related, so it's neat to see a whole chapter devoted to the subject early on. Even more opaque is the explicit use of threads. Again, this topic is made accessible in this text, especially with its discussion of thread synchronization. Basic graphics, video handling, and other media in Java are discussed, followed by Beans and the builder environment--but stopping short of JavaBeans. The book finishes with a section on applets, the Java plug-in, and digital signatures.

Overall, however, the reader gets no feeling of working toward a goal, and perhaps this would have been a better book if a project had been its theme. Another odd decision in the mix here was to ignore the several--some free--Java IDEs generally used to program Java. (The book makes a point of saying it hasn't discussed them but doesn't explain. Even beginners find Java more accessible in a programming environment.)

Still, Learning Java, which uses Java 2 v1.3, does a competent job of introducing the language to beginners. As with most O'Reilly books, it's authoritative, lucid, and well edited. Though this book may fail to inspire in the reader the presumed enthusiasm for Java felt by the authors, you won't go wrong with this one, and its coverage of object-oriented programming issues is particularly good. --Steve Patient, Amazon.co.uk

Book Description

Version 5.0 of the Java 2 Standard Edition SDK is the most important upgrade since Java first appeared a decade ago. With Java 5.0, you'll not only find substantial changes in the platform, but to the language itself-something that developers of Java took five years to complete. The main goal of Java 5.0 is to make it easier for you to develop safe, powerful code, but none of these improvements makes Java any easier to learn, even if you've programmed with Java for years. And that means our bestselling hands-on tutorial takes on even greater significance.

Learning Java is the most widely sought introduction to the programming language that's changed the way we think about computing. Our updated third edition takes an objective, no-nonsense approach to the new features in Java 5.0, some of which are drastically different from the way things were done in any previous versions. The most essential change is the addition of "generics", a feature that allows developers to write, test, and deploy code once, and then reuse the code again and again for different data types. The beauty of generics is that more problems will be caught during development, and Learning Java will show you exactly how it's done.

Java 5.0 also adds more than 1,000 new classes to the Java library. That means 1,000 new things you can do without having to program it in yourself. That's a huge change. With our book's practical examples, you'll come up to speed quickly on this and other new features such as loops and threads. The new edition also includes an introduction to Eclipse, the open source IDE that is growing in popularity.

Learning Java, 3rd Edition addresses all of the important uses of Java, such as web applications, servlets, and XML that are increasingly driving enterprise applications. The accompanying CD includes the Java 5.0 SDK for Windows, Linux, and Solaris, plus the Eclipse IDE, the NetBeans IDE, and the many example programs from the book.

Customer Reviews:

Java Review.......2006-11-10

The book is a great addition to my library. While it didn't get all my questions answered, it was very helpful.

Excellent book if you know a few things about programming.......2006-05-01

This book covers almost everything (that fits inside one volume) in Java. Very concise and precise, but needs some prior experience in any high level progamming language. Very good examples. This book help me a lot to dive fast in the Java's deep waters.

Ahh a delight for your mind .......2006-02-06

I have been working in this industry for past five years, I have been addicted to buying books on programming, The trouble with most of the books is that they don't focus on people who are programmers, They just re-hash for-loop while-loop its really irritating to read such topics in say 1 hour that you can squeeze out of your time. And most of the time you end up dropping the book.
This book is definitely different

Doesn't focus on teaching programming like a text for university course?
The style of narrative is super and free-flowing. It is easy to read say 100 pages per day
The examples are quite stylish and don't have the dummies approach.
The authors have depth knowledge abt what they are talking

In all a good book if your bit experienced in java/C++ or even C
(Newcomers should start with books like head-first java or C++ by lafore before taking up this material)

There is one definite short coming this books some times doesn't covers very complicated topics; and definitively you can't hope to use it as an reference.

Hope the authors write a book on advance java topics that can be read after finishing this book

Good survey style introduction to Java technologies.......2006-02-02

Learning Java provides a good introduction to the Java technologies that make up J2SE. While most of the sections does not go into enough detail to fully cover the area (and that would be impossible without making the book a multi volume effort) they provide enough detail to form the basis of further research.

The section on Java the language provides enough detail to get you up and running if you already know another object oriented language such as C++ or C# but it will not be sufficient for complete beginners.

But in terms of what it tries to cover as a set of overviews, it succeeds well.

This isn't just a tutorial for beginners.......2006-01-03

Patrick Niemeyer and Jonathan Knudsen's Learning Java appears in its 3rd updated edition to cover J2SE 5.0. This isn't just a tutorial for beginners: it moves from a basic introduction and application examples all the way to advanced topics such as advanced Java 5.0 features and writing threaded programs. So don't expect a simple introduction - though the lessons are designed as a 'classroom in a book' - chapters are quite technical and Java programmers with programming backgrounds will be pleased with its depth.

Average customer rating:

Far better resources available
HAVE A CUP OF JAVA I/O!!
Pretty good coverage of NIO and practical crypto
Great reference for your file input/output logic...
Great 2nd edition of a comprehensive book on Java I/O

Java I/O
Elliotte Harold
Manufacturer: O'Reilly Media, Inc.
ProductGroup: Book
Binding: Paperback

General | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Java | Programming | O'Reilly | By Publisher | Books

General | Programming | O'Reilly | By Publisher | Books
Similar Items:

ASIN: 0596527500

Amazon.com

Because it doesn't provide a printf() function like C/C++, some developers think Java isn't up to snuff with files and streams. Author Rusty Harold Elliotte argues against this notion in Java I/O, a book that shows how Java's stream support can help simplify network programming, internationalization, and even compression and encryption.

The book opens with an overview of Java's stream capabilities. (The author defends Java's lack of support for console input/output (I/O) since today's applications use graphical user interfaces anyway.) He shows how to open, read, and write local files in Java applications. His file viewer example presents data in a variety of formats. (This example is improved several times until it winds up supporting different international character sets by the end of the book.)

Next the author covers network programming using URL and network streams, including sockets. Sections on filters show how classes can filter out characters within streams. The tour moves forward to cover data streams, which permit streaming of Java's primitive data types. Details on how to communicate within Java programs using pipes follow. In a notable chapter, the author thoroughly explicates Java's support for encryption, including hashing, the Data Encryption Standard (DES) algorithm, and ciphers.

The last portion of the book explains object serialization, which allows Java objects to save and restore their state, plus it includes sections on Java's support for data compression (and ZIP files) and multilingual Unicode character sets. (Java is prepared to handle virtually any of the world's languages with its reader and writer classes.) Finally, the author shows how you can format output in Java using its support for width and numeric precision APIs.

In all, Elliotte makes a good case that Java streams are a flexible and powerful part of the language, and certainly not a limitation. --Richard Dragan

Book Description

All of Java's Input/Output (I/O) facilities are based on streams, which provide simple ways to read and write data of different types. Java provides many different kinds of streams, each with its own application. The universe of streams is divided into four large categories: input streams and output streams, for reading and writing binary data; and readers and writers, for reading and writing textual (character) data. You're almost certainly familiar with the basic kinds of streams--but did you know that there's a CipherInputStream for reading encrypted data? And a ZipOutputStream for automatically compressing data? Do you know how to use buffered streams effectively to make your I/O operations more efficient? Java I/O, 2nd Edition has been updated for Java 5.0 APIs and tells you all you ever need to know about streams--and probably more.

A discussion of I/O wouldn't be complete without treatment of character sets and formatting. Java supports the UNICODE standard, which provides definitions for the character sets of most written languages. Consequently, Java is the first programming language that lets you do I/O in virtually any language. Java also provides a sophisticated model for formatting textual and numeric data. Java I/O, 2nd Edition shows you how to control number formatting, use characters aside from the standard (but outdated) ASCII character set, and get a head start on writing truly multilingual software.

Java I/O, 2nd Edition includes:

Coverage of all I/O classes and related classes

In-depth coverage of Java's number formatting facilities and its support for International character sets

Customer Reviews:

Far better resources available.......2007-06-17

It covers a lot of topics but I did find it particularly helpful in any way. The idea of gathering all the information about I/O into one book to use as a single resource is nice, but this book doesn't do a good job. Not that much help in explaining things and no help at all as far as practical examples went. You will learn much more from general Java books and Google searches.

HAVE A CUP OF JAVA I/O!!.......2006-11-04

Howell do you know I/O? If you don't know it very well, then this book is for you. Author Elliote Rusty Harold, has done an outstanding job of writing a 2ndedition of a book that shows you the I/O tricks and techniques used by gurus and wizards of the Java world.

Harold, begins with an exploration of I/O in Java. Then, the author discusses the two most common targets of I/O, the filesystem and the network. Next, he discusses filter streams, which are Java's mechanism for processing data as you read or write rather than doing it after the fact. The author also discusses a completely new I/O model based on channels and buffers instead of streams. He continues by discussing operations on files themselves as distinct from the contents of those files. Then, the author explores how text is represented in Java and how it can be manipulated through special text streams called readers and writers. Finally, he shows you how to communicate with different kinds of peripherals and small devices that don't have traditional filesystems or network connections..

This most excellent book assumes you have a basic familiarity with Java. More importantly, this book is not a language tutorial, and the emphasis will always be on the I/O-specific features.

Pretty good coverage of NIO and practical crypto.......2006-09-23

Not a fan of O'Reilly books, but this one stands out because of excellent NIO coverage and topical examples. It beats the the "Java NIO" book from O'Reilly hands down. Overall I'd say this book is geared for those who want to implement but covers enough detail that it probably even soothes the more 'academic' out there (those who talk a good show but do not build real-world software).

Some highlights:

- You'll find good coverage of cryptographic I/O aimed at practical implementation.

- Excellent NIO coverage (including basic network servers in sync and async patterns)

- ZIP and JAR information including dynamic class loading

- Serial, USB and Bluetooth chapters (caveat: I don't use these but read them out of curiousity)

- Detailed coverage of readers/writers

- And obviously good coverage of the basic java.io/net packages.

As of Septemebr 2006 I find the book topical and current (even had some examples of future Java 6 code). To give you an idea of the detail offered here, there is a whole chapter (37 pages) of information on File access alone including pitfalls of cross-platform implementation. Not reading/writing files...just the trappings of opening and accessing files and directories using particular patterns, URLs, etc. The actual I/O is covered in similar depth in other chapters.

I'd also like to say that I highly appreciate examples that are concise and independant. There is nothing more frustrating than flipping to the middle of a book (what we all do anyway) and going through an example...only to find out that the author is using opaque references to classes and methods he/she developed on their own in five earlier chapters (bouncycastle APIs in Java Cryto for example). This pretty much makes quick-reference difficult to impossible and this book thankfully avoids it in spades.

I give it five starts because it'll be well used in several projects and because it is readable and accessible to both novice and advanced developers alike.

Great reference for your file input/output logic..........2006-09-11

[Review of 2nd edition]

Getting data into and out of files in your Java program can be painstaking when you consider all the variations... network resources as files, compressed files, text vs. binary data in the file, etc. Java has significant power in this area, but there's a lot to know and understand. Elliotte Rusty Harold has made the task of learning it all a little easier with the book Java I/O (2nd edition).

Contents:
Part 1 - Basic I/O: Introducing I/O; Output Streams; Input Streams
Part 2 - Data Sources: File Streams; Network Streams
Part 3 - Filter Streams: Filter Streams; Print Streams; Data Streams; Streams in Memory; Compressing Streams; JAR Archives; Cryptographic Streams; Object Serialization
Part 4 - New I/O: Buffers; Channels; Nonblocking I/O
Part 5 - The File System: Working with Files; File Dialogs and Choosers
Part 6 - Text: Character Sets and Unicode; Readers and Writers; Formatted I/O with java.text
Part 7 - Devices: The Java Communications API; USB; The J2ME Generic Connection Framework; Bluetooth
Part 8 - Appendix: Appendix; Index

The first edition of this book was written back in 1999, and that's an eternity in computer years. Not only has the java.nio classes come into play since then, but you now have devices that were either bleeding edge or concept-only in 1999, like Bluetooth gadgets. Harold has improved the basic material to bring it up to date with the current state of Java development, and added the additional information for I/O classes through Java 6. I appreciated the large amount of coding samples that he uses to illustrate his points, as it makes it easy to adapt your learning to your own particular situation. The examples are also very focused, so you don't end up trying to filter out extraneous code to find the applicable concept you need.

There's another way to use this book that makes it even more valuable than just a reference manual. If you've been coding for awhile, it's possible that you've developed some ingrained approaches to file I/O that are outdated. By simply scanning the information here, you could easily find new ways to build your applications using newer methods. Or, you might find there are language features you didn't know existed, like the ability to write your files in a compressed format without having to go through a separate utility. Two or three personal revelations like that, and the book has quickly earned its place on the shelf.

While you may not use this book for every Java application you build, you'll definitely want it whenever you're working with I/O logic...

Great 2nd edition of a comprehensive book on Java I/O.......2006-05-23

The first edition of Java I/O is now seven years old, and it is definitely time for a second edition considering all that has transpired. Note that the second edition was released in May 2006, so all reviews older than that are referring to the first edition. In this second edition there are basically eight entirely new chapters added to the original seventeen. It is probably worth the price of an upgrade especially if you are interested in Java I/O as it pertains to devices. I review this second edition in the context of comparing it to the first edition.

Chapters 1 through 5 are virtually the same.
Chapter six, "Filter Streams", has had one section - Print Streams - removed and had another section on the ProgressMonitorInputStream class added. ProgressMonitorInputStream is a unique filter stream hiding in the javax.swing package that displays progress bars that indicate how much of a stream has been read and how much remains to be read, and this book shows how to use it when reading unusually large files. The section on Print Streams that was removed from chapter six now has an entire chapter dedicated to it. This is because, starting in Java 5, the familiar PrintStream class has become a lot more powerful and interesting. Besides basic console output, it now provides extensive capabilities for formatting numbers and dates in a straightforward and easy fashion.

The chapters on data streams, streams in memory, and compressing streams are virtually unchanged from the first edition. However, the "Jar Files" section from the "compressing streams" chapter has been removed and now has an entire chapter dedicated to it. In this chapter, among other topics, the author explains the Pack200 compression format and evangelizes the increasingly popular technique of hiding noncode resources like images and data files inside JAR files. The two chapters on cryptographic streams and object serialization are basically the same as before, except that one section has been added on the JavaDoc in the serialization chapter.

The next section of the book, on New I/O, is completely new material and is comprised of three chapters. The java.nio packages provide nonblocking and memory-mapped I/O, and chapters 14 through 16 cover these powerful new abilities in depth. The new I/O model is based on channels and buffers instead of streams. This model doesn't replace traditional stream-based I/O for many uses. However, it is significantly faster in one important use case: servers that process many simultaneous clients.

The next two sections of the book, "The File System" and "Text", pretty much mimic chapters 12 through 16 of the first edition.

The final section of the book, "Devices", has almost completely new material. Some of the most exciting developments since the first edition have occurred in the world of small devices,in both peripherals such as GPS receivers that connect to a host computer and devices such as Palm Pilots that are themselves increasingly powerful computers. Treatment of both of these has been dramatically expanded in this edition. For those readers working with serial and parallel port devices, the Java Communications API chapter has been upgraded to version 3.0. However, in 2006 more and more devices use faster USB ports instead. Consequently, Chapter 23 covers the new Java USB API in depth. For smaller devices that can't quite run full Java but need to perform I/O nonetheless, J2ME offers the Generic Connection Framework (GCF). Chapter 24 covers this alternative to the traditional I/O framework. Finally, Chapter 25 uses the GCF to communicate over one of the newest I/O buses, the Bluetooth API used for wireless communications with a variety of peripherals.

I was very pleased with the first edition of this book, and I have an even higher recommendation for this second edition. There are clear descriptions of how to use the Java I/O classes as well as well-commented code examples for everything. However, if you are just recently coming from a C or C++ programming perspective, the Java I/O model is so different that it will likely be a shock no matter how good the teacher is, and Mr. Harold is an excellent one. I notice that Amazon does not show the table of contents, so I do that here:
Part PART I: Basic I/O
Chapter 1. Introducing I/O
Chapter 2. Output Streams
Chapter 3. Input Streams
Part PART II: Data Sources
Chapter 4. File Streams
Chapter 5. Network Streams
Part PART III: Filter Streams
Chapter 6. Filter Streams
Chapter 7. Print Streams
Chapter 8. Data Streams
Chapter 9. Streams in Memory
Chapter 10. Compressing Streams
Chapter 11. JAR Archives
Chapter 12. Cryptographic Streams
Chapter 13. Object Serialization
Part PART IV: New I/O
Chapter 14. Buffers
Chapter 15. Channels
Chapter 16. Nonblocking I/O
Part PART V: The File System
Chapter 17. Working with Files
Chapter 18. File Dialogs and Choosers
Part PART VI: Text
Chapter 19. Character Sets and Unicode
Chapter 20. Readers and Writers
Chapter 21. Formatted I/O with java.text
Part PART VII: Devices
Chapter 22. The Java Communications API
Chapter 23. USB
Chapter 24. The J2ME Generic Connection Framework
Chapter 25. Bluetooth
Part PART VIII: Appendix
Character Sets

Average customer rating:

A book by RonF Hitchens
Pretty good overview but consider using a framework.
Ok, but no great.
A Great Book for NIO
Good introduction to NIO (and regular exprs??), lacks depth

Java NIO
Ron Hitchens
Manufacturer: O'Reilly Media, Inc.
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Computer Science | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

French | Foreign Language Nonfiction | Nonfiction | Subjects | Books

Java | Programming | O'Reilly | By Publisher | Books

General | Programming | O'Reilly | By Publisher | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Nonfiction Books | Trip | Specialty Stores | Books

Nonfiction | French | Foreign Language Books | Specialty Stores | Books

Professional & Technical | French | Foreign Language Books | Specialty Stores | Books

All French Books | French | Foreign Language Books | Specialty Stores | Books
Similar Items:

ASIN: 0596002882

Book Description

Many serious Java programmers, especially enterprise Java programmers, consider the new I/O API--called NIO for New Input/Output--the most important feature in the 1.4 version of the Java 2 Standard Edition. The NIO package includes many things that have been missing from previous editions of Java that are critical to writing high-performance, large-scale applications: improvements in the areas of buffer management, scalable network and file I/O, character-set support, and regular expression matching. Most of all, it boosts performance and speed dramatically. Java NIO explores the new I/O capabilities of version 1.4 in detail and shows you how to put these features to work to greatly improve the efficiency of the Java code you write. This compact volume examines the typical challenges that Java programmers face with I/O and shows you how to take advantage of the capabilities of the new I/O features. You?ll learn how to put these tools to work using examples of common, real-world I/O problems and see how the new features have a direct impact on responsiveness, scalability, and reliability. The book includes:

A rundown of the new features in NIO
Basic and advanced I/O Concepts
Binary I/O and the new buffer classes
Memory mapped files and file locking
Character I/O: encoding, decoding and transforming character data
Regular Expressions and the new java.util.regex package
Muliplexing with java.nio

Because the NIO APIs supplement the I/O features of version 1.3, rather than replace them, you'll also learn when to use new APIs and when the older 1.3 I/O APIs are better suited to your particular application. Java NIO is for any Java programmer who is interested in learning how to boost I/O performance, but if you're developing applications where performance is critical, such as game computing or large-scale enterprise applications, you'll want to give this book a permanent spot on your bookshelf. With the NIO APIs, Java no longer takes a backseat to any language when it comes to performance. Java NIO will help you realize the benefits of these exciting new features.

Customer Reviews:

A book by RonF Hitchens.......2006-11-17

No, that's not a mistake the F in the RonF, I really meant it.. in italian "ronf ronf" stands for the sleeping snore, and that's what you will be doing if you try to read this book. I had to struggle with myself real hard to force my way through this book, and trust me, I am used to reading books that are not exactly pure entertainment. The material presented is actually quite accurate and useful, only the presentation style is abysmally boring, arid and schematic. Even the table of contents reflects that, it goes: Buffer - Channel - Selectors - Regexp - Charsets. Every subject is explained pretty much in isolation of each other. How can you possibly put together anything even remotely engaging and conving with a style like that? It's like trying to teach you the english language using a dictionary, first learn all the words that start with A, then let's go to the B...
The irony is that in the intro to chap 1, the author even makes jokes about IO not being so dull as usually believed. Well I agree with him , but he certainly managed to make an outstanding contribution to the dullness of IO. Should he be congratulated?

Pretty good overview but consider using a framework........2004-10-30

This is a pretty good overview, particularly for those who have no previous experience with non-blocking IO. The author explains the concept of buffers very well, with useful diagrams illustrating the differences between position, limit, etc.

The material on selectors and readiness selection is also strong.

The problem is, there are idiosyncracies to NIO that make it difficult to use effectively for large-scale, high-performance applications without some in-depth knowledge.

If you're really looking to architect a substantial NIO server or client, read this book for the overview, but also be sure to take a look at the open source Netty framework by Trustin Lee, or Ember IO by Mike Spille to see good NIO implementations that you can use as a building block.

Ok, but no great........2004-01-18

I am not sure what else is out there? The book ok, but not really remarkable in any way.

A Great Book for NIO.......2003-08-31

NIO is a great IO class, I think it's the best package presented by Sun since Swing, it provides you with more than what you need from NIO class in just 250 pages.

Good introduction to NIO (and regular exprs??), lacks depth.......2003-08-05

The book is useful to get started on nio, but you may overgrow it after a week:
it does not delve deeply into the matter. Particularly missing are:
- Mapped byte buffer uses
- Interactions between java & else using mapped files
- OS/platform idiosyncrasies (limits etc)
- Performance analysis

Finally, be aware that half of the book is devoted to regular expressions. The conflagration of nio and regexps is rather strange. I would rather have a shorter book with just a little more depth.

Books:

Books Index

Books Home

Recommended Books