Download Ebook Java I/O, by Elliotte Rusty Harold
By reviewing Java I/O, By Elliotte Rusty Harold, you can understand the understanding and also points more, not only about just what you receive from individuals to individuals. Schedule Java I/O, By Elliotte Rusty Harold will certainly be much more trusted. As this Java I/O, By Elliotte Rusty Harold, it will really provide you the great idea to be successful. It is not only for you to be success in certain life; you can be successful in everything. The success can be begun by recognizing the standard understanding and do activities.
Java I/O, by Elliotte Rusty Harold
Download Ebook Java I/O, by Elliotte Rusty Harold
Java I/O, By Elliotte Rusty Harold. One day, you will find a new journey and knowledge by investing more cash. Yet when? Do you think that you require to obtain those all requirements when having much money? Why do not you attempt to obtain something straightforward initially? That's something that will lead you to recognize even more regarding the world, experience, some locations, past history, amusement, and also more? It is your very own time to continue checking out habit. One of the books you could take pleasure in now is Java I/O, By Elliotte Rusty Harold below.
It is not secret when linking the composing abilities to reading. Reading Java I/O, By Elliotte Rusty Harold will certainly make you obtain more resources and resources. It is a way that could improve exactly how you ignore and also comprehend the life. By reading this Java I/O, By Elliotte Rusty Harold, you can more than just what you get from various other publication Java I/O, By Elliotte Rusty Harold This is a well-known publication that is released from well-known author. Seen type the author, it can be relied on that this publication Java I/O, By Elliotte Rusty Harold will offer lots of inspirations, concerning the life and also experience and everything inside.
You might not have to be question concerning this Java I/O, By Elliotte Rusty Harold It is simple means to obtain this publication Java I/O, By Elliotte Rusty Harold You could simply check out the set with the web link that we offer. Here, you can purchase the book Java I/O, By Elliotte Rusty Harold by online. By downloading and install Java I/O, By Elliotte Rusty Harold, you can find the soft documents of this book. This is the exact time for you to start reading. Also this is not printed book Java I/O, By Elliotte Rusty Harold; it will specifically give more advantages. Why? You may not bring the published publication Java I/O, By Elliotte Rusty Harold or only stack guide in your residence or the workplace.
You can finely add the soft file Java I/O, By Elliotte Rusty Harold to the gizmo or every computer unit in your office or residence. It will help you to constantly proceed reviewing Java I/O, By Elliotte Rusty Harold whenever you have leisure. This is why, reading this Java I/O, By Elliotte Rusty Harold doesn't offer you troubles. It will offer you crucial sources for you that want to start creating, blogging about the comparable publication Java I/O, By Elliotte Rusty Harold are different publication industry.
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 largecategories: 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 automaticallycompressing 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
- Sales Rank: #1139088 in Books
- Brand: Brand: O'Reilly Media
- Published on: 2006-05-26
- Released on: 2006-05-23
- Original language: English
- Number of items: 1
- Dimensions: 9.19" h x 1.60" w x 7.00" l, 2.50 pounds
- Binding: Paperback
- 728 pages
- Used Book in Good Condition
Amazon.com Review
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
Review
'If I had to decide the best technical book ever read by me, this would be a real candidate. In my opinion a good programming book should limit itself to covering some well-defined part of its (usually) exhaustive topic. It should be easy to read with well-chose and short code-samples, especially for the critical parts and optionally, the code should grow throughout the chapters and evolve to full working programs at the end. This title fulfils it all... There aren't many illustrations throughout, but the reader will not miss them. The 'in-depth-notes' at strategic places are interesting and reveals a deep knowledge of the subject. So, if you want a fundamental understanding of streams, and data communication and /or a deep understanding of the Java I/O-model, buy it.' - Christer Loefving, Cvue, January 2000
About the Author
Elliotte Rusty Harold is originally from New Orleans to which he returns periodically in search of a decent bowl of gumbo. However, he currently resides in the University Town Center neighborhood of Irvine with his wife Beth, dog Shayna, and cats Charm (named after the quark) and Marjorie (named after his mother-in-law). He's an adjunct professor of computer science at Polytechnic University where he teaches Java, XML, and object oriented programming. He's a frequent speaker at industry conferences including Software Development, Dr. Dobb's Architecure & Design World, SD Best Practices, Extreme Markup Languages, and too many user groups to count. His open source projects include the XOM Library for processing XML with Java and the Amateur media player.
Most helpful customer reviews
19 of 19 people found the following review helpful.
Great 2nd edition of a comprehensive book on Java I/O
By calvinnme
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
7 of 7 people found the following review helpful.
An excellent discussion of a commonly misunderstood subject
By Eric J. Lind
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.
25 of 25 people found the following review helpful.
Well-written, comprehensive treatment of the subject
By A Customer
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.
Java I/O, by Elliotte Rusty Harold PDF
Java I/O, by Elliotte Rusty Harold EPub
Java I/O, by Elliotte Rusty Harold Doc
Java I/O, by Elliotte Rusty Harold iBooks
Java I/O, by Elliotte Rusty Harold rtf
Java I/O, by Elliotte Rusty Harold Mobipocket
Java I/O, by Elliotte Rusty Harold Kindle
No comments:
Post a Comment