第1部分 基本语法
operators（新增批注30条）
simpler print statements
using java operators
precedence
assignment
mathematical operators
unary minus and plus operators
auto increment and decrement
relational operators
testing object equivalence
logical operators
literals
exponential notation
bitwise operators
shift operators
ternary if-else operator
string operator + and +=
common pitfalls when using
.operators
casting operators
truncation and rounding
promotion
java has no "sizeof "
summary
controlling execution
（新增批注21条）
true and false
if-else
iteration
do-while
for
the comma operator
foreach syntax
return
break and continue
the infamous "goto"
switch
summary
第2部分 面向对象
initialization & cleanup
（新增批注55条）
guaranteed initialization with
the constructor
method overloading
distinguishing overloaded
methods
overloading with primitives
overloading on return values
default constructors
the this keyword
calling constructors from
constructors
the meaning of static
cleanup： finalization and
garbage collection
what is finalize（） for？
you must perform cleanup
the termination condition
how a garbage collector works
member initialization
specifying initialization
constructor initialization
order of initialization
static data initialization
explicit static initialization
non-static instance initialization
array initialization
variable argument lists
enumerated types
summary
access control
（新增批注21条）
package： the library unit
code organization
creating unique package names
a custom tool library
java access specifiers
package access
public： interface access
private： you can't touch that！
protected： inheritance access
interface and implementation
class access
summary
reusing classes
（新增批注35条）
composition syntax
inheritance syntax
initializing the base class
delegation
combining composition and
inheritance
guaranteeing proper cleanup
name hiding
choosing composition vs.
inheritance
protected
upcasting
why "upcasting"？
composition vs. inheritance
revisited
the final keyword
final data
final methods
final classes
final caution
initialization and class
loading
initialization with inheritance
summary
interfaces
（新增批注16条）
abstract classes and methods
interfaces
"multiple inheritance" in java
extending an interface with
inheritance
name collisions when combining
interfaces
fields in interfaces
initializing fields in interfaces
interfaces and factories
summary
inner classes
（新增批注32条）
creating inner classes
the link to the outer class
using .this and .new
inner classes and upcasting
anonymous inner classes
factory method revisited
nested classes
classes inside interfaces
reaching outward from a
multiply nested class
why inner classes？
closures & callbacks
inheriting from inner classes
can inner classes be
overridden？
local inner classes
inner-class identifiers
summary
error handling with excep- tions（新增批注52条）
basic exceptions
exception arguments
catching an exception
the try block
exception handlers .
creating your own
exceptions
exceptions and logging
the exception specification
catching any exception
the stack trace
rethrowing an exception
exception chaining
standard java exceptions
special case： runtimeexception
performing cleanup with
finally
what's finally for？
using finally during return
pitfall： the lost exception
exception restrictions
constructors
exception matching
alternative approaches
passing exceptions to the console
summary
第3部分 数据存储
strings（新增批注53条）
immutable strings
overloading '+' vs.
stringbuilder
unintended recursion
operations on strings
formatting output
printf（）
system.out.format（）
the formatter class
format specifiers
formatter conversions
string.format（）
regular expressions
basics
creating regular expressions
quantifiers
pattern and matcher
split（）
replace operations
reset（）
regular expressions and java i/o
scanning input
scanner delimiters
scanning with regular
expressions
stringtokenizer
summary
arrays（新增批注36条）
why arrays are special
arrays are first-class objects
returning an array
multidimensional arrays
arrays and generics
creating test data
arrays.fill（）
data generators
arrays utilities
copying an array
comparing arrays
array element comparisons
sorting an array
searching a sorted array
summary
holding your objects
（新增批注35条）
generics and type-safe
containers
basic concepts
adding groups of elements
printing containers
list
iterator
listiterator
linkedlist
stack
set
map
queue
priorityqueue
collection vs. iterator
foreach and iterators
the adapter method idiom
summary
containers in depth
（新增批注102条）
full container taxonomy
filling containers
a generator solution
map generators
collection functionality
optional operations
unsupported operations
list functionality
sets and storage order
sortedset
queues
priority queues
deques
understanding maps
performance
sortedmap
linkedhashmap
hashing and hash codes
understanding hashcode（）
hashing for speed
overriding hashcode（）
choosing an implementation
a performance test framework
choosing between lists
microbenchmarking dangers
choosing between sets
choosing between maps
utilities
sorting and searching lists
making a collection or map
unmodifiable
synchronizing a collection or
map
holding references
the weakhashmap
java 1.0/1.1 containers
vector & enumeration
hashtable
stack
bitset
summary
第4部分 核心功能
i/o（新增批注89条）
the file class
a directory lister
directory utilities
checking for and creating
directories
input and output
types of inputstream
types of outputstream
adding attributes and useful
interfaces
reading from an inputstream
with filterinputstream
writing to an outputstream
with filteroutputstream
readers & writers
sources and sinks of data
modifying stream behavior
unchanged classes
off by itself：
randomaccessfile
typical uses of i/o streams
buffered input file
input from memory
formatted memory input
basic file output
storing and recovering data
reading and writing
random-access files
piped streams
file reading &
writing utilities
reading binary files
standard i/o
reading from standard input
changing system.out to a
printwriter
redirecting standard i/o
process control
new i/o
converting data
fetching primitives
view buffers
data manipulation with buffers
buffer details
memory-mapped files
file locking
compression
simple compression with gzip
multifile storage with zip
java archives （jars）
object serialization
finding the class
controlling serialization
using persistence
xml
summary
concurrency
（新增批注117条）
basic threading
defining tasks
the thread class
using executors
producing return values from
tasks
sleeping
priority
yielding
daemon threads
coding variations
joining a thread
catching exceptions
sharing resources
resolving shared resource
contention
atomicity and volatility
atomic classes
critical sections
synchronizing on other objects
thread local storage
terminating tasks
the ornamental garden
terminating when blocked
interruption
cooperation between tasks
wait（） and notifyall（）
notify（） vs. notifyall（）
producers and consumers
producer-consumers and queues
using pipes for i/o between tasks
deadlock
new library components
countdownlatch
cyclicbarrier
delayqueue
priorityblockingqueue
the greenhouse controller with
scheduledexecutor
semaphore
exchanger
simulation
bank teller simulation
the restaurant simulation
distributing work
performance tuning
comparing mutex technologies
lock-free containers
readwritelocks
active objects
summary
第5部分 高级特性
type information
（新增批注59条）
the need for rtti
the class object
class literals
generic class references
new cast syntax
checking before a cast
using class literals
a dynamic instanceof
counting recursively
registered factories
instanceof vs. class
equivalence
reflection： runtime class
information
a class method extractor
dynamic proxies
null objects
mock objects & stubs
interfaces and type
information
summary
generics
（新增批注126条）
comparison with c++
simple generics
a tuple library
a stack class
randomlist
generic interfaces
generic methods
leveraging type argument
inference
varargs and generic methods
a generic method to use with
generators
a general-purpose generator
simplifying tuple use
a set utility
anonymous inner classes
building complex models
the mystery of erasure
the c++ approach
migration compatibility
the problem with erasure
the action at the boundaries
compensating for erasure
creating instances of types
arrays of generics
bounds
wildcards
how smart is the compiler？
contravariance
unbounded wildcards
capture conversion
issues
no primitives as type parameters
implementing parameterized
interfaces
casting and warnings
overloading
base class hijacks an interface
self-bounded types
curiously-recurring generics
self-bounding
argument covariance
dynamic type safety
exceptions
mixins
mixins in c++
mixing with interfaces
using the decorator pattern
mixins with dynamic proxies
latent typing
compensating for the lack of
latent typing
reflection
applying a method to a sequence
when you don't happen
to have the right interface
simulating latent typing
with adapters
using function objects as
strategies
summary： is casting really
so bad？
enumerated types
（新增批注55条）
basic enum features
using static imports with enums
adding methods to an enum
overriding enum methods
enums in switch statements
the mystery of values（）
implements， not inherits
random selection
using interfaces for
organization
using enumset instead of
flags
using enummap
constant-specific methods
chain of responsibility with
enums
state machines with enums
multiple dispatching
dispatching with enums
using constant-specific methods
dispatching with enummaps
using a 2-d array
summary
annotations
（新增批注51条）
basic syntax
defining annotations
meta-annotations
writing annotation processors
annotation elements
default value constraints
generating external files
annotations don't
support inheritance
implementing the processor
using apt to process
annotations
using the visitor pattern with
apt
annotation-based unit testing
using @unit with generics
no "suites" necessary
implementing @unit
removing test code
sum
占位居中
直播中，去观看