Java编程实战指南

5星 · 超过95%的资源需积分: 9 28 浏览量更新于2024-07-23 收藏 14.11MB PDF 举报

"这是一本由Ian F. Darwin编写的《Java Cookbook》第三版，由Rejmi Net Group, Inc.版权所有。这本书由O'Reilly Media, Inc.出版，旨在为教育、商业或销售推广提供Java编程的实用指南。在线版本也可在大多数标题的Safari Books Online上找到。" 《Java Cookbook》是Java程序员的一本实用参考书，由Ian F. Darwin撰写。这本书主要面向已经有一定Java编程基础的开发者，提供了大量解决常见问题的代码示例和解决方案。书中涵盖了多个Java开发中的关键领域，包括但不限于： 1. **基础语法**：解释了Java的基本语法特性，如变量声明、数据类型、流程控制语句（if、switch、循环等）以及异常处理。 2. **类与对象**：深入探讨了面向对象编程的核心概念，如类的创建、继承、多态性，以及接口和抽象类的使用。 3. **集合框架**：详细介绍了Java集合框架，包括List、Set、Map接口的实现类，如ArrayList、LinkedList、HashSet、HashMap等，并讨论了它们的使用场景和性能差异。 4. **泛型**：阐述了泛型的使用，如何创建泛型类、泛型方法，以及通配符的运用，以提高代码的类型安全性和重用性。 5. **I/O流**：讲解了输入输出流的处理，包括文件操作、网络通信、对象序列化等，涵盖了InputStream、OutputStream、Reader、Writer等类的使用。 6. **多线程**：介绍了并发编程的概念，如线程的创建、同步机制（synchronized关键字、Lock接口）、并发工具类（如ExecutorService、Semaphore、CountDownLatch等）。 7. **反射与注解**：探讨了Java的反射机制，如何在运行时动态访问和修改类、接口、字段和方法，以及注解的使用和自定义注解的实现。 8. **XML与JSON处理**：涵盖了解析和生成XML文档的DOM、SAX、StAX方法，以及JSON对象的处理，如使用Jackson或Gson库进行JSON序列化和反序列化。 9. **网络编程**：讲解了套接字编程，包括TCP和UDP通信，以及HTTP客户端和服务器的实现。 10. **数据库访问**：介绍了JDBC的使用，如何连接数据库、执行SQL语句、处理结果集，以及事务管理。此外，这本书还涵盖了错误处理、调试技巧、性能优化等方面的内容。每个章节都提供了具体的问题实例和解决方案，帮助读者在实际开发中快速查找并解决问题。通过学习《Java Cookbook》，开发者能够提升工作效率，编写出更高效、更健壮的Java代码。

1. Editor’s note: the “other Oak” that triggered this renaming was not a computer language, as is sometimes

supposed, but Oak Technology, makers of video cards and the cdrom.sys file that was on every DOS/Windows

PC at one point.

2. One of the world’s leading high-tech, vendor-independent training companies; see http://www.learning

tree.com/.

Java (O’Reilly) or Learning Java (O’Reilly) if you’re new to this family of languages, or

Java in a Nutshell (O’Reilly) if you’re an experienced C programmer.

I started programming in C in 1980 while working at the University of Toronto, and C

served me quite well through the 1980s and into the 1990s. In 1995, as the nascent

language Oak was being renamed Java, I had the good fortune of being told about it by

my colleague J. Greg Davidson. I sent an email to the address Greg provided, and got

this mail back from James Gosling, Java’s inventor, in March 1995:

| Hi. A friend told me about WebRunner(?), your extensible network

| browser. It and Oak(?) its extension language, sounded neat. Can

| you please tell me if it's available for play yet, and/or if any

| papers on it are available for FTP?

Check out http://java.sun.com

(oak got renamed to java and webrunner got renamed to

hotjava to keep the lawyers happy)

So Oak became Java

before I could get started with it. I downloaded HotJava and began

to play with it. At first I wasn’t sure about this newfangled language, which looked like

a mangled C/C++. I wrote test and demo programs, sticking them a few at a time into

a directory that I called javasrc to keep it separate from my C source (because often the

programs would have the same name). And as I learned more about Java, I began to see

its advantages for many kinds of work, such as the automatic memory reclaim (“garbage

collection”) and the elimination of pointer calculations. The javasrc directory kept

growing. I wrote a Java course for Learning Tree,

and the directory grew faster, reaching

the point where it needed subdirectories. Even then, it became increasingly difficult to

find things, and it soon became evident that some kind of documentation was needed.

In a sense, this book is the result of a high-speed collision between my javasrc directory

and a documentation framework established for another newcomer language. In O’Reil‐

ly’s Perl Cookbook, Tom Christiansen and Nathan Torkington worked out a very suc‐

cessful design, presenting the material in small, focused articles called “recipes,” for the

then-new Perl language. The original model for such a book is, of course, the familiar

kitchen cookbook. Using the term “cookbook” to refer to an enumeration of how-to

recipes relating to computers has a long history. On the software side, Donald Knuth

applied the “cookbook” analogy to his book The Art of Computer Programming

(Addison-Wesley), first published in 1968. On the hardware side, Don Lancaster wrote

The TTL Cookbook (Sams). (Transistor-transistor logic, or TTL, was the small-scale

building block of electronic circuits at the time.) Tom and Nathan worked out a

xiv | Preface

3. Well, not completely. See the Java Puzzlers books by Joshua Bloch and Neal Gafter for the actual quirks.

successful variation on this, and I recommend their book for anyone who wishes to, as

they put it, “learn more Perl.” Indeed, the work you are now reading strives to be the

book for the person who wishes to “learn more Java.”

The code in each recipe is intended to be largely self-contained; feel free to borrow bits

and pieces of any of it for use in your own projects. The code is distributed with a

Berkeley-style copyright, just to discourage wholesale reproduction.

Who This Book Is For

I’m going to assume that you know the basics of Java. I won’t tell you how to println a

string and a number at the same time, or how to write a class that extends JFrame and

prints your name in the window. I’ll presume you’ve taken a Java course or studied an

introductory book such as Head First Java, Learning Java, or Java in a Nutshell (O’Reil‐

ly). However, Chapter 1 covers some techniques that you might not know very well and

that are necessary to understand some of the later material. Feel free to skip around!

Both the printed version of the book and the electronic copy are heavily cross-

referenced.

What’s in This Book?

Unlike my Perl colleagues Tom and Nathan, I don’t have to spend as much time on the

oddities and idioms of the language; Java is refreshingly free of strange quirks.

But that

doesn’t mean it’s trivial to learn well! If it were, there’d be no need for this book. My

main approach, then, is to concentrate on the Java APIs. I’ll teach you by example what

the important APIs are and what they are good for.

Like Perl, Java is a language that grows on you and with you. And, I confess, I use Java

most of the time nowadays. Things I once did in C—except for device drivers and legacy

systems—I now do in Java.

Java is suited to a different range of tasks than Perl, however. Perl (and other scripting

languages, such as awk and Python) is particularly suited to the “one-liner” utility task.

As Tom and Nathan show, Perl excels at things like printing the 42nd line from a file.

Although Java can certainly do these things, it seems more suited to “development in

the large,” or enterprise applications development, because it is a compiled, object-

oriented language. Indeed, much of the API material added in Java 2 was aimed at this

type of development. However, I will necessarily illustrate many techniques with shorter

examples and even code fragments. Be assured that every fragment of code you see here

(except for some one- or two-liners) has been compiled and run.

Preface | xv

Some of the longer examples in this book are tools that I originally wrote to automate

some mundane task or another. For example, a tool called MkIndex (in the javasrc

repository) reads the top-level directory of the place where I keep all my Java example

source code and builds a browser-friendly index.html file for that directory. For another

example, the body of the first edition was partly composed in XML (see Chapter 20); I

used XML to type in and mark up the original text of some of the chapters of this book,

and text was then converted to the publishing software format by the XmlForm program.

This program also handled—by use of another program, GetMark—full and partial code

insertions from the javasrc directory into the book manuscript. XmlForm is discussed in

Chapter 20.

Organization of This Book

Let’s go over the organization of this book. I start off Chapter 1, Getting Started: Compil‐

ing, Running, and Debugging by describing some methods of compiling your program

on different platforms, running them in different environments (browser, command

line, windowed desktop), and debugging.

Chapter 2, Interacting with the Environment moves from compiling and running your

program to getting it to adapt to the surrounding countryside—the other programs that

live in your computer.

The next few chapters deal with basic APIs. Chapter 3, Strings and Things concentrates

on one of the most basic but powerful data types in Java, showing you how to assemble,

dissect, compare, and rearrange what you might otherwise think of as ordinary text.

Chapter 4, Pattern Matching with Regular Expressions teaches you how to use the pow‐

erful regular expressions technology from Unix in many string-matching and pattern-

matching problem domains. “Regex” processing has been standard in Java for years,

but if you don’t know how to use it, you may be “reinventing the flat tire.”

Chapter 5, Numbers deals both with built-in numeric types such as int and double, as

well as the corresponding API classes (Integer, Double, etc.) and the conversion and

testing facilities they offer. There is also brief mention of the “big number” classes.

Because Java programmers often need to deal in dates and times, both locally and in‐

ternationally, Chapter 6, Dates and Times—New API covers this important topic.

The next two chapters cover data processing. As in most languages, arrays in Java are

linear, indexed collections of similar-kind objects, as discussed in Chapter 7, Structuring

Data with Java. This chapter goes on to deal with the many “Collections” classes: pow‐

erful ways of storing quantities of objects in the java.util package, including use of

“Java Generics.”

xvi | Preface

Despite some syntactic resemblance to procedural languages such as C, Java is at heart

an object-oriented programming (OOP) language. Chapter 8, Object-Oriented Techni‐

ques discusses some of the key notions of OOP as it applies to Java, including the com‐

monly overridden methods of java.lang.Object and the important issue of design

patterns.

Java is not, and never will be, a pure “functional programming” (FP) language. However,

it is possible to use some aspects of FP, increasingly so with Java 8 and its support of

“lambda expressions” (a.k.a. “closures”). This is discussed in Chapter 9, Functional Pro‐

gramming Techniques: Functional Interfaces, Streams, Parallel Collections.

The next few chapters deal with aspects of traditional input and output. Chapter 10,

Input and Output details the rules for reading and writing files (don’t skip this if you

think files are boring; you’ll need some of this information in later chapters: you’ll read

and write on serial or parallel ports in this chapter, and on a socket-based network

connection in Chapter 13, Network Clients!). Chapter 11, Directory and Filesystem Op‐

erations shows you everything else about files—such as finding their size and last-

modified time—and about reading and modifying directories, creating temporary files,

and renaming files on disk.

Chapter 12, Media: Graphics, Audio, Video leads us into the GUI development side of

things. This chapter is a mix of the lower-level details (such as drawing graphics and

setting fonts and colors), and very high-level activities (such as controlling a video clip

or movie). In Chapter 14, Graphical User Interfaces, I cover the higher-level aspects of

a GUI, such as buttons, labels, menus, and the like—the GUI’s predefined components.

Once you have a GUI (really, before you actually write it), you’ll want to read Chapter 15,

Internationalization and Localization so your programs can work as well in Akbar,

Afghanistan, Algiers, Amsterdam, and Angleterre as they do in Alberta, Arkansas, and

Alabama.

Because Java was originally promulgated as “the programming language for the Inter‐

net,” it’s only fair that we spend some of our time on networking in Java. Chapter 13,

Network Clients covers the basics of network programming from the client side, focusing

on sockets. For the third edition, Chapter 13, Network Clients has been refocused from

applets and web clients to emphasize web service clients instead. Today so many appli‐

cations need to access a web service, primarily RESTful web services, that this seemed

to be necessary. We’ll then move to the server side in Chapter 16, Server-Side Java,

wherein you’ll learn some server-side programming techniques.

Programs on the Net often need to generate or process electronic mail, so Chapter 17,

Java and Electronic Mail covers this topic.

Chapter 18, Database Access covers the essentials of the higher-level database access

(JPA and Hibernate) and the lower-level Java Database Connectivity (JDBC), showing

Preface | xvii

how to connect to local or remote relational databases, store and retrieve data, and find

out information about query results or about the database.

One simple text-based representation for data interchange is JSON, the JavaScript Ob‐

ject Notation. Chapter 19, Processing JSON Data describes the format and some of the

many APIs that have emerged to deal with it.

Another textual form of storing and exchanging data is XML. Chapter 20, Processing

XML discusses XML’s formats and some operations you can apply using SAX and DOM,

two standard Java APIs.

Chapter 21, Packages and Packaging shows how to create packages of classes that work

together. This chapter also talks about “deploying” or distributing and installing your

software.

Chapter 22, Threaded Java tells you how to write classes that appear to do more than

one thing at a time and let you take advantage of powerful multiprocessor hardware.

Chapter 23, Reflection, or “A Class Named Class” lets you in on such secrets as how to

write API cross-reference documents mechanically (“become a famous Java book au‐

thor in your spare time!”) and how web servers are able to load any old Servlet—never

having seen that particular class before—and run it.

Sometimes you already have code written and working in another language that can do

part of your work for you, or you want to use Java as part of a larger package. Chapter 24,

Using Java with Other Languages shows you how to run an external program (compiled

or script) and also interact directly with “native code” in C/C++ or other languages.

There isn’t room in an 800-page book for everything I’d like to tell you about Java. The

Afterword presents some closing thoughts and a link to my online summary of Java

APIs that every Java developer should know about.

Finally, Appendix A gives the storied history of Java in a release-by-release timeline, so

whatever version of Java you learned, you can jump in here and get up to date quickly.

No two programmers or writers will agree on the best order for presenting all the Java

topics. To help you find your way around, I’ve included extensive cross-references,

mostly by recipe number.

Platform Notes

Java has gone through many major versions as discussed in Appendix A. This book is

aimed at the Java 7 and 8 platforms. By the time of publication, I expect that all Java

projects in development will be using Java 6 or 7, with a few stragglers wedded to earlier

versions for historical reasons (note that Java 6 has been in “end of life” status for about

a year prior to this edition’s publication). I have compiled all the code in the javasrc

xviii | Preface

剩余895页未读，继续阅读

cdoublef

粉丝: 2
资源: 79

Java编程实战指南

Java Cookbook(3rd) 无水印pdf

JavaCookBook

JavaCookbook.pdf

java:Java Cookbook的开发存储库

The Common Java Cookbook 2009

JavaCookBook(2nd)

java-cookbook-examples:通过 Java Cookbook 2nd 中的示例学习 Java 秘诀。 埃德。 伊恩·F·达尔文

Java Cookbook - Problems and Solutions for Java Developers

JavaCookBook(part6)

JavaCookBook(part1)

最新资源

java-cookbook-examples:通过 Java Cookbook 2nd 中的示例学习 Java 秘诀。埃德。伊恩·F·达尔文