Core Java Volume II - Advanced Features 9th Edition 深入探讨

4星 · 超过85%的资源需积分: 9 120 浏览量更新于2024-07-25 5 收藏 69.09MB PDF 举报

"Core Java Volume II--Advanced Feature 9th Edition.pdf" 《Core Java Volume II—Advanced Features》是Cay S. Horstmann和Gary Cornell合著的第九版书籍，主要针对Java的高级特性进行深入探讨。这本书对于Java开发者来说是一份重要的学习资料，尤其适合已经掌握了Java基础并希望提升到更高层次的读者。本书涵盖了以下核心Java的高级主题： 1. **多线程编程**：Java以其强大的多线程支持而闻名。书中会详细介绍如何创建和管理线程，包括线程同步、锁机制（如synchronized关键字、java.util.concurrent包中的工具）以及线程池的使用。 2. **网络编程**：Java提供了丰富的API来处理网络通信，包括Socket编程、ServerSocket、HTTP和HTTPS协议的实现，以及NIO（非阻塞I/O）的使用，这些都是构建分布式系统的关键部分。 3. **高级GUI编程**：Java Swing和JavaFX是两个主要的图形用户界面库，书中会讲解如何创建复杂的桌面应用，包括组件布局管理、事件处理、动画和可定制的外观与风格。 4. **集合框架**：深入讲解Java集合框架，包括List、Set、Map接口的实现类，以及高级数据结构如TreeMap、ConcurrentHashMap和LinkedBlockingQueue等。此外，还会讨论泛型、迭代器和流API的使用。 5. **反射和注解**：反射允许程序在运行时检查和修改自身的行为，注解则为元数据提供了一种方式，使得编译器和运行时系统可以自动处理代码。这两者是Java的强大力量，常用于框架开发和元编程。 6. **序列化**：Java的序列化机制允许对象的状态被持久化到磁盘或在网络上传输。书中会介绍如何实现Serializable接口，处理序列化过程中的问题，以及使用ObjectInputStream和ObjectOutputStream。 7. **异常处理**：Java的异常处理机制有助于程序的健壮性，书中会讨论如何正确地使用try-catch-finally语句，以及自定义异常的创建。 8. **模块系统**：Java 9引入了模块系统，改善了大型应用的组织和封装。这部分内容将解释如何设计和使用模块，并解决模块间的依赖问题。 9. **JVM优化**：书中会探讨如何理解和调整Java虚拟机（JVM）参数，以提高应用程序的性能。 10. **测试和调试**：涵盖JUnit测试框架的使用，以及如何利用调试工具（如JDB和VisualVM）来诊断和修复代码问题。《Core Java Volume II—Advanced Features》第九版是Java开发者的宝贵资源，它不仅介绍了Java的高级特性和最佳实践，还提供了大量示例代码帮助读者理解和应用这些概念。对于想要深化Java技能的开发者来说，这是一本不可多得的参考书籍。

1.1. To read and write strings and numbers, you need more capable subclasses. For example, DataInputStream and

DataOutputStream let you read and write all the primitive Java types in binary format. Finally, there are

streams that do useful stuff; for example, the ZipInputStream and ZipOutputStream let you read and write files

in the familiar ZIP compression format.

Figure 1.1. Input and output stream hierarchy

For Unicode text, on the other hand, you can use subclasses of the abstract classes Reader and Writer (see

Figure 1.2). The basic methods of the Reader and Writer classes are similar to those for InputStream and

OutputStream.

flushes this Flushable.

java.lang.Readable 5.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.Appendable 5.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.CharSequence 1.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 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

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

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.

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 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 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 din = new DataInputStream(

pbin = 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 image

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

DataInputStream din = new DataInputStream(zin);

剩余1618页未读，继续阅读

SEALS

粉丝: 9
资源: 43

Core Java Volume II - Advanced Features 9th Edition 深入探讨

Prentice.Hall.Core.Java.Volume.II.Advanced.Features.10th.Edition.2017

Core.Java.Volume.II.Advanced.Features.10th.Edition.2016.12.pdf

Prentice.Hall.Core.Java.Volume.II.Advanced.Features.11th.Edition.0135166314.rar

Prentice.Hall.Core.Java.Volume.II.Advanced.Features.11th.Edition.2019（非草稿）

Core.Java.2.Volume.II.Advanced.Features.7th.Edition

Core Java(Volume II--Advanced Features 9th Edition).pdf

Prentice.Hall.Core.Java.Volume.II.Advanced.Features.8th.Edition.Apr.2008.chm

Core Java, Volume II--Advanced Features (9th Edition).pdf

Core.Java.Volume.II.Advanced.Features.10th.Edition

Prentice.Hall.Core.Java.Volume.II.Advanced.Features.8th.Edition.Apr.2008.part2.rar

最新资源