Core Java 9版高级特性详解：Horstmann与Cornell合著

需积分: 9 19 浏览量更新于2024-07-20 收藏 16.28MB PDF 举报

《Core Java 9th edition》是关于高级特性的CoreJava系列的第九版，由Cay S. Horstmann和Gary Cornell共同编著。本书面向Java专业开发者，深入探讨了Java语言的高级功能，旨在帮助读者提升Java编程技能，理解并掌握面向对象编程、并发编程、泛型、集合框架、I/O流、网络编程等复杂主题。该版本于2015年1月9日在中国北京出版，特别强调了商标使用规范，指出Oracle和Java是Oracle公司及其关联公司的注册商标，而书中提到的其他名称可能是其所有者的商标。作者和出版社在编写过程中已尽职尽责，但明确声明不提供任何形式的明示或默示担保，对由于使用书中的信息或程序可能带来的偶然或间接损害不负责任。本书内容涵盖了广泛的高级Java特性，例如： 1. 面向对象编程：深入讲解类、对象、继承、多态和接口的概念，以及如何设计和实现高效、可扩展的软件结构。 2. 并发编程：讨论了Java并发API（如Thread类、synchronized关键字、Executor框架和并发集合），以及如何利用多线程技术优化性能，处理并发问题。 3. 泛型：介绍类型参数化和类型擦除的概念，以及如何编写安全、可重用的代码，避免类型相关的运行时错误。 4. 集合框架：剖析ArrayList、LinkedList、HashMap、TreeMap等常用数据结构的内部工作原理，以及如何根据具体需求选择和操作集合。 5. I/O流：讲解输入/输出流的使用，包括标准输入/输出流、文件流、字符流、字节流，以及如何处理数据的读写操作。 6. 网络编程：介绍Socket编程和网络通信的基本原理，以及Java提供的NIO (Non-blocking Input/Output) API，以提高网络应用的性能。 7. 性能优化与调试：讨论内存管理、性能分析工具和调试技巧，帮助开发者提升应用程序的效率。 8. 最新技术和实践：鉴于Java语言的不断发展，书中还可能包含Java 9及后续版本的新特性介绍，如Lambda表达式、Stream API、模块化系统等。《Core Java 9th edition》不仅是一本技术指南，也是Java程序员的参考手册，适合有一定基础的开发者深入学习和实践，提升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

剩余701页未读，继续阅读

jane2016

粉丝: 1
资源: 1

Core Java 9版高级特性详解：Horstmann与Cornell合著

Java核心技术英文第九版，Core Java 9th Edition，带源码

Core Java (9th Edition)

Core Java(Volume I--Fundamentals 9th Edition)

java编程思想 文献_JAVA编程思想英文参考文献和翻译

No implementation found for long org.opencv.core.Mat.n_Mat(int, int, int) (tried Java_org_opencv_core_Mat_n_1Mat and Java_org_opencv_core_Mat_n_1Mat__III)

java 外文参考文献_java英文参考文献

java集成rosjava_core的maven依赖

2021年至2023年出版的Java类书籍

java条形码识别_java openCV 识别条形码

java opencv图片匹配_Java+opencv3.2.0实现模板匹配

最新资源

java编程思想文献_JAVA编程思想英文参考文献和翻译