疯狂Java程序员的基本修养

作者简介

李刚编著的《疯狂Java程序员的基本修养》归纳了Java学习者、工作者在学习、工作过程中最欠缺的技术短板，本书把Java编程中的重点、要点、难点、常见陷阱收集在一起，旨在帮助读者重点突破这些看似“司空见惯”的基本功。

    《疯狂Java程序员的基本修养》知识主要分为四个部分，第一部分主要介绍Java程序的内存管理，这部分是大多Java程序员最容易忽略的地方——因为Java不像C，而且Java提供了垃圾回收机制，因此导致许多Java程序员对内存管理重视不够；第二部分主要介绍了Java编程过程中各种常见的陷阱，这些陷阱有些来自于李刚老师早年痛苦的经历，有些来自于他的众多学子的痛苦经历，都是Java程序员在编程过程中的“前车之鉴”，希望读者能引以为戒；第三部分主要介绍常用数据结构的Java实现，这部分内容也是大多Java程序员重视不够的地方——因为许多初级程序员往往会感觉：数据结构对实际开发帮助并不大，但实际上，我们每天开发都会使用数据结构，只是经常利用别人的实现而已；第四部分主要介绍Java程序开发的方法、经验等，它们是李刚老师多年的实际开发经验、培训经验的总结，更符合初学者的习惯，更能满足初学者的需要，因此掌握这些开发方法、经验可以更有效地进行开发。

    本书提供了配套的网站：http://www.crazyit.org，读者在阅读该书过程中遇到任何技术问题都可登录该站点与李刚老师交流，也可与疯狂Java图书庞大的读者群交流。

    本书不是一本包含所有技术细节的手册，而是承载了无数过来人的谆谆教导，书中内容为有一定的Java基础的读者而编写，尤其适合于有一到两年的Java学习经验的读者和参加工作不久的初级Java程序员，帮助他们突破技术基本功的瓶颈。

书籍目录

第1章  数组及其内存管理
1

1.1  数组初始化
2

1.1.1  Java数组是静态的
2

1.1.2  数组一定要初始化吗
5

1.1.3  基本类型数组的初始化
7

1.1.4  引用类型数组的初始化
9

1.2  使用数组
12

1.2.1  数组元素就是变量
12

1.2.2  没有多维数组
14

1.3  本章小结
20

第2章  对象及其内存管理
21

2.1  实例变量和类变量
22

2.1.1  实例变量和类变量的属性
23

2.1.2  实例变量的初始化时机
26

2.1.3  类变量的初始化时机
30

2.2  父类构造器
32

2.2.1  隐式调用和显式调用
32

2.2.2  访问子类对象的实例变量
34

2.2.3  调用被子类重写的方法
37

2.3  父子实例的内存控制
39

2.3.1  继承成员变量和继承方法的区别
39

2.3.2  内存中子类实例
42

2.3.3  父、子类的类变量
47

2.4  final修饰符
48

2.4.1  final修饰的变量
48

2.4.2  执行“宏替换”的变量
53

2.4.3  final方法不能被重写
57

2.4.4  内部类中的局部变量
59

2.5  本章小结
62

第3章  常见Java集合的实现细节
63

3.1  Set和Map
64

3.1.1  Set和Map的关系
64

3.1.2  HashMap和HashSet
69

3.1.3  TreeMap和TreeSet
79

3.2  Map和List
85

3.2.1  Map的values()方法
85

3.2.2  Map和List的关系
91

3.3  ArrayList和LinkedList
92

3.3.1  Vector和ArrayList的区别
94

3.3.2  ArrayList和LinkedList的实现差异
97

3.3.3  ArrayList和LinkedList的性能分析及适用场景
101

3.4  Iterator迭代器
101

3.4.1  Iterator实现类与迭代器模式
102

3.4.2  迭代时删除指定元素
103

3.5  本章小结
106

第4章  Java的内存回收
107

4.1  Java引用的种类
108

4.1.1  对象在内存中的状态
108

4.1.2  强引用
111

4.1.3  软引用
111

4.1.4  弱引用
114

4.1.5  虚引用
118

4.2  Java的内存泄漏
119

4.3  垃圾回收机制
123

4.3.1  垃圾回收的基本算法
123

4.3.2  堆内存的分代回收
125

4.3.3  与垃圾回收相关的附加选项
127

4.3.4  常见的垃圾回收器
127

4.4  内存管理小技巧
131

4.4.1  尽量使用直接量
132

4.4.2  使用StringBuilder和StringBuffer进行字符串连接
132

4.4.3  尽早释放无用对象的引用
132

4.4.4  尽量少用静态变量
133

4.4.5  避免在经常调用的方法、循环中创建Java对象
133

4.4.6  缓存经常使用的对象
134

4.4.7  尽量不要使用finalize方法
134

4.4.8  考虑使用SoftReference
135

4.5  本章小结
135

第5章  表达式中的陷阱
136

5.1  关于字符串的陷阱
137

5.1.1  JVM对字符串的处理
137

5.1.2  不可变的字符串
140

5.1.3  字符串比较
142

5.2  表达式类型的陷阱
144

5.2.1  表达式类型的自动提升
144

5.2.2  复合赋值运算符的陷阱
145

5.2.3  Java 7新增的二进制整数
147

5.3  输入法导致的陷阱
148

5.4  注释字符必须合法
149

5.5  转义字符的陷阱
149

5.5.1  慎用字符的Unicode转义形式
149

5.5.2  中止行注释的转义字符
150

5.6  泛型可能引起的错误
151

5.6.1  原始类型变量的赋值
151

5.6.2  原始类型带来的擦除
153

5.6.3  创建泛型数组的陷阱
155

5.7  正则表达式的陷阱
157

5.8  多线程的陷阱
158

5.8.1  不要调用run方法
158

5.8.2  静态的同步方法
160

5.8.3  静态初始化块启动新线程执行初始化
162

5.8.4  注意多线程执行环境
167

5.9  本章小结
171

第6章  流程控制的陷阱
172

6.1  switch语句陷阱
173

6.1.1  default分支永远会执行吗
173

6.1.2  break的重要性
174

6.1.3  Java 7增强的switch表达式
176

6.2  标签引起的陷阱
177

6.3  if语句的陷阱
178

6.3.1  else隐含的条件
178

6.3.2  小心空语句
181

6.4  循环体的花括号
182

6.4.1  什么时候可以省略花括号
182

6.4.2  省略花括号的危险
183

6.5  for循环的陷阱
185

6.5.1  分号惹的祸
185

6.5.2  小心循环计数器的值
188

6.5.3  浮点数作循环计数器
188

6.6  foreach循环的循环计数器
190

6.7  本章小结
192

第7章  面向对象的陷阱
193

7.1  instanceof运算符的陷阱
194

7.2  构造器的陷阱
198

7.2.1  构造器之前的void
198

7.2.2  构造器创建对象吗
199

7.2.3  无限递归的构造器
203

7.3  持有当前类的实例
205

7.4  到底调用哪个重载的方法
206

7.5  方法重写的陷阱
209

7.5.1  重写private方法
209

7.5.2  重写其他访问权限的方法
210

7.6  非静态内部类的陷阱
211

7.6.1  非静态内部类的构造器
211

7.6.2  非静态内部类不能拥有静态成员
213

7.6.3  非静态内部类的子类
214

7.7  static关键字
215

7.7.1  静态方法属于类
215

7.7.2  静态内部类的限制
217

7.8  native方法的陷阱
217

7.9  本章小结
219

第8章  异常处理的陷阱
220

8.1  正确关闭资源的方式
221

8.1.1  传统关闭资源的方式
221

8.1.2  使用Java 7增强的try语句关闭资源
224

8.2  finally块的陷阱
226

8.2.1  finally的执行规则
226

8.2.2  finally块和方法返回值
227

8.3  catch块的用法
229

8.3.1  catch块的顺序
229

8.3.2  不要用catch代替流程控制
231

8.3.3  只有catch可能抛出的异常
232

8.3.4  做点实际的修复
235

8.4  继承得到的异常
237

8.5  Java 7增强的throw语句
238

8.6  本章小结
240

第9章  线性表
241

9.1  线性表概述
242

9.1.1  线性表的定义及逻辑结构
242

9.1.2  线性表的基本操作
243

9.2  顺序存储结构
243

9.3  链式存储结构
248

9.3.1  单链表上的基本运算
249

9.3.2  循环链表
255

9.3.3  双向链表
256

9.4  线性表的分析
262

9.4.1  线性表的实现分析
262

9.4.2  线性表的功能
263

9.5  本章小结
264

第10章  栈和队列
265

10.1  栈
266

10.1.1  栈的基本定义
266

10.1.2  栈的常用操作
267

10.1.3  栈的顺序存储结构及实现
267

10.1.4  栈的链式存储结构及实现
272

10.1.5  Java集合中的栈
275

10.2  队列
275

10.2.1  队列的基本定义
275

10.2.2  队列的常用操作
276

10.2.3  队列的顺序存储结构及实现
276

10.2.4  循环队列
280

10.2.5  队列的链式存储结构及实现
284

10.2.6  Java集合中的队列
287

10.3  双端队列
288

10.4  本章小结
289

第11章  树和二叉树
290

11.1  树的概述
291

11.1.1  树的定义和基本术语
291

11.1.2  树的基本操作
292

11.1.3  父节点表示法
293

11.1.4  子节点链表示法
296

11.2  二叉树
301

11.2.1  二叉树的定义和基本概念
301

11.2.2  二叉树的基本操作
302

11.2.3  二叉树的顺序存储
303

11.2.4  二叉树的二叉链表存储
306

11.2.5  二叉树的三叉链表存储
310

11.3  遍历二叉树
313

11.3.1  先序遍历
314

11.3.2  中序遍历
314

11.3.3  后序遍历
315

11.3.4  广度优先（按层）遍历
316

11.4  转换方法
316

11.4.1  森林、树和二叉树的转换
317

11.4.2  树的链表存储
318

11.5  哈夫曼树
318

11.5.1  哈夫曼树的定义和基本概念
319

11.5.2  创建哈夫曼树
319

11.5.3  哈夫曼编码
322

11.6  排序二叉树
323

11.7  红黑树
331

11.7.1  插入操作
332

11.7.2  删除操作
335

11.8  本章小结
344

第12章  常用的内部排序
345

12.1  排序的基本概念
346

12.1.1  排序概述
346

12.1.2  内部排序的分类
347

12.2  选择排序法
347

12.2.1  直接选择排序
347

12.2.2  堆排序
351

12.3  交换排序
356

12.3.1  冒泡排序
356

12.3.2  快速排序
358

12.4  插入排序
360

12.4.1  直接插入排序
360

12.4.2  折半插入排序
362

12.4.3  Shell排序
364

12.5  归并排序
367

12.6  桶式排序
370

12.7  基数排序
372

12.8  本章小结
375

第13章  程序开发经验谈
376

13.1  扎实的基本功
377

13.1.1  快速的输入能力
377

13.1.2  编程实现能力
379

13.1.3  快速排错
379

13.2  程序开发之前
380

13.2.1  分析软件的组件模型
380

13.2.2  建立软件的数据模型
383

13.3  理清程序的实现流程
384

13.3.1  各组件如何通信
384

13.3.2  人机交互的实现
386

13.3.3  复杂算法的分析
388

13.4  编写开发文档
391

13.4.1  绘制建模图、流程图
391

13.4.2  提供简要说明
393

13.4.3  编写伪码实现
393

13.5  编码实现和开发心态
394

13.5.1  开发是复杂的
394

13.5.2  开发过程是漫长的
394

13.6  本章小结
395

第14章  程序调试经验谈
396

14.1  程序的可调试性
397

14.1.1  增加注释
397

14.1.2  使用log
397

14.2  程序调试的基本方法
405

14.2.1  借助编译器的代码审查
405

14.2.2  跟踪程序执行流程
408

14.2.3  断点调试
409

14.2.4  隔离调试
411

14.2.5  错误重现
412

14.3  记录常见错误
414

14.3.1  常见异常可能的错误原因
414

14.3.2  常见运行时异常可能的错误原因
416

14.4  程序调试的整体思路
417

14.4.1  分段调试
418

14.4.2  分模块调试
419

14.5  调试心态
419

14.5.1  谁都会出错
420

14.5.2  调试比写程序更费时
420

14.6  本章小结
420

第15章  IDE工具心法谈
421

15.1  何时开始利用IDE工具
422

15.2  IDE工具概述
423

15.2.1  IDE工具的基本功能
424

15.2.2  常见的Java IDE工具
425

15.3  项目管理
428

15.3.1  建立项目
428

15.3.2  自动编译
434

15.3.3  自动部署、运行
435

15.4  代码管理
436

15.4.1  向导式的代码生成
436

15.4.2  代码生成器
438

15.4.3  代码提示
439

15.4.4  自动代码补齐
441

15.4.5  实时错误提示
441

15.5  项目调试
442

15.5.1  设置断点
442

15.5.2  单步调试
444

15.5.3  步入、步出
445

15.6  团队协作功能
446

15.7  本章小结
450

第16章  软件测试经验谈
451

16.1  软件测试概述
452

16.1.1  软件测试的概念和目的
452

16.1.2  软件测试的分类
454

16.1.3  开发活动和测试活动
454

16.1.4  常见的Bug管理工具
455

16.2  单元测试
456

16.2.1  单元测试概述
456

16.2.2  单元测试的逻辑覆盖
458

16.2.3  JUnit介绍
461

16.2.4  JUnit的用法
461

16.3  系统测试和自动化测试
467

16.3.1  系统测试概述
467

16.3.2  自动化测试
468

16.3.3  常见的自动化测试工具
469

16.4  性能测试
470

16.4.1  性能测试概述
470

16.4.2  性能测试的相关概念
471

16.4.3  常见的性能测试工具
472

16.5  本章小结
472

编辑推荐

李刚编著的《疯狂Java程序员的基本修养》第一部分主要介绍Java内存管理相关方面的知识，内存管理既是Java程序员容易忽视的地方，又是Java编程的重点。    本书第三部分所介绍的常见数据结构、排序算法的Java实现，则是笔者一直想介绍的内容——也许你初涉编程时感受不到这些经典算法的用途，因为你可以直接利用别人的实现；但如果你希望突破自己，上升到另外一个高度时，你就不可避免地需要自己开发类库，而不是总使用别人的类库，那这些经典算法的作用就显现出来了。    本书第二部分收集了Java编程中各种常见的陷阱；第四部分的内容则解决了他们进入实际开发之前的困扰，包括程序开发的基本方法，有效进行程序调试的方法，如何看待、使用IDE工具，软件测试等相关内容。

前言

　　前言　　Java语言拥有的开发人群越来越大了，大量程序员已经进入或正打算进入Java编程领域。这当然和Java语言本身的优秀不无关系，却也和Java编程入门简单有关。一个毫无编程基础的初学者，只要有点数据库和SQL基础，大概花不到一个月时间就可以学会编写JSP页面，说不定就可以找到一份Java编程的工作了。如果他肯再多下点功夫，学习一下编写Struts Action类、配置Action，编写Spring Bean类、配置Bean，他甚至可能自我感觉很不错了。　　问题是：这种“快餐式”的程序员、“突击式”的程序员真的满足要求吗？如果仅仅满足于这些简单的、重复式开发，他们也许没有太多的问题，但他们可能很少有突破的机会。究其根本原因，很大程度上是因为他们的基本修养不够扎实。对他们而言，与其说Java是一种面向对象的语言，不如说更像一种脚本；他们从源代码层次来看程序运行（甚至只会从Eclipse等集成开发环境中看程序运行），完全无法从底层内存分配的角度来看程序运行；他们天天在用Java类库、用Struts、用Spring，但对这些东西的实现知之甚少--这又如何突破自己、获得更好的提高呢？　　鉴于此种现状，“疯狂软件教育中心”训练过程中除了采用大量的实际项目来驱动教学之外，往往会花时间、精力来培养学员的基本修养。比如讲授Spring框架，如果只关注编写Bean类、配置Bean，一天就足够了。而笔者往往会深入Spring框架的底层实现，带领学生从工厂模式、策略模式、门面模式、代理模式、命令模式的角度来深度分析Spring框架实现，然后进行对比，总结Spring框架的优势到底在哪里？不使用Spring框架是否有替换解决方案？进而感受设计模式对实际开发的帮助。　　上面这些内容，看似“高深”，但其实质依然离不开Java编程的基本功。完全可以这样说：一旦读者真正把基本功打扎实了，将可以看得更高、更透彻。　　在这样的背景下，笔者想将自己多年的一些经验、总结通过本书与大家分享，希望把自己多年积累的经验、心得表达出来；把自己走过的弯路“标”出来，让后来者尽量少走弯路。　　本书内容　　本书第一部分主要介绍Java内存管理相关方面的知识，内存管理既是Java程序员容易忽视的地方，又是Java编程的重点。实际上，许多有一定编程经验的Java开发者，自然而然就会关心垃圾回收、内存管理、性能优化相关内容。无论学习哪种语言，如果能真正从程序运行的底层机制、内存分配细节、内存回收细节把握程序执行过程，这样才能有豁然开朗的感觉，本书第一部分正是旨在帮助大家更好地掌握Java内存管理相关知识。　　本书第三部分所介绍的常见数据结构、排序算法的Java实现，则是笔者一直想介绍的内容--也许你初涉编程时感受不到这些经典算法的用途，因为你可以直接利用别人的实现；但如果你希望突破自己，上升到另外一个高度时，你就不可避免地需要自己开发类库，而不是总使用别人的类库，那这些经典算法的作用就显现出来了。　　本书第二部分和第四部分则主要来自于参加“疯狂软件教育中心”的学生，正如每个动手编程的初学者，他们都曾经遭遇过各种各样的陷阱，笔者总是提醒他们应该将这些陷阱收集起来，以免再次陷进去。本书第二部分收集了Java编程中各种常见的陷阱；第四部分的内容则解决了他们进入实际开发之前的困扰，包括程序开发的基本方法，有效进行程序调试的方法，如何看待、使用IDE工具，软件测试等相关内容。　　本书源代码的下载地址为：http：//www.broadview.com.cn/19232。　　本书写给谁看　　如果你想从零开始学习Java编程，本书不适合你。如果你已经学会了Java基本语法，动手编程却感到困难重重，或者你已经是一个Java程序员了，实际开发中却感觉力不从心，本书将非常适合你。本书会帮助你找出自己的技术短板，提升Java编程的基本修养。

内容概要

李刚，从事10多年的Java EE应用开发，现任疯狂软件教育中心教学总监。

疯狂Java实训营创始人，疯狂Java体系图书作者。曾任LITEON公司的J2EE技术主管，负责该公司的企业信息化平台的架构设计。

曾任广州电信、广东龙泉科技等公司的技术培训导师。曾兼任广东技术师范学院计算机科学系的兼职副教授。

2007年3月26日的《电脑报》专访人物。

培训的学生已在华为、立信、普信、网易、电信盈科等公司就职。

国内著名的高端IT技术作家，已出版《疯狂Java讲义》、《疯狂Android讲义》、《轻量级Java EE企业应用实战》、《疯狂Ajax讲义》、《疯狂XML讲义》、《经典Java EE企业应用实战》、《Struts 2.1权威指南》、《Ruby On Rails敏捷开发最佳实践》等著作。其中疯狂Java体系图书都是已经得到广泛的市场认同，并多次重印的畅销图书，并被多家高校选作教材，部分图书已被翻译成繁体中文版、输出到台湾地区。

图书封面

---

 疯狂Java程序员的基本修养下载 精选章节试读 更多精彩书评

---