- Taschenbuch: 596 Seiten
- Verlag: O'Reilly & Associates (1. April 1999)
- Sprache: Englisch
- ISBN-10: 1565924851
- ISBN-13: 978-1565924857
- Größe und/oder Gewicht: 17,8 x 3,1 x 23,3 cm
- Durchschnittliche Kundenbewertung: 15 Kundenrezensionen
- Amazon Bestseller-Rang: Nr. 1.281.781 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
- Komplettes Inhaltsverzeichnis ansehen
Java I/O (Java Series) (Englisch) Taschenbuch – 1. April 1999
Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.
Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.
Wenn Sie dieses Produkt verkaufen, möchten Sie über Seller Support Updates vorschlagen?
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
'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 2000Alle Produktbeschreibungen
Derzeit tritt ein Problem beim Filtern der Rezensionen auf. Bitte versuchen Sie es später noch einmal.
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.
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.
Möchten Sie weitere Rezensionen zu diesem Artikel anzeigen?
Die neuesten Kundenrezensionen