Customer Reviews

Java I/O

5 star:		(16)
4 star:		(5)
3 star:		(2)
2 star:		(2)
1 star:		(4)

 

 

This is an excellent book.

After jumping around and reading about a third of it, I was already recommending to some of the newer Java programmers around me to pick it up and get a solid understanding of proper I/O use in Java. I very much recommend this as any Java programmer's second book. Right after learning the language itself, this book should be read followed closely by other O'Reilly titles such as Java Threads and Java Network Programming. Those three books will give an in-depth understanding of the core Java API's for any new Java programmer, and will be of use to you no matter how you are using Java.

Even after three years as a Java developer, I have learned from this book. The author often presents algorithms in clear steps and follows those clear steps with a correct implementation. Because of this clear presentation, the chapter on compression left me for the first time with an understanding of not only how to use the java.util.zip.* classes but how they work. What I learned there in one reading is immediately applicable to what I am working on now. The sections on Files is full of tips on how to use them in a cross platform fashion. Every new Java programmer needs to read that chapter before their applications actually get used.

I was also impressed that several I/O classes missing in the standard library which I have only recently developed myself were presented as well. The StreamCopier and the TeeOutputStream are extremely useful classes that should be incorporated in some fashion into the base API. I wish I had them a long time ago. (A hint: you can also use the TeeOutputStream as a 'Traitor' to peek at your I/O while your program is running and without affecting its execution.) If I have any complaint about this book, it is that there are not more of these types of utilities presented for use by the advanced Java programmer. However, I haven't finished the book yet, so they may still be hidden there.

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

I had been using Java without really comprehending Java's approach to I/O. Other books never really explained what was going on to the extent that I could ever trust myself to write I/O code without having a book open.

This book clearly explains the theory and practice of Java I/O, and all the various features. It's the second most valuable Java book I own (Java in a Nutshell being the most frequently used). The book has led me to trying out facilities (such as compression and number formatting) that I otherwise shunned because of poor descriptions.

The basis of Java is to make hard things easy and easy things impossible. And among one of these impossibilites is standard I/O.

After having tried almost every single I/O class in Java and having been only able to get FileReader and FileWriter to work successfully, I decided to buy this book. I was afraid that I would get it and it would be so technical that only people who wear pocket protectors as their standard gear would be able to read it, but this was not a problem. Mr. Harrold was perfectly willing to lay everything out just as clearly as was physically possible, while at the same time still giving an equal amount of importance to examples.

Other reviewers seem to have viewed this as a weakness in the book, but personally, I would say that having an extra 50% percent of stuff you will never need is better than only having half of what is necessary to accomplish anything.

Due to my having bought this book, in the last month I have gone from basic file reading and writing, building my own file reader with a readLine() method of my own make since Sun's is buggy, to internet connections to having most recently written a proxy that logs all events that go on in my internet browser by concurrently handling six I/O operations(an in from the internet to two outs to my browser and log file, and an in from my browser to the two outs of the internet and my log file.) And I say this not to boast my prowess, but to show you just how valuable this book is to anyone who will be doing any Java programming that involves I/O.

I'm a C++ programmer that has given himself a crash-course in Java for a project at work. If I had this book earlier, I would have gotten things done a lot faster. Every programmer should be familiar with input and output streams, but how many can say they know the in's and out's of Java's cryptographic streams and piped streams? If asked, could you tell the difference between a BufferedWriter and a PrintWriter? I had to use three books to accumulate the knowledge I could have gained by just reading this one book. If you are a beginning or intermediate Java programmer, don't assume you know everything about Java I/O and what it can do; check out the pearls of wisdom in this book. Needless to say, now I'm writing much better I/O-related Java code because of it, and I believe you will too.

First of all, this is not a reference, it explains the organization behind the I/O Library. If you are looking for a reference book to locate answers in under a minute this ISN'T the book for you, instead get 'Java in a Nutshell'. Second of all, this book helps you to learn the I/O classes by constructing a program that you modify throughout the book. If that will annoy you, don't get this book. Overall, I think this is a great book! It was well worth the investment. I had previously encountered I/O documentation in more broadly scoped Java books such as, Beginning Java, in other words not much detail. This book, however, blew me away with its detail, but it is presented in a very down to earth manner. In other words, you don't have to be a rocket scientist to understand what's going on. This book will take you from the top of the I/O class hierarchy and move you down into the specialized sub-classes. All the while explaining to you what each of the classes does and like I said before, a lot of supporting details. Best of all, this book helps you understand I/O by showing you how Sun logically organized the I/O Library. By the time you've finished the book it's much easier to understand how all of the classes come together to offer powerful I/O support. Before I read this book when I looked at the inheritance tree for the I/O Library my reponse was like "you've got to be kidding me! I'll never be able to get all of this down!". But after finishing this book I am in no way intimidated or confused by the I/O classes. Good luck!

For many programmers who started off using the command line as their primary I/O source, the Java system is a bit unusual. The simple, straightforward style of C is completely different than the various classes in Java. After reading through this book and delving into a few examples, Java's I/O classes became much clearer. The class structure makes a lot of sense, separating formatting from actual reading and writing, and allows for a great deal of flexibility. Although the author maligns the old command line style, much of the java.io package is based on streams and pipes from the Unix paradigm. This somewhat flippant disregard for the command line is my only major beef with the book. Otherwise, I found it to be very readable and handled all of the topics well.

Frankly, EVERY Java program deals with I/O in some form or another. Yet no topic could have been ignored, or trivialised in so many books. Finally, here is a good book that is concise, to the point and yet very lucid.

Whether you are a Java novice or a guru, this is a 'must have' book on your shelf.

I've read many different Java books but most of them covered just the basics of Java I/O. I really got this book because I was interested in working with packet protocols in Java. The book covers many topics very clearily and I recommend it very highly. I enjoyed this book so much, I purchased Harold's other book "Java Network Programming".

Thorough guide to the java.(n)io API. Less useful as a cookbook as the organization of the book follows the API rather than focusing on specific tasks (e.g. how to best copy a file). Could have done without some of the cool chapters such as the one on J2ME (better treated in other books), or the one that describes hooking up a temperature sensor via USB, or a GPS via Bluetooth (publish these projects in a blog). Could also cut the rants about how outdated command line applications are, and I don't think the Swing-based file browser application that's built up throughout the book adds much. On the other hand I'd rather have more on performance considerations and error handling strategies!