Core Java 9 Vol. 2英文版高级特性PDF教程

5星 · 超过95%的资源需积分: 10 150 浏览量更新于2024-07-24 1 收藏 51.89MB PDF 举报

"Core Java 9 Volume II - Advanced Features, Ninth Edition" 是由Cay S. Horstmann和Gary Cornell合著的一本专业IT书籍，它是《Core Java》系列的一部分，专注于Java 9的高级特性。这本书是英文版，面向已经对Java基础知识有一定了解的读者，深入探讨了Java语言的复杂概念和技术。在第九版中，作者们可能覆盖了Java 9的新特性，如模块化系统（Module System）、Lambda表达式、流(Streams)的进一步应用、方法引用(Method References)、接口的默认方法(Defaults Methods in Interfaces)、以及Java平台标准版(JDK)的改进等。这些内容旨在帮助开发者提升编程效率，理解和掌握现代Java开发的最佳实践。书中还强调了版权和商标的重要性，指出Oracle和Java是Oracle公司及其关联公司的注册商标，而其他名称可能属于各自的版权所有者。这体现了作者尊重知识产权的态度，同时也提醒读者在学习过程中遵循相应规范。尽管本书精心编排，但作者和出版商并不承担任何形式的明确或隐含的保修责任，并且不为因使用书中的信息或程序导致的偶然或间接损害承担责任。该书主要作为信息资源提供，其内容受版权保护，仅供学习和参考使用。对于想要深入学习Java 9高级特性的程序员、软件工程师或技术领导者而言，这本书是一本不可或缺的参考资料，它不仅涵盖了理论知识，还提供了实际应用的案例和示例，帮助读者在实践中熟练掌握Java 9的技术革新。通过阅读和实践书中的内容，开发者可以提升自己的编程技能，紧跟Java技术的发展潮流。

Figure 1.2. Reader and writer hierarchyFigure 1.2. Reader and writer hierarchy

abstract int read()

abstract void write(int c)

The read method returns either a Unicode code unit (as an integer between 0 and 65535) or -1 when you have reached the end

of the file. The write method is called with a Unicode code unit. (See Volume I, Chapter 3 for a discussion of Unicode code

units.)

There are four additional interfaces: Closeable, Flushable, Readable, and Appendable (see Figure 1.3). The first two

interfaces are very simple, with methods

void close() throws IOException

and

void flush()

PDF by Landray transform

Figure 1.3. The Figure 1.3. The CloseableCloseable, , FlushableFlushable, , ReadableReadable, and , and AppendableAppendable interfaces interfaces

respectively. The classes InputStream, OutputStream, Reader, and Writer all implement the Closeable interface.

Note Note

The java.io.Closeable interface extends the java.lang.AutoCloseable interface. Therefore, you can use the

try-with-resources statement with any Closeable. Why have two interfaces? The close method of the Closeable

interface only throws an IOException, whereas the AutoCloseable.close method may throw any exception.

OutputStream and Writer implement the Flushable interface.

The Readable interface has a single method

int read(CharBuffer cb)

The CharBuffer class has methods for sequential and random read/write access. It represents an in-memory buffer or a

memory-mapped file. (See Section 1.7.1, “The Buffer Data Structure,” on p. 77 for details.)

The Appendable interface has two methods for appending single characters and character sequences:

Appendable append(char c)

Appendable append(CharSequence s)

The CharSequence interface describes basic properties of a sequence of char values. It is implemented by String,

CharBuffer, StringBuilder, and StringBuffer.

Of the stream zoo classes, only Writer implements Appendable.

java.io.Closeablejava.io.Closeable

5.05.0

• void close()

closes this Closeable. This method may throw an IOException.

java.io.Flushablejava.io.Flushable

5.05.0

• void flush()

flushes this Flushable.

java.lang.Readablejava.lang.Readable

5.05.0

• int read(CharBuffer cb)

attempts to read as many char values into cb as it can hold. Returns the number of values read, or -1 if no

further values are available from this Readable.

java.lang.Appendablejava.lang.Appendable

5.05.0

• Appendable append(char c)

• Appendable append(CharSequence cs)

appends the given code unit, or all code units in the given sequence, to this Appendable; returns this.

java.lang.CharSequencejava.lang.CharSequence

1.41.4

• char charAt(int index)

returns the code unit at the given index.

• int length()

returns the number of code units in this sequence.

• CharSequence subSequence(int startIndex, int endIndex)

returns a CharSequence consisting of the code units stored at index startIndex to endIndex - 1.

• String toString()

returns a string consisting of the code units of this sequence.

1.1.3. Combining Stream Filters1.1.3. Combining Stream Filters

FileInputStream and FileOutputStream give you input and output streams attached to a disk file. You need to pass the

file name or full path name of the file to the constructor. For example,

FileInputStream fin = new FileInputStream("employee.dat");

looks in the user directory for a file named employee.dat.

Tip Tip

All the classes in java.io interpret relative path names as starting from the user’s working directory. You can get

this directory by a call to System.getProperty("user.dir").

Caution Caution

Since the backslash character is the escape character in Java strings, be sure to use \\ for Windows-style path names

(for example, C:\\Windows\\win.ini). In Windows, you can also use a single forward slash (C:/Windows/win.ini)

because most Windows file-handling system calls will interpret forward slashes as file separators. However, this is

not recommended—the behavior of the Windows system functions is subject to change. Instead, for portable programs,

use the file separator character for the platform on which your program runs. It is available as the constant string

java.io.File.separator.

PDF by Landray transform

Like the abstract InputStream and OutputStream classes, these classes support only reading and writing at the byte

level. That is, we can only read bytes and byte arrays from the object fin.

byte b = (byte) fin.read();

As you will see in the next section, if we just had a DataInputStream, we could read numeric types:

DataInputStream din = . . .;

double s = din.readDouble();

But just as the FileInputStream has no methods to read numeric types, the DataInputStream has no method to get data

from a file.

Java uses a clever mechanism to separate two kinds of responsibilities. Some streams (such as the FileInputStream and the

input stream returned by the openStream method of the URL class) can retrieve bytes from files and other more exotic

locations. Other streams (such as the DataInputStream and the PrintWriter) can assemble bytes into more useful data

types. The Java programmer has to combine the two. For example, to be able to read numbers from a file, first create a

FileInputStream and then pass it to the constructor of a DataInputStream.

Click here to view code imageClick here to view code image

FileInputStream fin = new FileInputStream("employee.dat");

DataInputStream din = new DataInputStream(fin);

double s = din.readDouble();

If you look at Figure 1.1 again, you can see the classes FilterInputStream and FilterOutputStream. The subclasses of

these classes are used to add capabilities to raw byte streams.

You can add multiple capabilities by nesting the filters. For example, by default streams are not buffered. That is, every

call to read asks the operating system to dole out yet another byte. It is more efficient to request blocks of data instead

and store them in a buffer. If you want buffering

and

the data input methods for a file, you need to use the following rather

monstrous sequence of constructors:

DataInputStream din = new DataInputStream(

new BufferedInputStream(

new FileInputStream("employee.dat")));

Notice that we put the DataInputStream

last

in the chain of constructors because we want to use the DataInputStream

methods, and we want

them

to use the buffered read method.

Sometimes you’ll need to keep track of the intermediate streams when chaining them together. For example, when reading

input, you often need to peek at the next byte to see if it is the value that you expect. Java provides the

PushbackInputStream for this purpose.

Click here to view code imageClick here to view code image

PushbackInputStream pbin = new PushbackInputStream(

new BufferedInputStream(

new FileInputStream("employee.dat")));

Now you can speculatively read the next byte

int b = pbin.read();

and throw it back if it isn’t what you wanted.

if (b != '<') pbin.unread(b);

However, reading and unreading are the

only

methods that apply to a pushback input stream. If you want to look ahead and also

read numbers, then you need both a pushback input stream and a data input stream reference.

DataInputStream dindin = new DataInputStream(

pbinpbin = new PushbackInputStream(

new BufferedInputStream(

new FileInputStream("employee.dat"))));

Of course, in the stream libraries of other programming languages, niceties such as buffering and lookahead are automatically

taken care of, so it is a bit of a hassle to resort, in Java, to combining stream filters. However, the ability to mix and

match filter classes to construct truly useful sequences of streams does give you an immense amount of flexibility. For

example, you can read numbers from a compressed ZIP file by using the following sequence of streams (see Figure 1.4):

Click here to view code imageClick here to view code image

ZipInputStream zin = new ZipInputStream(new FileInputStream("employee.zip"));

DataInputStream din = new DataInputStream(zin);

PDF by Landray transform

Figure 1.4. A sequence of filtered streamsFigure 1.4. A sequence of filtered streams

(See Section 1.4, “ZIP Archives,” on p. 33 for more on Java’s handling of ZIP files.)

java.io.FileInputStreamjava.io.FileInputStream 1.01.0

• FileInputStream(String name)

• FileInputStream(File file)

creates a new file input stream using the file whose path name is specified by the name string or the file object.

(The File class is described at the end of this chapter.) Path names that are not absolute are resolved relative to

the working directory that was set when the VM started.

java.io.FileOutputStreamjava.io.FileOutputStream 1.01.0

• FileOutputStream(String name)

• FileOutputStream(String name, boolean append)

• FileOutputStream(File file)

• FileOutputStream(File file, boolean append)

creates a new file output stream specified by the name string or the file object. (The File class is described at

the end of this chapter.) If the append parameter is true, an existing file with the same name will not be

deleted and data will be added at the end of the file. Otherwise, this method deletes any existing file with the

same name.

java.io.BufferedInputStreamjava.io.BufferedInputStream 1.01.0

• BufferedInputStream(InputStream in)

creates a buffered stream. A buffered input stream reads bytes from a stream without causing a device access every

time. When the buffer is empty, a new block of data is read into the buffer.

java.io.BufferedOutputStreamjava.io.BufferedOutputStream 1.01.0

• BufferedOutputStream(OutputStream out)

creates a buffered stream. A buffered output stream collects bytes to be written without causing a device access

every time. When the buffer fills up or when the stream is flushed, the data are written.

java.io.PushbackInputStreamjava.io.PushbackInputStream 1.01.0

• PushbackInputStream(InputStream in)

• PushbackInputStream(InputStream in, int size)

constructs a stream with one-byte lookahead or a pushback buffer of specified size.

• void unread(int b)

pushes back a byte, which is retrieved again by the next call to read.

Parameters:

b The byte to be read again

1.2. Text Input and Output1.2. Text Input and Output

When saving data, you have the choice between binary and text formats. For example, if the integer 1234 is saved in binary,

it is written as the sequence of bytes 00 00 04 D2 (in hexadecimal notation). In text format, it is saved as the string

"1234". Although binary I/O is fast and efficient, it is not easily readable by humans. We first discuss text I/O and cover

binary I/O in Section 1.3, “Reading and Writing Binary Data,” on p. 25.

When saving text strings, you need to consider the

character encoding

. In the UTF-16 encoding, the string "1234" is encoded

as 00 31 00 32 00 33 00 34 (in hex). However, many programs expect that text files are encoded in a different encoding.

PDF by Landray transform

In ISO 8859-1, the encoding most commonly used in the United States and Western Europe, the string would be written as 31

32 33 34, without the zero bytes.

The OutputStreamWriter class turns a stream of Unicode code units into a stream of bytes, using a chosen character

encoding. Conversely, the InputStreamReader class turns an input stream that contains bytes (specifying characters in

some character encoding) into a reader that emits Unicode code units.

For example, here is how you make an input reader that reads keystrokes from the console and converts them to Unicode:

InputStreamReader in = new InputStreamReader(System.in);

This input stream reader assumes the default character encoding used by the host system, such as the ISO 8859-1 encoding in

Western Europe. You can choose a different encoding by specifying it in the constructor for the InputStreamReader, for

example:

InputStreamReader in = new InputStreamReader(new FileInputStream("kremlin.dat"), "ISO8859_5");

See Section 1.2.4, “Character Sets,” on p. 20 for more information on character encodings.

1.2.1. How to Write Text Output1.2.1. How to Write Text Output

For text output, use a PrintWriter. That class has methods to print strings and numbers in text format. There is even a

convenience constructor to link a PrintWriter to a FileWriter. The statement

PrintWriter out = new PrintWriter("employee.txt");

is equivalent to

PrintWriter out = new PrintWriter(new FileWriter("employee.txt"));

To write to a print writer, use the same print, println, and printf methods that you used with System.out. You can use

these methods to print numbers (int, short, long, float, double), characters, boolean values, strings, and objects.

For example, consider this code:

String name = "Harry Hacker";

double salary = 75000;

out.print(name);

out.print(' ');

out.println(salary);

This writes the characters

Harry Hacker 75000.0

to the writer out. The characters are then converted to bytes and end up in the file employee.txt.

The println method adds the correct end-of-line character for the target system ("\r\n" on Windows, "\n" on UNIX) to the

line. This is the string obtained by the call System.getProperty("line.separator").

If the writer is set to

autoflush mode

, all characters in the buffer are sent to their destination whenever println is

called. (Print writers are always buffered.) By default, autoflushing is

not

enabled. You can enable or disable autoflushing

by using the PrintWriter(Writer out, boolean autoFlush) constructor:

PrintWriter out = new PrintWriter(new FileWriter("employee.txt"), true); // autoflush

The print methods don’t throw exceptions. You can call the checkError method to see if something went wrong with the

stream.

Note Note

Java veterans might wonder whatever happened to the PrintStream class and to System.out. In Java 1.0, the

PrintStream class simply truncated all Unicode characters to ASCII characters by dropping the top byte. (At the

time, Unicode was still a 16-bit encoding.) Clearly, that was not a clean or portable approach, and it was fixed with

the introduction of readers and writers in Java 1.1. For compatibility with existing code, System.in, System.out,

and System.err are still streams, not readers and writers. But now the PrintStream class internally converts

Unicode characters to the default host encoding in the same way as the PrintWriter does. Objects of type

PrintStream act exactly like print writers when you use the print and println methods, but unlike print writers

they allow you to output raw bytes with the write(int) and write(byte[]) methods.

PDF by Landray transform

剩余1400页未读，继续阅读

潜伏在伤口

粉丝: 2
资源: 5

Core Java 9 Vol. 2英文版高级特性PDF教程

core java2 volumn II 5e java2核心编程第5版卷II 高级特性

Core Java 2 (Volumn 1 + Volumn 2) 英文版 chm格式

Core Java 9th Vol.1

Dreaming in Code Volumn 2

Think in C++ Volumn 2双页印刷

DB2 development CLI volumn 1

performance volumn

DB2 v9.7 development CLI volumn 1

Core Java 2 Volume I 7th Edithon 中文版part1

Core Java 学习笔记

最新资源