Java 源码分析一

JAVA 语言的主要特征：

简单、动态、高性能、跨平台、面象对象、分布式、多线程、安全、健壮性html

Class Arrays:

This class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists.前端

经常使用方法有： asList ,copyOf, fill ,sortjava

public static <T> List<T> asList(T... a)
public static <T> T[] copyOf(T[] original,int newLength)
public static void fill(Object[] a,Object val)
public static void fill(Object[] a,int fromIndex,int toIndex,Object val)
parallelSort: public static <T extends Comparable<? super T>> void parallelSort(T[] a)

类和对象

成员方法修饰符：主要有public、private、protect、final 、static、abstract和 synchronized 7种,用来讲明方法的访问权限

 方法传参：
 –值传递：表示方法接收的是调用者提供的变量的值。
 –引用传递：表示方法接收的是调用者提供的变量地址。
 –一个方法能够修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。
    方法传参（基本数据类型）：–方法不会改变实参的值
  方法传参（引用类型）：–方法体内，经过引用改变了实际参数对象的值
 Java参数传递机制：  –http://blog.sina.com.cn/s/blog_4b622a8e0100c1bo.html
 对象和对象的引用    –http://jingyan.baidu.com/article/a501d80cf734c3ec630f5e25.html

Java类库中几个重要的包

java.lang –包含一些造成语言核心的类，如String、Math、Integer和Thread。
•java.awt –包含了构成抽象窗口工具包（AWT）的类，这个包被用来构建和管理应用程序的图形用户界面。
•java.applet –包含了可执行applet 特殊行为的类。
java.net –包含执行与网络相关的操做的类和处理接口及统一资源定位器(URLs)的类。
•java.io –包含处理I/O 文件的类。
•java.util –包含为任务设置的实用程序类，如随机数发生、定义系统特性和使用与日期日历相关的函数。

访问修饰符与封装

• public公共成员
– 成员方法或变量声明为public，称为公共成员
-- 能够被全部的类访问的成员（前提所属类自己是可见的）
• private私有成员
– 不能被其所在类之外的任何类访问
• 声明为private的成员，称为私有成员
• protected保护成员和默认成员
– 声明为protected的成员，称为保护成员
– 能够被同一包内的类访问和被子类继承
• 没有任何修饰符的成员，称为默认成员
– 只能被同一包内的类访问sql

对象的继承

–Java 中的单继承机制：一个类只能有一个直接父类;
–final修饰的类不能有子类;String是典型特例
–Object类是全部Java类的顶级父类。数据库

实例化子类对象时系统会先调用父类的构造方法，而后再调用子类的构造方法。编程

– JVM默认会调用父类中无参数的构造方法，若父类中没有无参数的构造方法，程序会报错。后端

抽象类：

abstract修饰的类称为抽象类，抽象类的特色：
–不能实例化对象;
–类中能够定义抽象方法（abstract修饰的方法）;
–抽象类中能够没有抽象方法。
•abstract修饰的方法称为抽象方法，抽象方法只有方法的声明没有方法实现，即没有方法体。包含抽象方法的类自己必须被声明为抽象的数组

子类继承抽象类必须实现抽象类中全部的抽象方法，不然子类也必须定义为抽象类。安全

接口：

Java中的接口是一系列方法的声明，是一些方法特征的集合，接口能够看作是一种特殊的抽象类，其中包含常量和方法的声明，而没有变量和方法的实现网络

– 一个类能够同时实现多个接口;
– 一个接口能够被多个无关的类实现;
– 一个类实现接口必须实现接口中全部的抽象方法，不然必须定义为抽象类。

接口的继承：

Java中接口能够继承接口，与类的继承概念一致，一个接口继承一个父接口就会继承父接口中定义的全部方法和属性。
• Java中接口的继承是多继承机制，即一个接口能够同时继承多个接口。

java.lang.Class<T>

Type Parameters:

T - the type of the class modeled by this Class object. For example, the type of String.class is Class<String>. Use Class<?> if the class being modeled is unknown

Class 对象的方法

Object()
– 默认构造方法。
• clone()
– 建立并返回此对象的一个副本。
• equals(Object obj)
– 指示某个其余对象是否与此对象“相等”。
• finalize()
– 当垃圾回收器肯定不存在对该对象的更多引用时，由对象的垃圾
回收器调用此方法。
• getClass()
– 返回一个对象的运行时类。

hashCode()
–返回该对象的哈希码值。
•notify()
–唤醒在此对象监视器上等待的单个线程。
•notifyAll()
–唤醒在此对象监视器上等待的全部线程。
•toString()
–返回该对象的字符串表示。
•wait()
–致使当前的线程等待，直到其余线程调用此对象的notify() 方法或notifyAll() 方法。

•wait(long timeout)
–致使当前的线程等待，直到其余线程调用此对象的notify() 方法或notifyAll() 方法，或者超过指定的时间量。
•wait(long timeout, int nanos)
–致使当前的线程等待，直到其余线程调用此对象的notify() 方法或notifyAll() 方法，或者其余某个线程中断当前线程，或者已超过某个实际时间量。

nanosecond:  十亿分之一秒;

The amount of real time, measured in nanoseconds, is given by: 1000000*timeout+nanos

包装器类

•Java中的八种基本数据类型自己只能表示一种数值，为了能将基本类型视为对象来处理,并能链接相关的方法，Java为每一个基本类型提供了包装类。

•Java的八种基本数据类型对应的包装器类分别为：Byte，Short，Character，Integer，Long，Float，Double，Boolean。

包装器类型对象共同的特色:

–对象一旦赋值，其值不能再改变。

装箱、拆箱

•在Java中一些运算或程序对数据类型是有限制的，好比：++/--操做符只能操做基本类型数据，集合中只能存放包装器类型对象等等。
•思考：如何对Integer类型的数据进行++/--操做？
Integer y = new Integer (567);
intx = y.intValue();
x++;
y = new Integer(x);

基本数据类型的加宽带来的方法重载问题

基本数据类型会被加宽到更宽泛的基本数据类型
–基本数据类型和对应的包装器类型是不一样的数据类型

自动装箱带来的方法重载问题

自动装箱给方法的重载带来了必定的难题;
可变元参数列表带来的方法重载问题
可变元参数列表给方法的重载带来了必定的难题;

重载方法调用规则

选择重载时匹配哪一个方法时遵循如下原则：
–是否有直接匹配的
–是否加宽后直接可以匹配的
–是否装箱后可以匹配的
–先装箱后加宽后可否匹配
•能够先装箱，后加宽（int能够经过Integer编程Object）
–是否有不定长参数可以匹配的

Static修饰符

声明为static的变量实质上就是全局变量

• 当声明一个对象时，并不产生static变量的拷贝
• 该类全部的实例变量共享同一个static变量
• 在类装载时，只分配一块存储空间，全部此类的对象均可
以操控此块存储空间

static{后面跟着一段代码，这是用来进行显式的静态变量
初始化，这段代码只会初始化一次，且在类被第一次装载
时
• 涉及到继承的时候，会先初始化父类的static变量，而后
是子类的
• 子类实例化对象时的执行顺序
– 父类的静态代码块
– 子类的静态代码块
– 父类的构造方法
– 子类的构造方法

静态类

• 一般一个普通类不容许声明为静态的，只有一个内部类才能够。
• 声明为静态的内部类能够直接做为一个普通类来使用，而不需实例化一个外部类

static和final一块儿使用
– static final用来修饰成员变量和成员方法，可简单理解为“全局常量”
– 对于变量，表示一旦赋值就不可修改，而且经过类名能够访问
– 对于方法，表示不可覆盖，而且能够经过类名直接访问

内部类（inner class）

是定义在另外一个类中的类。
•内部类的特色：
–内部类是一种编译时的语法，编译后生成的两个类是独立的两个类。（对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类）。
–能够自由访问外部类的任何成员（包括私有成员），但外部类不能直接访问内部类的成员。
–内部类可为静态，能够用protected、private修饰，而外部类只能使用public和缺省的包访问权限。
–用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限

枚举Enum

Java中的enum本质就是一个clas
枚举与类的区别: 
 枚举不能够实例化
 一般只为枚举成员变量提供get方法，而不提供set方法
枚举的特色：

数据集
–他们的数值在程序中是稳定的
–元素个数有限
•全部枚举类都继承了Enum类的方法
–toString
–Equals
–Hashcode
–…
–注：equals、hashcode方法是final 的，因此不能够被枚举重写（只能够继承）。可是，能够重写toString方法
–Java 不容许使用= 为枚举常量赋值

除了不能继承，基本上能够将Enum 自做一个常规的类异常和断言

异常和断言

异常分为2大类
–Error：描述了Java运行系统中的内部错误以及资源耗尽错误
•惟一的解决方法：尽力使程序安全地终止
–Exception：程序中须要关注的
•运行时错误（RuntimeException）：在Java 虚拟机正常运行期间抛出的异常，由程序错误致使。Java编译器容许程序中不对这类异常作出处理。
–错误的类型转换
–数组下标越界
–访问空指针
•其余错误（如：IO异常、SQL异常）：通常是外部错误，Java编译器要求在程序中必须处理这类异常

异常处理的优点

Java采用异常类表示异常
–把异常状况表示成异常类，能够充分发挥类的可扩展和可重用的优点
•异常流程的代码和正常流程的代码分离，提升了程序的可读性，简化了程序的结构
•Java能够灵活的处理异常，若是当前方法有能力处理异常，就捕获并处理它，不然只需抛出异常，交由方法调用者来处理

异常处理机制

对于异常Java中提供了两种常见的方式：
–捕获异常
–抛出异常

断言

•JavaSE1.4中引入的新特性，用于检查程序的安全性。
•关键字assert、java.lang.AssertError类
•当须要在一个值为FALSE时中断当前操做的话，可使用断言
–可看作是异常处理的高级形式，断言的布尔状态为true则没问题，若是为false，则抛出AssertError异常。

•两种形式

–assertExpression1
–assertExpression1:Expression2
•断言在默认状况下是关闭的，启用断言验证假设须用到java命令的参数-ea
•在Eclipse中的run configuration中添加默认参数-ea

容器和泛型

集合 Java提供的这一套容器类，其中基本类型是List、Set、Queue和Map，这些对象类型也称之为集合类。

List :

列表（List ）：关心的是索引
–对象按索引存储
–能够存储重复元素
–具备与索引相关的一套方法
•主要实现类
–ArrayList：线性表
•快速迭代，少许插入删除
–LinkedList：链表
•迭代速度慢，快速插入删除

Set
•集（Set）是最简单的一种集合：关心惟一性
–对象无序存储
–不能存储重复元素
•主要实现类
–HashSet：使用被插入对象的Hash码
–LinkedHashSet：HashSet的ordered版本
–TreeSet：二叉树结构，保证元素按照元素的天然顺序进行升序排序

HashSet
•基于HashMap 实现的，HashSet 底层采用HashMap 来保存全部元素
•不容许有重复元素
•不关心集合中元素的顺序

TreeSet
•TreeSet（树集）相似HashSet（散列集）
•能够以任意顺序将元素插入到集合中
•对集合遍历时，每一个值会自动的按照排序后的顺序呈现
•添加操做速率比散列集慢（由于迭代器老是以排好序的顺序访问每一个元素）

Queue

•java.util.Queue
•队列是一种特殊的线性表，只容许在表的前端（front，队头）进行删除操做，而在表的后端（rear，队尾）进行插入操做
•继承了Collection接口
•LinkedList实现了Queue接口

Queue接口经常使用方法
•add(E e): 增长一个元素。成功时返回true，若是队列已满，则抛出一个IIIegaISlabEepeplian异常
•remove(): 移除并返回队列头部的元素。若是队列为空，则抛出一个NoSuchElementException异常
•Element(): 返回队列头部的元素。若是队列为空，则抛出一个NoSuchElementException异常
•offer(E e): 添加一个元素并返回true。若是队列已满，返回false
•poll(): 移除并返问队列头部的元素。若是队列为空，则返回null
•peek(): 返回队列头部的元素。若是队列为空，则返回null

•put(E e): 添加一个元素。若是队列满，则阻塞

•take(): 移除并返回队列头部的元素。若是队列空，则阻塞

Map接口
•映射（Map）
–对象以键－值对（key-value）存储
–key不容许有重复，value容许有重复
•Map中元素，能够将key序列、value序列单独抽取出来
–使用keySet()抽取key序列，将map中的全部keys生成一个Set。
–使用values()抽取value序列，将map中的全部values生成一个Collection。

HashMap
•基于哈希表的Map 接口的实现
•HashMap是非线程安全的
•经常使用方法：
–Object put(K key,V value)
–Object get(Object K)
–containsKey(Object K)
•遍历HashMap

TreeMap
–基于红黑树实现
–按照元素的天然顺序排序
•LinkedHashMap
–HashMap的ordered版本

迭代器（Iterator）

•Iterator：“轻量级”对象
•iterator()方法是java.lang.Iterable接口,被Collection继承。
•主要功能：用于对容器的遍历
•主要方法
–Boolean hasNext():判断是否有能够元素继续迭代
–Object next()：返回迭代的下一个元素
–void remove()：从迭代器指向的集合中移除迭代器返回的最后一个元素

泛型

重写hashCode和equals方法

hashCode契约

•equals方法比较相等的两个对象hashCode返回值必须相同
•equals方法比较不相等的两个对象hashCode返回值能够不相同，也能够相同
•若是没有修改对象的equals比较内的任何属性信息，则这个对象屡次调用hashCode返回相同结果

自反的： •对任意的x引用，x.equals(x)都应返回true
对称的： •对任意的x、y引用，当且仅当x.equals（y）时，y.equals(x)才返回true
传递的： •对任意的x、y、z引用,若是x.equals(y)和y.equals(z)返回true，则z.equals(x)返回true
一致的：•对任意的x、y引用，对象中的信息没有作修改的前提下屡次调用x.equals(y)返回一致的结果
非空： •对任意非NULL引用x,x.equals(null)返回false

泛型引入：Generics

为了提升代码的重用性，用通用的数据类型Object来实现
•优势
–灵活
–通用性强
•缺点
–处理值类型时，会出现装箱、折箱操做，性能损失很是严重
–处理引用类型时，虽然没有装箱和折箱操做，但将用到数据类型的强制转换操做，增长处理器的负担
–若是处理数据是数组，数组中数据类型不一致
•运行时类型转换异常
•编译器没法检查出来

使用泛型

既加强代码通用性，又避免编译器没法检查编译错误的问题——泛型
•泛型用一个通用的数据类型T来代替object，在类实例化时指定T的类型，运行时自动编译为本地代码，运行效率和代码质量都有很大提升，而且保证数据类型安全
•泛型的做用就是提升代码的重用性，避免强制类型转换，减小装箱拆箱提升性能，减小错误

泛型（Generics）
–所谓泛型，即经过参数化类型来实如今同一份代码上操做多种数据类型
–泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用
–泛型赋予了代码更强的类型安全，更好的复用，更高的效率，更清晰的约束

使用通配符（?）
•接受所声明变量类型的任何子类型
–void addAnimal(List<? extends Animal> animals)
–Animal能够是类或接口
•接受父类型的变量
–void addAnimal(List<? super Dog> animals)
–接受super右边类型或其超类型
•List<?> 与List<? extents Object>彻底相同
•List<Object>与List<?>彻底不一样

流和文件

程序如何与外部资源进行交互呢？

•例如：我但愿读取本地的一个文本文件显示在屏幕上怎么办呢？
Java程序与外部交互的主要手段就是流！！

Java中流的处理
•在Java中对于不一样的流提供了相应的处理类：
–字节输入流：InputStream类
–字节输出流：OutputStream类
–字符输入流：Reader类
–字符输出流：Writer类

根据操纵对象的类型分类
•字符流：读取单位为字符，由于数据编码的不一样，而有了对字符进行高效操做的流对象。本质其实就是基于字节流读取时，去查了指定的码表。读取的字节数由字符编码肯定。
•字节流：读取单位为字节，通常用于文件传输
只要处理纯文本数据，优先考虑字符流，其余的形式采用字节流。

Java中字符流的处理
• 字符流的输入输出主要以字符为单位。主要用于外部设备
中字符序列的读取和外部设备中字符序列的显示。Java采
用16位的Unicode来表示字符串和字符。
• 对于字符流的资源比较单一，就是字符序列。

对象流：

序列化的概念
• Java容许咱们在内存中经过定义对象来保存对象状态，可是当JVM中止时对象就没法保存。
• 如何持久化保存对象状态呢？
• Java对象序列化就可以帮助咱们实现该功能。在保存对象时把其转换为一组字节，等待须要时再将本身组装回以前
的对象。

对象序列化注意事项
• 类必须实现Serializable或Externalizable接口才能被序列化
• 实现Serializable的类中如有不参与序列化的变量可用transient关键字修饰
• 用static修饰的静态成员变量，不参加序列化过程

JDK8 新特性：日期

旧版本：Java中用于表示日期的类
–Date类
–Calendar类
•日期的格式化和解析
–DateFormate
–SimpleDateFormate

JDK8日期新特性
•新日期、时间的一些相关概念
–瞬时时间（Instant）
–持续时间（duration）
–日期（date）
–时间（time）
–时区（time-zone）
–时间段（Period）

新特性——日期
•java.time包
•关键类
–Instant——它表明的是时间戳
–LocalDate——不包含具体时间的日期，好比2014-01-14。它能够用来存储生日，周年记念日，入职日期等。
–LocalTime——它表明的是不含日期的时间
–LocalDateTime——它包含了日期及时间，不过仍是没有偏移信息或者说时区。
–ZonedDateTime——这是一个包含时区的完整的日期时间，偏移量是以UTC/格林威治时间为基准的。

字符串解析

Java中字符串相关类包括：
– 字符串常量类
• java.lang.String
– 字符串变量类
• java.lang.StringBuffer
• java.lang.StringBuilder
• java.util.StringTokenizer

String类

• String是字符串常量类

– String对象的值一经赋值，其值不可变
– 指的是所指向的内存值不可修改，但能够改变指向
• String类型变量的初始化
– 构造方法初始化
• String name= new String(“zhangxiao”);
– 字符串常量初始化
• String sex = “男”;
• String类是final的，没法被继承

String中经常使用的字符串处理方法
• 字符串链接
– concat(String str)
– “+”运算符
• 字符串查找
– indexOf (String str)
– lastIndexOf(String str)
– charAt(int indexOf)
– startsWith(String prefix)
• 字符串分割
– split(String regex)：字符串分割
– compareTo(String str)：字符串比较
– equalslgnoreCase(String str)：忽略大小写

字符串替换
– replace(char oldChar, char newChar)
• 字符串求子串
– substring(int beginIndex, int endIndex)
• 字符串大小写转换
– toUpperCase() 小写转大写
– ToLowerCase()大写转小写

StringBuffer类

StringBuffer类是一个字符串变量类
– StringBuffer对象的值能够修改
– 主要用于对字符串作大量修改的操做时
• StringBuffer变量的初始化
– 构造方法初始化
– StringBuffer sb = new StringBuffer(“Hello”);

字符串链接
– append(Object obj)
• 字符串删除
– delete(int start,int end)
• 字符串插入
– insert(int offset,Object obj)
• 字符串逆序
– reverse()
• 转换为String对象
– toString()

StringBuilder类

• StringBuilder类与StringBuffer类的方法调用是一致的。

• StringBuilder类与StringBuffer类的区别：
– StringBuffer是线程安全的
– StringBuilder是非线程安全的

StringTokenzier类

• StringTokenizer类主要用途是将字符串以定界符为界，

分析为一个个独立的token（可理解为单词）。
• StringTokenizer中的定界符能够本身指定。
• StringTokenizer经常使用的方法：
– hasMoreTokens：是否有更多的分隔符
– nextToken：返回下一个分隔符前的内容值

日期类：

Java中经常使用的表示日期的类有三个
– java.util.Date：JDK 1.1后，java.util.Date 类中的大多数方法已经不推荐使用。
– java.sql.Date：主要针对数据库操做中的SQL使用，只有日期没有时间部分。
– java.util.Calendar：翻译为中文称为“日历”，JDK1.1以后Calendar逐步取代了java.util.Date类，提供了更多的方式来表示
日期和时间。

Date类

• java.util.Date类其实是一个包裹类，它包含的是一个长整型数据, 表示的是从GMT(格林尼治标准时间)1970年1

月1日00:00:00这一刻以前或者是以后经历的毫秒数.
– Date类提供了两个重载的构造方法
– Date()：以本地当前时间构造一个Date对象。
– Date(long date)：以距离基准（1970 年1 月1 日00:00:00 GMT）时间的毫秒值构造Date对象。
– Date date = new Date();
– System.out.println(date.getTime()); //获得毫秒值

Calendar类

java.util.Calendar类中文翻译为“日历”，Calendar类中定义了足够的方法来表述日历的规则。

– Calendar类的方便之处就在于其能够灵活的设置和获取日期对应的年、月、日、时、分、秒信息，而且能够灵活的对日期进行加
减操做。
• Calendar是一个抽象类，Java中提供了Calendar的一个具体实现类GregorianCalendar。
• 建立Calendar类型对象：
– 经过其中的静态方法Calendar.getInstance()。
– 获得的对象是一个Calendar类的对象。
• Calendar中的set(int field)和get(int field)方法能够用来
设置和读取日期的特定部分

Calendar类属性常量（一）
• HOUR：get 和set 的字段数字，指示上午或下午的小时
• DATE：set和get的字段数字，指示一个月中的某一天。
• MONTH：指示月份的get 和set 的字段数字。
• YEAR：指示年的get 和set 的字段数字。
• DAY_OF_MONTH：get 和set 的字段数字，指示一个月中的某天。
• DAY_OF_WEEK：get 和set 的字段数字，指示一个星期中的某天。
• DAY_OF_WEEK_IN_MONTH：get 和set 的字段数字，指示当前月中的第几个星期。

DAY_OF_YEAR：get 和set 的字段数字，指示当前年中的天数。
• WEEK_OF_MONTH：get 和set 的字段数字，指示当前月中的星期数。
• WEEK_OF_YEAR：get 和set 的字段数字，指示当前年中的星期数。
• HOUR_OF_DAY：get 和set 的字段数字，指示一天中的小时。
• AM_PM：get 和set 的字段数字，指示HOUR 是在中午以前仍是在中午以后。
• PM：指示从中午到午夜以前这段时间的AM_PM 字段值
• AM：指示从午夜到中午以前这段时间的AM_PM 字段值

Calendar与Date的转换
• 从一个Calendar 对象中获取Date 对象
– Calendar calendar = Calendar.getInstance();
– Date date =calendar.getTime();
• 从一个Date对象得到Calendar对象
– Calendar calendar = Calendar.getInstance();
– Date date = new Date(long 型参数);
– calendar.setTime(date);

DateFormate
• DateFormat 是日期/时间格式化的抽象类，它以与语言
无关的方式格式化并解析日期或时间。
• DateFormate实例建立
– DateFormat df = DateFormat.getDateInstance(参数)
– 参数的取值
• DateFormat.SHORT 彻底为数字，如12-9-10
• DateFormat.MEDIUM 较长，如2012-9-10
• DateFormat.LONG 更长，如2012年9月10日
• DateFormat.FULL 是彻底指定，如2012年9月10日星期一
• DateFormate格式化、解析日期的方法
– String format(Date date)：格式化日期
– Date parse(String sateStr)：解析字符串

线程和多线程

程序、进程、线程
–程序是一段静态的代码，是应用软件执行的蓝本;
–进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程自己从产生、发展至消亡的过程
–线程是比进程更小的执行单位。进程在其执行过程当中，能够产生多个线程，造成多条执行线索，每条线索，即每一个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念

Java中的线程
–若是main方法中没有建立其余的线程，那么当main方法执行完最后一个语句，JVM就会结束Java应用程序——单线程
–若是main方法中又建立了其余线程，那么JVM就要在主线程和其余线程之间轮流切换，JVM要等程序中全部线程都结束以后才结束程序——多线程

•多线程的优点:

–减轻编写交互频繁、涉及面多的程序的困难.
–程序的吞吐量会获得改善.
–由多个处理器的系统，能够并发运行不一样的线程.(不然,任什么时候刻只有一个线程在运行)
–“同时”执行是人的感受，在线程之间实际上轮换执行。

线程的生命周期
•线程完整的生命周期包括五个状态：新建、就绪、运行、阻塞和死亡.

•新建状态：线程对象已经建立，尚未在其上调用start()方法。
•可运行状态：当线程调用start方法，但调度程序尚未把它选定为运行线程时线程所处的状态。
•运行状态：线程调度程序从可运行池中选择一个线程做为当前线程时线程所处的状态。这也是线程进入运行状态的惟一方式

等待/阻塞/睡眠状态：其共同点是：线程仍旧是活的，可是当前没有条件运行。它是可运行的，当某件事件出现，他可能返回到可运行状态。

•死亡状态：当线程的run()方法完成时就认为它死去。线程一旦死亡，就不能复生。一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

Java中两种建立线程的方式：
–继承Thread类
•重写run() 方法
•new一个线程对象
•调用对象的start() 启动线程

实现Runnable接口
–实现run() 方法
–建立一个Runnable类的对象r，new MyRunnable()
–建立Thread类对象并将Runnable对象做为参数，new Thread(r)
–调用Thread对象的start()启动线程

反射

程序运行时，容许改变程序结构或变量类型——这种语言称为动态语言

– 从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言
– Java有着一个很是突出的动态相关机制：Reflection

在运行状态中，对于任意一个类，都可以知道其全部属性和方法；对于任意一个对象，都可以调用其任意一个方法；
——这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制

Java反射提供如下功能
1  在运行时判断任意一个对象所属的类
2  在运行时构造任意一个类的对象
3  在运行时判断任意一个类所具备的成员变量和方法
4  在运行时调用任意一个对象的方法
5  生成动态代理

Java反射机制中设计的类
• Class：类的实例表示正在运行的Java 应用程序中的类和接口
• Field：提供有关类或接口的属性的信息，以及对它的动态访问权限
• Constructor：提供关于类的单个构造方法的信息以及对它的访问权限
• Method：提供关于类或接口上单独某个方法的信息

Class类

• Class 类十分特殊，其实例用以表达Java程序运行时的类和接口

• 获取Class对象
– 经过Object的getClass()方法
– 经过Class的getSuperClass()方法
– 经过Class的静态forName()方法
– 对于包装器类型，经过类名.TYPE属性

Java反射机制的应用
• 操做数据库
– 动态建立SQL语句
• 解析XML
– 解析XML动态生成对象
• 动态代理
• 其它的框架中使用
– Struts框架、Spring框架、Hibernate框架

Java反射机制的缺点
• 主要的缺点是对性能有影响
– 使用反射基本上是一种解释操做，您能够告诉JVM您但愿作什么而且它知足您的要求。这类操做老是慢于直接执行相同的操做

Java8 新特性 --Lambda表达式

Lambda表达式是方法的实现
•Lambda表达式语法格式
([参数1],[参数2],…)->{ }
•做用：
–匿名内部类的简化写法

Lambda表达式的局限性
–接口
–仅包含一个抽象方法

JDK8新特性——方法引用

方法引用可看作是一个Lambda表达式

•须要一个明确的目标类型充当功能性接口的实例
–被引用的方法与功能接口的SAM(Single Abstract Method) 参数、返回类型相匹配
•借用C++ 的做用域解析操做符“::”
•做用
–提升复杂的Lambda表达式的可读性
–逻辑更清晰

方法签名与功能性接口的SAM 一致（SAM接口,即Single Abstract Method interfaces）
–功能接口有惟一的抽象方法
–引用方法的参数与抽象方法的参数列表相同
•例子：
Runnable r = MyProgram::main;
void main(String... args) 与run() 方法能配上对

方法引用形式
•静态方法(ClassName::methName)
•对象的实例方法(instanceRef::methName)
•对象的super 方法(super::methName)
•类型的实例方法(ClassName::methName, 引用时和静态方法是同样的，但这里的methName是个实例方法)
•类的构造方法(ClassName::new)
•数组的构造方法(TypeName[]::new)

JDK8新特性——Function与Stream

Function简介
•函数接口（SAM）
–一种只定义了一个抽象方法的接口
–支持lambda表达式
•java.util.function包
–专门给新增的API使用的函数接口（>40个）
•新注释@FunctionalInterface
–为了强调接口是函数接口，防止往这个接口里增长方法

Function接口的主要方法
–R apply(T t)：将Function对象应用到输入的参数上，而后返回计算结果。
•其余方法
–andThen(Function after) 返回一个先执行当前函数对象apply方法再执行after函数对象apply方法的函数对象。
–compose(Function before)返回一个先执行before函数对象apply方法再执行当前函数对象apply方法的函数对象。
–identity() 返回一个执行了apply()方法以后只会返回输入参数的函数对象

Stream接口

Stream接口
•java.util.stream包
–用不多的代码完成许多复杂的功能
–经过流来遍历集合
–从集合和数组来建立流
–聚合流的值
•更像具备Iterable的集合类，但行为和集合类又有所不一样
–Filter 过滤
–Sort 排序
–Map 映射
–Match 匹配
–Count 计数
–……

Stream接口引入目的
–为何不在集合类实现这些操做，而是定义了全新的Stream API？
•Oracle官方解释
–是集合类持有的全部元素都是存储在内存中的，很是巨大的集合类会占用大量的内存，而Stream的元素倒是在访问的时候才被计算出来，这种“延迟计算”的特性有点相似Clojure的lazy-seq，占用内存不多
–集合类的迭代逻辑是调用者负责，一般是for循环，而Stream的迭代是隐含在对Stream的各类操做中，例如map()。

Stream扩展
有多种方式生成Stream Source
•从Collection 和数组
–Collection.stream()
–Collection.parallelStream()
–Arrays.stream(T array) or Stream.of()
•从BufferedReader
–java.io.BufferedReader.lines()

有多种方式生成Stream Source
•静态工厂
•java.util.stream.IntStream.range()
•java.nio.file.Files.walk()
•本身构建
–java.util.Spliterator
•其它
–Random.ints()
–BitSet.stream()
–Pattern.splitAsStream(java.lang.CharSequence)
–JarFile.stream()

其余类和接口：
•Collector接口
•Collectors类
•IntStream接口
•DoubleStream接口
•……

Stream特性总结
•不是IO，不是集合框架，对集合对象功能的加强，它专一于对集合对象进行各类很是便利、高效的集合操做以及大批量数据操做
•借住于Lambda表达式，极大的提升编程效率和程序可读性
•它不是数据结构也没有内部存储，只是用操做管道从source抓取数据
•它不修改本身所封装的底层数据结构的数据。如filter操做会产生一个不包含被过滤元素的新Stream，而不是从source删除那些元素
•全部Stream的操做必须以lambda表达式为参数

Stream的特性
•很容易生成数组或list。
•惰性化。
•不少Stream操做是向后延迟的，一直到它弄清楚了最后须要多少数据才会开始。
•Intermediate操做永远是惰性化的。
•并行能力，当一个Stream是并行化的，就不须要再多写多线程代码，全部对它的操做会自动并行进行的
•能够是无限的大小，limit(n)和findFirst这类的short-circuiting操做能够对无限的Stream进行运算并很快完成。

Java8新特性 Annatation

Annatation做用
•帮助开发者提高代码的质量和可读性
•自动化代码分析的准确性
•功能
–做为特定的标记
–额外信息的载体
•Java 8 对Annotation 引入了两项重要的改变
–Type Annotation
–Repeating Annotation

Annatation使用
•元注解
•注解的声明
•注解的使用
•重复注解

Annatation使用——元注解
•不一样于java中的注释
•注解是一种类型，能够对方法、类、参数、包、域以及变量等添加标记(即附上某些信息)，以后经过反射将标记的信息提取出来以供使用
•java.lang.annotation包提供了4种元注解

@Target @Rentation @Document @Inherited

•@Target：表示该注解用于什么位置,可选的参数是ElementType枚举中的成员
–ElementType在SE1.8中又加入了两个成员
TYPE_PARAMETER、TYPE_USE
TYPE  类型声明(类,接口,enum)
FIELD  成员变量声明(对象,属性,enum的实例)
METHOD 方法声明
PARAMETER 参数声明
CONSTRUCTOR 构造器声明
LOCAL_VARIABLE 局部变量声明
ANNOTATION_TYPE 注解声明
PACKAGE  包声明

•@Retention: 表示须要在什么级别保存该注解信息(生命周期)，可选的参数是RetentionPolicy枚举中的成员

SOURCE  停留在java源文件,会将被编译器丢弃
CLASS  停留在class文件中,但会被VM丢弃
RUNTIME  内存中的字节码,VM在运行期间保留注解

–注意,只有声明为RUNTIME,才能够经过反射机制读取注解的信息
•@Document: 将注解包含在Javadoc中
•@Inherited: 容许子类继承父类中的注解,只针对CLASS级别的注解有效

注解的声明
•语法——关键字@interface定义
•默认继承Annotation接口
•元素：表示一些值，相似接口中无参的方法
•经过default提供默认值（不能为null）

Annatation使用——注解的使用
•必须对注解内的元素进行赋值（有默认值的元素除外）
•注解只有一个元素且该元素的名称是value的话,在使用注解的时候能够省略"value="直接写须要的值便可

Annatation使用——重复注解 @Repeatable•SE1.8引入了重复注解的特性–容许在声明同一类型时屡次使用同一个注解

Java 源码分析 一