关于写的Java书籍进展

简介:

大家好,去年说要写本Java书,近期就快出版了。目前已经开始打印样书了,最快于本月中旬左右就可以在互动网www.china-pub.com上看到消息,其它各个网站何时会发售要看具体进货情况。


去年我预期是半年写好这本书,6个月左右确实将手稿写好,但由于是第一次写书,所以没有意料到许多review的成本也是很高的,另外需要在每次review过后与出版社沟通,一直拖到现在才准备出版(而且还只出了上册),很多小伙伴已经等得花儿都谢了,哈哈!我也有类似的感觉,去年写的有些内容现在已经快过时了,呵呵,不过还好重点不是技术点本身。

经过几次review下来后,书中改掉许多问题,也删掉了一些内容,肯定比手稿看起来要顺畅很多。不过肯定还有一些没有注意到的地方,希望大家能够谅解。


这本书在写的过程中越写越多,去年年底发现写的内容已经远远超过了计划的字数和篇幅。因此与出版社决定分为“上下册”出版,本次出版的就是上册,上册是完全讲解基础的,也是胖哥认为最好的。本次出版的也是上册,据出版社介绍,上册内容部分总共为490页。


这本书从写这一年多以来很久,很多小伙伴一直对这本书的名字很感兴趣,哈哈,本书的名字还是有点霸气的,叫做《Java特种兵》,不过我想说的是名字只是一个嚼头,并不是说看了这本书就成特种兵了,具体细节可以看书里面的前言部分,本书封面基本定下来,可参考下图:




 这本书上册有2个篇,一个是基础篇、一个是源码篇。最近也有很多小伙伴问我到底要写什么,这里我就贴下目录:

上册目录如下:

1篇  Java功底篇

第1章  扎马:看看功底如何

1.1 String的例子,见证下我们的功底

  1.1.1  关于“==”

  1.1.2  关于“equals()”

  1.1.3  编译时优化方案

  1.1.4  补充一个例子

  1.1.5  跟String较劲上了

  1.1.6 intern()/equals()

  1.1.7 StringBuilder.append()与String“+”的PK.. 

1.2  一些简单算法,你会如何理解

  1.2.1  从一堆数据中找max和min

  1.2.2  从100万个数字中找最大的10个数字

  1.2.3  关于排序,实际场景很重要

  1.2.4  数据库是怎么找数据的

  1.2.5 Hash算法的形象概念

1.3  简单数字游戏玩一玩

  1.3.1  变量A、B交换有几种方式

  1.3.2  将无序数据Hash到指定的板块

  1.3.3  大量判定“是|否”的操作

  1.3.4  简单的数据转换

  1.3.5  数字太大,long都存放不下

1.4  功底概述

  1.4.1  什么是功底

  1.4.2  功底有何用途

  1.4.3  如何磨练功底

1.5  功底补充

  1.5.1  原生态类型

  1.5.2  集合类

1.6  常见的目录与工具包

1.7  面对技术,我们纠结的那些事儿

  1.7.1  为什么我这里好用,哪里不好用

  1.7.2  你的程序不好用,你会不会用,环境有问题

  1.7.3  经验是否能当饭吃

1.8  老A是在逆境中迎难而上者


第2章  Java程序员要知道计算机工作原理

2.1 Java程序员需要知道计算机工作原理吗?

2.2 CPU的那些事儿

  2.2.1  从CPU联系到Java

  2.2.2  多核

  2.2.3 Cache line

  2.2.4  缓存一致性协议

  2.2.5  上下文切换

  2.2.6  并发与征用

2.3  内存

2.4  磁盘

2.5  缓存

  2.5.1  缓存的相对性

  2.5.2  缓存的用途和场景

2.6  关于网络与数据库

  2.6.1 Java基本I/O

  2.6.2 Java的网络基本原则

  2.6.3 Java与数据库的交互

2.7  总结


第3章  JVM,Java程序员的OS

3.1  学习Java虚拟机对我们有什么好处

3.2  跨平台与字节码基本原理

  3.2.1 javap命令工具

  3.2.2 Java字节码结构

  3.2.3 Class字节码的加载

  3.2.4  字节码增强

3.3  从虚拟机的板块开始

  3.3.1 Hotspot VM板块划分

  3.3.2  “对象存放位置”小总结

  3.3.3  关于永久代

3.4  常见的虚拟机回收算法

  3.4.1  串行GC

  3.4.2 ParallelGC与ParallelOldGC

  3.4.3 CMS GC与未来的G1

  3.4.4  简单总结

  3.4.5  小小补充

3.5  浅析Java对象的内存结构

  3.5.1  原始类型与对象的自动拆装箱

  3.5.2  对象内存结构

  3.5.3  对象嵌套

  3.5.4  常见类型 & 集合类的内存结构

  3.5.5  程序中内存拷贝和垃圾

  3.5.6  如何计算对象大小

  3.5.7  轻松玩一玩int[2][100]PK int[100][2] 

3.6  常见的OOM现象

  3.6.1 HeapSize OOM

  3.6.2 PermGen OOM

  3.6.3 DirectBuffer OOM

  3.6.4 StackOverflowError 

  3.6.5  其他的一些内存溢出现象

3.7  常见的Java工具

  3.7.1 jps. 

  3.7.2 jstat 

  3.7.3 jmap. 

  3.7.4 jstack. 

  3.7.5 jinfo.

  3.7.6 JConsole. 

  3.7.7 Visual VM... 

  3.7.8 MAT(MemoryAnalyzer Tool)... 

  3.7.9 BTrace. 

  3.7.10 HSDB.. 

  3.7.11 工具总结... 

3.8  总结.... 

  3.8.1  写代码... 

  3.8.2  心理上战胜虚拟机带来的恐惧   


第4章  Java通信,交互就需要通信

4.1  通信概述.... 

  4.1.1 Java通信的基本过程... 

  4.1.2 Java通信的协议包装... 

  4.1.3  编写自定义通信协议... 

  4.1.4 Java的I/O流是不是很难学... 

4.2 Java I/O与内存的那些事.... 

  4.2.1  常规I/O操作的运作过程... 

  4.2.2 DirectBuffer的使用... 

  4.2.3  关于Buffer 

  4.2.4 FileChannel的加锁... 

4.3  通信调度方式.... 

  4.3.1  同步与异步... 

  4.3.2  阻塞与非阻塞... 

  4.3.3 Linux OS调度IO模型... 

  4.3.4 Java中的BIO、NIO.. 

  4.3.5 Java AIO.. 

4.4 Tomcat中对I/O的请求处理.... 

  4.4.1 Tomcat的配置&一个请求的响应... 

  4.4.2 Request、Response对象生成... 

  4.4.3 拉与推... 

第5章  Java并发,你会遇到吗.............. 

5.1  基础介绍.... 

  5.1.1  线程基础... 

  5.1.2  多线程... 

  5.1.3  线程状态... 

  5.1.4  反面教材suspend()、resume()、stop() 

  5.1.5  调度优先级... 

  5.1.6  线程合并(Join)... 

  5.1.7  线程补充小知识... 

5.2  线程安全.... 

  5.2.1  并发内存模型概述... 

  5.2.2  一些并发问题描述... 

  5.2.3 volatile. 

  5.2.4 final 

  5.2.5  栈封闭... 

  5.2.6 ThreadLocal 

5.3  原子性与锁.... 

  5.3.1 synchronized. 

  5.3.2  什么是乐观锁... 

  5.3.3  并发与锁... 

  5.3.4 Atomic. 

  5.3.5 Lock. 

  5.3.6  并发编程核心AQS原理... 

  5.3.7  锁的自身优化方法... 

5.4 JDK 1.6并发编程的一些集合类.... 

5.5  常见的并发编程工具.... 

  5.5.1 CountDownLatch. 

  5.5.2 CyclicBarrier 

  5.5.3 Semaphor 

  5.5.4  其他工具简介... 

  5.6  线程池&调度池.... 

  5.6.1  阻塞队列模型... 

  5.6.2 ThreadPoolExecutor 

  5.6.3  调度器ScheduleThreadPoolExecutor 

5.7  总结:编写并发程序要注意些什么.... 

  5.7.1  锁粒度... 

  5.7.2  死锁... 

  5.7.3 “坑”很多... 

  5.7.4  并发效率一定高吗... 

5.8  其他的并发编程知识.... 

  5.8.1 ShutdownHook(钩子线程)

  5.8.2 Future. 332

  5.8.3  异步并不等价于多线程... 

第6章  好的程序员应当知道数据库基本原理........................................... 

6.1  开发人员为什么要知道数据库原理.... 

6.2  从开发人员角度看数据库原理.... 

  6.2.1  实例与存储... 

  6.2.2  数据库基本原理... 

  6.2.3  索引基本原理... 

  6.2.4  数据库主从基本原理... 

  6.2.5  我们经常相信的那些经验... 

6.3  从程序员角度看数据库优化方法.... 

  6.3.1  不同领域的SQL区别... 

  6.3.2  执行计划... 

  6.3.3 SQL逻辑的例子... 

  6.3.4  模型结构设计的优化... 

  6.3.5  临时表... 

  6.3.6  分页知识补充... 

  6.3.7  计算count值... 

  6.3.8  分布式事务探讨... 

  6.3.9  其他... 

6.4  学会最基本的性能诊断.... 

  6.4.1  进入云数据库时代... 

  6.4.2  从程序员角度关注的数据库诊断信息... 

6.5  数风流存储,还看今朝.... 


第2篇  源码篇


第7章  源码基础

7.1  为何会出现框架.... 

7.2  阅读框架前的技术储备.... 

  7.2.1  反射基础知识... 

  7.2.2 AOP基础... 

  7.2.3 ORM基础... 

  7.2.4 Annotation与配置文件... 

第8章  部分JDBC源码讲解..

8.1 JDBC通用接口规范.... 

8.2 JDBC Driver注册.... 

8.3  创建Connection. 

8.4 SQL执行及处理.... 

  8.4.1  创建Statement 

  8.4.2 Batch设置批处理...

  8.4.3 fetchSize与maxRows. 

  8.4.4 setQueryTimeout()与cancel() 

第9章  部分Spring源码讲解

9.1 Spring MVC

  9.1.1 Spring加载

  9.1.2 Spring MVC处理一个简单请求

9.2 Spring事务管理器

  9.2.1 JDBC事务的基本思想

  9.2.2 Spring事务管理器的基本架构

  9.2.3 Spring如何保存Connection

  9.2.4 Spring如何保证程序中多次获取到的连接是同一个

9.3  思考:自己做框架有眉目了吗


第10章  看源码的一些总结.

10.1  高手看API的能力

10.2  通过源码能否量化性能与稳定性

10.3  思考相似方案和技术的优缺点

10.4  明确场景和业务,不做技术控

  10.4.1 谈谈技术控的那些事..

  10.4.2 明确业务背景的例子..

10.5  胖哥对框架的浅析...

  10.5.1 框架由来的一个补充.

  10.5.2 开源框架与扩展..

  10.5.3 框架与解决问题.

10.6  学海无涯,心境无限.



下册的手稿也已经写好,但是具体的目录和内容还会有所改动,不过不会有非常大的变动了,为了满足大家的好奇心,我写一下下册大概要写的内容(在上册的前言中也有):

1、设计篇,设计篇会提到设计模式和思想,但是胖哥会提出一些探讨性的观点和生活中的思想,然后我们再用一些实例来设计一些东西(2-3章)。

2、实现篇,主要讲解项目中的你我他,胖哥会讲讲自己所经历的一些项目中的稀奇古怪的事情,做事情的方法,人与人之间的合作,一些技术坑。

3、扩展篇,扩展篇比较杂,有走马观花式探讨一些集群、分布式的技术知识,也有探讨思想方法,看问题的角度,做IT人的心态等。


大概就这些了,下次大概就这些了,上册如果大家喜欢的话,下册我也会竭尽所能尽快review好,好了,就这些了!

等书出版的时候我再发个帖子,哈哈!








目录
相关文章
|
Java Spring 自然语言处理
Java源码英翻中进展-内测上线
解析Java源码, 并将标识符翻译为中文服务部署. Demonstrate the library to parse Java source code and translate the identifiers to Chinese with a domain.
722 0
|
6天前
|
存储 Java 数据库连接
java多线程之线程通信
java多线程之线程通信
|
7天前
|
安全 Java 开发者
深入理解Java并发编程:线程安全与性能优化
【4月更文挑战第9天】本文将深入探讨Java并发编程的核心概念,包括线程安全和性能优化。我们将详细解析Java中的同步机制,包括synchronized关键字、Lock接口以及并发集合等,并探讨它们如何影响程序的性能。此外,我们还将讨论Java内存模型,以及它如何影响并发程序的行为。最后,我们将提供一些实用的并发编程技巧和最佳实践,帮助开发者编写出既线程安全又高效的Java程序。
20 3
|
10天前
|
设计模式 安全 Java
Java并发编程实战:使用synchronized关键字实现线程安全
【4月更文挑战第6天】Java中的`synchronized`关键字用于处理多线程并发,确保共享资源的线程安全。它可以修饰方法或代码块,实现互斥访问。当用于方法时,锁定对象实例或类对象;用于代码块时,锁定指定对象。过度使用可能导致性能问题,应注意避免锁持有时间过长、死锁,并考虑使用`java.util.concurrent`包中的高级工具。正确理解和使用`synchronized`是编写线程安全程序的关键。
|
8天前
|
Java
Java 并发编程:深入理解线程池
【4月更文挑战第8天】本文将深入探讨 Java 中的线程池技术,包括其工作原理、优势以及如何使用。线程池是 Java 并发编程的重要工具,它可以有效地管理和控制线程的执行,提高系统性能。通过本文的学习,读者将对线程池有更深入的理解,并能在实际开发中灵活运用。
|
6天前
|
算法 Java 开发者
Java中的多线程编程:概念、实现与性能优化
【4月更文挑战第9天】在Java编程中,多线程是一种强大的工具,它允许开发者创建并发执行的程序,提高系统的响应性和吞吐量。本文将深入探讨Java多线程的核心概念,包括线程的生命周期、线程同步机制以及线程池的使用。接着,我们将展示如何通过继承Thread类和实现Runnable接口来创建线程,并讨论各自的优缺点。此外,文章还将介绍高级主题,如死锁的预防、避免和检测,以及如何使用并发集合和原子变量来提高多线程程序的性能和安全性。最后,我们将提供一些实用的性能优化技巧,帮助开发者编写出更高效、更稳定的多线程应用程序。
|
4天前
|
安全 算法 Java
深入理解Java并发编程:线程安全与性能优化
【4月更文挑战第11天】 在Java中,高效的并发编程是提升应用性能和响应能力的关键。本文将探讨Java并发的核心概念,包括线程安全、锁机制、线程池以及并发集合等,同时提供实用的编程技巧和最佳实践,帮助开发者在保证线程安全的前提下,优化程序性能。我们将通过分析常见的并发问题,如竞态条件、死锁,以及如何利用现代Java并发工具来避免这些问题,从而构建更加健壮和高效的多线程应用程序。
|
8天前
|
Java
Java并发编程:深入理解线程池
【4月更文挑战第7天】在现代软件开发中,多线程编程已经成为一种不可或缺的技术。为了提高程序性能和资源利用率,Java提供了线程池这一强大工具。本文将深入探讨Java线程池的原理、使用方法以及如何根据实际需求定制线程池,帮助读者更好地理解和应用线程池技术。
14 0
|
2天前
|
Java 程序员 编译器
Java中的线程同步与锁优化策略
【4月更文挑战第14天】在多线程编程中,线程同步是确保数据一致性和程序正确性的关键。Java提供了多种机制来实现线程同步,其中最常用的是synchronized关键字和Lock接口。本文将深入探讨Java中的线程同步问题,并分析如何通过锁优化策略提高程序性能。我们将首先介绍线程同步的基本概念,然后详细讨论synchronized和Lock的使用及优缺点,最后探讨一些锁优化技巧,如锁粗化、锁消除和读写锁等。
|
3天前
|
Java
探秘jstack:解决Java应用线程问题的利器
探秘jstack:解决Java应用线程问题的利器
13 1
探秘jstack:解决Java应用线程问题的利器