深入理解Java IO：第二版

4星 · 超过85%的资源需积分: 7 88 浏览量更新于2024-08-01 收藏 10.48MB PDF 举报

"Java IO 2nd Edition 是一本由 Elliotte Rusty Harold 撰写的书籍，由 O'Reilly 出版，出版日期为2006年5月，ISBN-10 为 0-596-52750-0，ISBN-13 为 978-0-59-652750-1，全书共726页。本书深入探讨了Java的输入/输出（I/O）机制，主要关注基于流的模型，这些流用于读写不同类型的二进制和文本数据。" 在Java中，所有的I/O设施都建立在流的基础上，流提供了一种简单的方法来处理不同类型的数据。Java提供了多种不同类型的流，每种都有其特定的应用场景。流的宇宙被划分为四大类别：输入流和输出流，用于读写二进制数据；以及读者和写者，用于读写文本（字符）数据。基础的流类型可能大家已经很熟悉，但书中提到了一些可能不常见的流，如CipherInputStream，它用于读取加密数据，提供安全的传输；ZipOutputStream则能自动压缩数据，便于减小存储空间。此外，书中还讨论了如何有效利用缓冲流来提高I/O操作的效率，这是优化性能的关键。对于I/O的讨论，字符集和格式化是不可或缺的部分。Java支持Unicode，因此书中详细介绍了字符编码和解码的细节，包括如何处理不同的字符编码标准，如UTF-8、ISO-8859-1等。同时，书中也涵盖了日期和时间的格式化，以及如何使用PrintWriter、Formatter等工具进行文本输出。在Java 5.0 API的背景下，这本书进行了更新，涵盖了新的I/O特性，如NIO（非阻塞I/O）和文件系统API的改进。NIO引入了通道(Channel)和选择器(Selector)，允许程序处理多个输入/输出流，大大提高了并发I/O的性能。书中还可能涵盖了错误处理、文件操作、网络I/O（如套接字Socket编程）以及如何在多线程环境中安全地使用I/O资源等内容。"Java IO 2nd Edition" 是一个全面的指南，不仅适合初学者理解Java I/O的基础，也为有经验的开发者提供了深入研究和优化I/O操作的宝贵资源。

Part PART I: Basic I/O

Chapter 1: Introducing I/O

Chapter 2: Output Streams

Chapter 3: Input Streams

Page 16

Chapter 1. Introducing I/O

Input and output, I/O for short, are fundamental to any computer operating system or programming language. Only

theorists find it interesting to write programs that don't require input or produce output. At the same time, I/O

hardly qualifies as one of the more "thrilling" topics in computer science. It's something in the background, something

you use every daybut for most developers, it's not a topic with much sex appeal.

But in fact, there are plenty of reasons Java programmers should find I/O interesting. Java includes a particularly rich

set of I/O classes in the core API, mostly in the

java.io

and

java.nio

packages. These packages support several

different styles of I/O. One distinction is between byte-oriented I/O, which is handled by input and output streams,

and character-I/O, which is handled by readers and writers. Another distinction is between the old-style stream-

based I/O and the new-style channel- and buffer-based I/O. These all have their place and are appropriate for

different needs and use cases. None of them should be ignored.

Java's I/O libraries

are designed in an abstract way that enables you to read from external data sources and write to

external targets, regardless of the kind of thing you're writing to or reading from. You use the same methods to read

from a file that you do to read from the console or from a network connection. You use the same methods to write

to a file that you do to write to a byte array or a serial port device.

Reading and writing without caring where your data is coming from or where it's going is a very powerful abstraction.

Among other things, this enables you to define I/O streams that automatically compress, encrypt, and filter from one

data format to another. Once you have these tools, programs can send encrypted data or write zip files with almost

no knowledge of what they're doing. Cryptography or compression can be isolated in a few lines of code that say,

"Oh yes, make this a compressed, encrypted output stream."

In this book, I'll take a thorough look at all parts of Java's I/O facilities. This includes all the different kinds of

streams you can use and the channels and buffers that offer high-

performance, high

-throughput, nonblocking

operations on servers. We're also going to investigate Java's support for Unicode. We'll look at Java's powerful

facilities for formatting I/O. Finally, we'll look at the various APIs Java provides for low-level I/O through various

devices including serial ports, parallel ports, USB, Bluetooth, and other hardware you'll find in devices that don't

necessarily look like a traditional desktop computer or server.

I won't go so far as to say, "If you've always found I/O boring, this is the book for you!" I will say that if you do find

I/O uninteresting, you probably don't know as much about it as you should. I/O is the means for communication

between software and the outside world. Java provides a powerful and flexible set of tools for doing this crucial part

of the job. Having said that, let's start with the basics.

Page 17

1.1. What Is a Stream?

A stream is an ordered sequence of bytes of indeterminate length. Input streams move bytes of data into a Java

program from some generally external source. Output streams move bytes of data from Java to some generally

external target. (In special cases, streams can also move bytes from one part of a Java program to another.)

The word stream is derived from an analogy between a sequence and a stream of water. An input stream is like a

siphon that sucks up water; an output stream is like a hose that sprays out water. Siphons can be connected to

hoses to move water from one place to another. Sometimes a siphon may run out of water if it's drawing from a

finite source like a bucket. On the other hand, if the siphon is drawing water from a river, it may well operate

indefinitely. So, too, an input stream may read from a finite source of bytes such as a file or an unlimited source of

bytes such as

System.in

. Similarly, an output stream may have a definite number of bytes to output or an indefinite

number of bytes.

Input to a Java program can come from many sources. Output can go to many different kinds of destinations. The

power of the stream metaphor is that the differences between these sources and destinations are abstracted away.

All input and output operations are simply treated as streams using the same classes and the same methods. You

don't need to learn a new API for every different kind of device. The same API that reads files can read network

sockets, serial ports, Bluetooth transmissions, and more.

1.1.1. Where Do Streams Come From?

The first source of input most programmers encounter is

System.in

. This is the same thing as

stdin

in Cgenerally

some sort of console window, probably the one in which the Java program was launched. If input is redirected so the

program reads from a file, then

System.in

is changed as well. For instance, on Unix, the following command redirects

stdin

so that when the

MessageServer

program reads from

System.in

, the actual data comes from the file data.txt

instead of from the console:

% java MessageServer < data.txt

The console is also available for output through the static field

out

in the

java.lang.System

class, that is,

System.out

. This is equivalent to

stdout

in C parlance and may be redirected in a similar fashion. Finally,

stderr

available as

System.err

. This is most commonly used for debugging and printing error messages from inside

catch

clauses. For example:

try {

//... do something that might throw an exception

}

catch (Exception ex) {

System.err.println(ex);

}

Both

System.out

and

System.err

are print streamsthat is, instances of

java.io.PrintStream

. These will be discussed in

detail in Chapter 7.

Files are another common source of input and destination for output. File input streams provide a stream of data

that starts with the first byte in a file and finishes with the last byte in that file. File output streams write data into

a file, either by erasing the file's contents and starting from the beginning or by appending data to the file. These

will be introduced in Chapter 4.

Network connections provide streams too. When you connect to a web server, FTP server, or some other kind of

server, you read the data it sends from an input stream connected from that server and write data onto an output

stream connected to that server. These streams will be introduced in Chapter 5.

Java programs themselves produce streams. Byte array input streams, byte array output streams, piped input

streams, and piped output streams all move data from one part of a Java program to another. Most of these are

introduced in Chapter 9.

Perhaps a little surprisingly, GUI components like

TextArea

and

JTextArea

do not produce streams. The issue here is

ordering. A group of bytes provided as data for a stream must have a fixed order. However, users can change the

contents of a text area or a text field at any point, not just at the end. Furthermore, they can delete text from the

Page 18

middle of a stream while a different thread is reading that data. Hence, streams aren't a good metaphor for reading

data from GUI components. You can, however, use the strings they do produce to create a byte array input stream

or a string reader.

1.1.2. The Stream Classes

Most of the classes that work directly with streams are part of the

java.io

package. The two main classes are

java.io.InputStream

and

java.io.OutputStream

. These are abstract base classes for many different subclasses with

more specialized abilities.

The subclasses include:

BufferedInputStream

BufferedOutputStream

ByteArrayInputStream

ByteArrayOutputStream

DataInputStream

DataOutputStream

FileInputStream

FileOutputStream

FilterInputStream

FilterOutputStream

ObjectInputStream

ObjectOutputStream

PipedInputStream

PipedOutputStream

PrintStream

PushbackInputStream

SequenceInputStream

The

java.util.zip

package contains four input stream classes that read data in compressed format and return it in

uncompressed format and four output stream classes that read data in uncompressed format and write in

compressed format. These will be discussed in Chapter 10.

CheckedInputStream

CheckedOutputStream

DeflaterOutputStream

GZIPInputStream

GZIPOutputStream

InflaterInputStream

ZipInputStream

ZipOutputStream

The

java.util.jar

package includes two stream classes for reading files from JAR archives. These will be discussed

Chapter 11.

JarInputStream

JarOutputStream

The

java.security

package includes a couple of stream classes used for calculating message digests:

DigestInputStream

DigestOutputStream

The Java Cryptography Extension (JCE) adds two classes for encryption and decryption:

CipherInputStream

CipherOutputStream

These four streams will be discussed in Chapter 12.

Finally, a few random stream classes are hiding inside the

sun

packagesfor example,

sun.net.TelnetInputStream

and

sun.net.TelnetOutputStream

. However, these are deliberately hidden from you and are generally presented as

instances of

java.io.InputStream

java.io.OutputStream

only.

Page 19

1.2. Numeric Data

Input streams read bytes and output streams write bytes. Readers read characters and writers write characters.

Therefore, to understand input and output, you first need a solid understanding of how Java deals with bytes,

integers, characters, and other primitive data types, and when and why one is converted into another. In many

cases Java's behavior is not obvious.

1.2.1. Integer Data

The fundamental integer data type in Java is the

int

, a 4-byte, big-endian, two's complement integer. An

int

can

take on all values between -2,147,483,648 and 2,147,483,647. When you type a literal integer such as 7, -

8345, or

3000000000 in Java source code, the compiler treats that literal as an

int

. In the case of 3000000000 or similar

numbers too large to fit in an

int

, the compiler emits an error message citing "Numeric overflow."

long

s are 8-byte, big-endian, two's complement integers that range all the way from -

9,223,372,036,854,775,808

to 9,223,372,036,854,775,807.

long

literals are indicated by suffixing the number with a lower- or uppercase

. An

uppercase

is preferred because the lowercase

is too easily confused with the numeral 1 in most fonts. For

example, 7L,

8345L, and 3000000000L are all 64

-bit

long

literals.

Two more integer data types are available in Java, the

short

and the

byte

shorts

are 2-byte, big-endian, two's

complement integers with ranges from

-32,768 to 32,767. They're rarely used in Java and are included mainly for

compatibility with C.

bytes

, however, are very much used in Java. In particular, they're used in I/O. A

byte

is an 8-bit, two's complement

integer that ranges from -128 to 127. Note that like all numeric data types in Java, a

byte

is signed. The maximum

byte

value is 127. 128, 129, and so on through 255 are not legal values for bytes.

Java has no

short

byte

literals. When you write the literal 42 or 24000, the compiler always reads it as an

int

never as a

byte

or a

short

, even when used in the right-hand side of an assignment statement to a

byte

short

like this:

byte b = 42;

short s = 24000;

However, in these lines, a special assignment conversion is performed by the compiler, effectively casting the

int

literals to the narrower types. Because the

int

literals are constants known at compile time, this is permitted.

However, assignments from

int

variables to

short

s and

byte

s are notat least not without an explicit cast. For

example, consider these lines:

int i = 42;

byte b = i;

Compiling these lines produces the following errors:

Error: Incompatible type for declaration.

Explicit cast needed to convert int to short.

ByteTest.java line 6

This occurs even though the compiler is theoretically capable of determining that the assignment does not lose

information. To correct this, you must use explicit casts, like this:

int i = 42;

byte b = (byte) i;

Even the addition of two

byte

variables produces an integer result and thus cannot be assigned to a

byte

variable

without a cast. The following code produces the same error:

byte b1 = 22;

Page 20

剩余663页未读，继续阅读

yupeng_yanjie_1314

粉丝: 1
资源: 10

深入理解Java IO：第二版

java io 2nd

JavaIO 2nd Edition PDF

如何学习javaio流

java io流能做什么业务

java io流面试题

java io 和nio_java对比IO和NIO的文件读写性能测试

JAVA IO 与 NIO 理解

Javaio读取视频

Java io流是什么

java io serializable 和kryoSerializable

最新资源