java个人整理知识点

发展：

1.SE 标准版。
2.EE 企业版，基于SE。
3.ME 已经淘汰。

JDK、JRE和JVM：

JDK：

称为Java开发工具包（ Java Development Kit）。Java开发人士需要下载和安装JDK，目前的主流版本为JDK11。

JRE：

称之为Java SE运行时环境（Java SE Runtime Environment），提供了运行Java应用程序所必须的软件环境等。无论是开发还是运行Java应用都必须安装。

区别：

JDK包含了JRE，同时还包含了编译java源码的编译器javac，还包含了很多java程序调试和分析的工具：jconsole，jvisualvm等工具软件，还包含了java程序编写所需的文档和demo例子程序。
JRE包含JVM和类库
JVM多个系统上都有实现，使得跨平台能够实现。

javac和java：

javac.exe编译器，主要用于将高级Java源代码翻译成字节码文件。生成对应的xxx.class，即可通过java xxx执行
java.exe解释器，主要用于启动JVM对字节码文件进行解释并执行。新特性：java xxx.java可以直接在版本11运行，如果当前路径存在编译后的class，会报错。

常见操作：

1.注释

单行用//，多行用/* */，文档注释/** */可以提取

2.规范

xxx.java开头用注释声明项目名称、功能、作者、版本、备注

3.xxx.java里面要有这个类xxx

public class xxx {
	public static void main(String[] args){
	}
}

4.变量的声明方式

数据类型 变量名 = 初始值;	//其中=初始值可以省略，但;不可以省略。
变量使用之前需要声明和初始化。
不能重复声明

5.标识符的命名法则

• 由数字、字母、下划线以及$等组成，其中数字不能开头(不能区分字面值)。
• 不能使用Java语言的关键字，所谓关键字就是Java语言用于表示特殊含义
的单词。
• 区分大小写，长度没有限制但不宜过长。
• 尽量做到见名知意，支持中文但不推荐使用。
• 标识符可以给类/变量/属性/方法/包 起名字。

6.变量的输入

Scanner scanner = new Scanner(System.in);
api的使用可以参考手册index.html

基本数据类型：

概述：

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

1. byte(Byte)

byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7），最大值是 127（2^7-1，最高位为0表示非负），默认值是 0；用在大型数组中节约空间。

2. short(Short)

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；最大值是 32767（2^15 - 1）；默认值是 0；

3. int(Integer)

int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；最大值是 2,147,483,647（2^31 - 1）；一般地整型变量默认为 int 类型；默认值是 0 ；
正无穷为∞（字节'\u221e'），负无穷为-∞。print输出为Infinity。

4. long(Long)

long 数据类型是 64 位、有符号的以二进制补码表示的整数
默认值是 0L；long a = 100000L，"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

默认的数字字面值解释器声明为int类型，然后转换为定义的byte、short，int。
	但int a=25;byte b=a;解释器会报错，因为a是变量，存储的值还不固定，和数字字面值不同，所以解释器直接报错了。
如果超过int范围，会报错整数太大。需要显式加上l或L。
更大的数可以用java.math.BigInteger
	BigInteger a = new BigInteger("25025050060000000000000000");

5. float(Float)

float 数据类型是单精度、4个字节32位、符合IEEE 754标准的浮点数，可以表示7位有效数字；范围:-3.403E38~3.403E38。（因为有些位数用来表示指数，所以范围更大了）
float 在储存大型浮点数组的时候可节省内存空间；默认值是 0.0f；浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f/F(不加f的话double转float，报错)。会自动忽略超过位数。

6. double(Double)（推荐，有效位数更多）

double 数据类型是双精度、8个字节64 位、符合IEEE 754标准的浮点数，可以表示15位有效数字；范围:-1.798E308~1.798E308。
浮点数的默认类型为double类型；double类型同样不能表示精确的值，如货币；默认值是 0.0d；运算不精确。比如0.1+0.2=0.3000004。
精确可以用java.math.BigDecimal。System.out.println(new BigDecimal("0.1").add(new BigDecimal("0.2")));
例子：double d1 = 123.4。

7. boolean

boolean数据类型表示一位的信息；只有两个取值：true 和 false；默认值是 false；内存空间中所占大小没有明确的规定，可以认为是1个字节。

8. char(Character)

char类型是一个单一的 2个字节 16 位（没有符号位） Unicode 字符；
单引号。
最小值是 \u0000（即为0）；最大值是 \uffff（即为65,535，UCS-2统一码版本，其中汉字一共2w多个，基本满足各种语言的使用，最新版本UCS-4是31位字符集）；char 数据类型可以储存任何字符；
	扩展：有两个实现utf-8采用变长字节，1-4位字节变化，由于额外的标志信息,4个字节一共64029个（3个字节一共52156个，汉字常用）；utf-16两个字节
例子：
	char letter = 'A'。 
	char d=1会自动转换为ascii码对应的字符，计算机的底层只识别0和1组成的二进制序列。(int)d即可打印对应的数字。

引用数据类型：

数组、类、接口、枚举、标注

进制转换：

10转2:

二进制（ob/oB开头）中的最高位(最左边)用于代表符号位，若该位是0则表示非负数， 若该位是1则表示负数。
1.除2取余法，使用十进制整数不断地除以2取出余数，直到商为0时将余数逆序排序。
2.拆分法，将十进制整数拆分为若干个二进制权重（1，2，4，8）的和，有该权重下面 写1，否则写0。

2转10:

1.加权法，使用二进制中的每个数字乘以当前位的权重再累加起来。

负十进制转换为二进制的方式：

先将十进制的绝对值转换为二进制，然后进行按位取反再加1。（涉及到补码的概念，正负相加为0，溢出丢弃）

负二进制转换为十进制的方式：

先减1再按位取反，合并为十进制整数后添加负号。

16进制：

以0x开头

8进制：

以0开头

字节与bit：

公式：

1B(byte,字节)= 8 bit(位)

为什么？

一个字节定义为可容纳单个字符的最小bits
它并不总是8，有时是7或9。这取决于平台。
一个说法是使用8个字符（方便的2乘幂），有时他们将第8位用于奇偶校验，有时又将其用于ASCII标准的扩展。有时他们只是将第8位设置为零。
26个英文字母大小写52个, 加上10个数字,还有一些特殊符号超过了64个,所以ascll128个, 共计需要连续七组信号值, 但是早期的传输不可靠, 于是预留了一位作为奇偶校验, 共八组信号值, 一字节8位

类型转换：

自动类型转换：

从小类型到大类型之间的转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
	byte,short,char—> int —> long—> float —> double 

强制类型转换：

概述：

从大类型到小类型之间的转换

格式：

变量名 = (目标类型)源类型变量名;

数据类型转换必须满足如下规则：

// 子类也可以通过这种强制类型转换 变为父类
1. 不能对boolean类型进行类型转换。
2. 不能把对象类型转换成不相关类的对象。
3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
4. 转换过程中可能导致溢出或损失精度，例如：
	int i =128;   
	byte b = (byte)i;
	因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
	(int)23.7 == 23;        
	(int)-45.89f == -45

运算符：

算术运算符：

+ 表示加法运算符，同时可以实现字符串(至少一边即可)与其他数据类型“相连”。（表明java为弱类型语言）
- 表示减法运算符
* 表示乘法运算符
/ 表示除法运算符，只保留整数部分，要想保留小数需要其中一个为double，或者乘以0.1。不能除以0，除以0.0得到infinity，0/0得到NaN
% 表示取模/取余运算符

自增减运算符：

只能用于变量，常数不可以
a++：是一个表达式，先让a的数值作为整个表达式的最终结果，然后再让a变量加1
++：a让a变量加1，再让a的数值作为整个表达式的最终结果。少了一步声明赋值，效率更高。
a--
--a

逻辑运算符：

&& 表示逻辑与运算符，相当于"并且"，同真为真，一假为假。 
|| 表示逻辑或运算符，相当于"或者"，一真为真，同假为假。
! 表示逻辑非运算符，相当于"取反"，真为假，假为真。
逻辑运算符的操作数均为boolean表达式。

短路特性
对于逻辑与运算符来说，若第一个表达式为假则结果为假，此时跳过第 二个表达式;
对于逻辑或运算符来说，若第一个表达式为真则结果为真，此时跳过第 二个表达式;

条件/三目运算符：

条件表达式? 表达式1: 表达式2
判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2 。

赋值运算符：

= 表示赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量 原来的数值。
赋值表达式本身也有值，其本身之值即为所赋之值。
+=、 -=、 *=、 /=、 ...

注意：
	byte a=10;
	a = a+10;会报错，编译器做了优化，将a和10都变为int类型然后相加，结果为int类型。需要强转换。
	而a+=10等价于a=(byte)(a+10)，所以没有报错。

规范：
	a==2
	2==a两者的区别是少写一个等号的时候，能在编译阶段报错。

移位运算符：

<< 左移运算符，用于将数据的二进制位向左移动，右边使用0补充
	左移1位通常结果*2，在没超出范围的情况下。
>> 右移运算符，用于将数据的二进制位向右移动，左边使用符号位补充
	右移1位相当于除2
>>> 表示逻辑右移运算符，用于将数据的二进制位向右移动，左边使用0 补充。
	非负时和右移一样

位运算符：

& 表示按位与运算符，按照二进制位进行与运算，同1为1，一0为0.
| 表示按位或运算符，按照二进制位进行或运算，一1为1，同0为0.
~ 表示按位取反运算符，按照二进制位进行取反，1为0，0为1.
^ 表示按位异或运算符，按照二进制位进行异或运算，同为0，不同为1.

优先级：

[]()(方法调用)				从左到右
!~++--+(一元运算)-(一元运算)	从右到左
*/%							从左到右
+-							从左到右
<< >> >>>					从左到右
== !=						从左到右
&							从左到右
^							从左到右
|							从左到右
&&							从左到右
||							从左到右
?:							从右到左
=							从右到左

流程控制：

if语句：

if(){}
if else 
if else if else

switch case分支结构：

从上到下执行
switch(变量/表达式) {
	case 字面值1: 语句块1; break; 
	case 字面值2: 语句块2; break; ...
	default:语句块n;
}
switch()中支持的数据类型有:byte、short、char以及int类型，从jdk1.5 开始支持枚举类型，从jdk1.7开始支持String类型。
case穿透：如果执行了一个case没有break，会执行下一行直到break；
default和位置顺序无关，总是在匹配不到的时候才执行。

for循环：

for(初始化表达式; 条件表达式; 修改初始值表达式) { 循环体;
}
for(;;) - 这种没有循环条件的循环叫做 无限循环，俗称“死循环”。
如果要退出外层循环体，需要使用标号的方式。
	outer: for (...) {
		for(...) {
			break outer;
		}
	}

while循环：

while(条件表达式) { 
	循环体;
}
注意：
	while(条件表达式);{}相当于
	while(条件表达式){:}{}，这会导致i不会增加， 空语句，用于延时。

do while循环(熟悉):

do { 
	循环体;
} while(条件表达式);		//这里有个分号

数组：

概述：

Java 语言中提供的数组是用来存储固定大小的同类型元素。

声明：

首先必须声明数组变量，才能在程序中使用数组。
dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法，dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

创建：

dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};
dataType[] arrayRefVar = new dataType[]{value0, value1, ..., valuek};
示例：
	int[] arr = new int[2];默认值填充

索引：

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

遍历：

for (int i = 1; i < myList.length; i++)
for(type element: array)

内存结构分析：

栈区
	栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开 始到结束会有多次变量的声明。
堆区
	JVM会在其内存空间中开辟一个称为“堆”的存储空间，这部分空间用于存 储使用new关键字创建的数组和对象。
	示例：
		int[] a = new int[2];这句话，先在栈区声明一个变量，然后在堆区初始化数组，最后赋值操作是在栈区存储堆区的内存地址（引用类型）

增删改查：

数组赋值arr=brr，会把brr的内存地址赋值给arr，arr的长度元素都变为brr。
拷贝：System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

优缺点：

可以直接通过下标(或索引)的方式访问指定位置的元素，速度很快。 
数组要求所有元素的类型相同。
数组要求内存空间连续，并且长度一旦确定就不能修改。
增加和删除元素时可能移动大量元素，效率低。

Arrays 类：

java.util.Arrays 类能方便地操作数组（遍历、查找、排序），它提供的所有方法都是静态的。
方法：
	static String toString(int[] a)
	public static void fill(int[] a, int val)	//将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
		示例：
			Arrays.fill(a, 1,3,10);	将1到3不含3的位置的元素填充为10，注意不能超索引
	public static void sort(Object[] a)		//对指定对象数组根据其元素的自然顺序进行升序排列。
	public static boolean equals(long[] a, long[] a2)	//如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。返回true
	public static int binarySearch(Object[] a, Object key)	//用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。
			//数组在调用前必须排序好的(二分查找)。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
	copyOfRange(li,start,end)切片复制，生成另一个数组

二维数组：

声明和初始化：

数据类型[][] 数组名称 = new 数据类型[行数][列数]; 		其中列数可以忽略。表示不定长。
数据类型[][] 数组名称 = {{元素1, 元素2，...}, ...};

面向对象编程：

概念：

面向对象指以属性和行为的观点去分析现实生活中的事物。
面向对象编程指先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程。
面向过程指侧重具体的步骤，面向对象则是针对能实现步骤的对象。

理解面向对象的思想精髓(封装、继承、多态)，至少掌握一种编程语言。

类和对象的概念：

类简单来就是“分类”，是对具有相同特征和行为的多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征/属性的成员变量以及描述行为的成员方法。
类是用于构建对象的模板，对象的数据结构由定义它的类来决定。

类和成员变量的定义：

class 类名{		通常情况下，当类名由多个单词组成时，要求每个单词首字母都要大写。
	类体;
	数据类型成员变量名= 初始值;		当成员变量由多个单词组成时，通常要求从第二个单词起每个单词的首字母大写。 初始值一般不写
}

对象的创建：

a.当一个类定义完毕后，可以使用new关键字来创建该类的对象，这个过程叫做类的实例化。
b.创建对象的本质就是在内存空间的堆区申请一块存储区域，用于存放该对象独有特征信息。
成员变量的默认值： 
	当变量作为作为类成员使用时，java才确保给定其初始值，防止程序运行时错误。
	byte short int long float double char  0/'/uoooo'
	boolean false 
	引用类型 null

引用的定义：

基本概念：

a.使用引用数据类型定义的变量叫做引用型变量，简称为"引用"。
b.引用变量主要用于记录对象在堆区中的内存地址信息，便于下次访问。

语法格式：

类名引用变量名;
引用变量名.成员变量名;

方法：

定义：

class 类名{
	返回值类型 成员方法名(形参列表) {		当成员方法名由多个单词组成时，要求从第二个单词起每个单词的首字母大写
		成员方法体;
	}
}	
方法内访问成员可以直接访问。
数据类型形参变量名1, 数据类型形参变量名2, ...

调用：

引用变量名.成员方法名(实参列表);

可变长参数：

返回值类型方法名(参数的类型... 参数名) 类型固定，看作数组即可。
方法参数部分指定类型的参数个数是可以改变的，也就是0~n个。
一个方法的形参列表中最多只能声明一个可变长形参，并且需要放到参数列表的末尾。
基于数组的实现的语法糖

参数传递：

值传递。把实参传递给形参，方法内部其实是在使用形参。
基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间；
引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间
	当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间。
形参和实参不能同名，否则当作形参了。

内存结构：

栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次方法的调用。
JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据。
当某一个方法调用完成后，其对应的栈帧将被清除。

构造方法：

class 类名{
	类名(形参列表) {
		构造方法体;
	}
}
构造方法名与类名完全相同并且没有返回值类型，连void都不许有。
支持重载。
使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。
this可以在构造方法里调用其他构造方法
默认构造方法：
	当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造构造方法，叫做默认/缺省构造方法，如：Person(){}
	若类中出现了构造方法，则编译器不再提供任何形式的构造方法。

方法引用：

方法引用通过方法的名字来指向一个方法，可以使语言的构造更紧凑简洁，减少冗余代码。
使用一对冒号 :: 

1. 构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
	final Car car = Car.create( Car::new );
	final List< Car > cars = Arrays.asList( car );

2. 静态方法引用：它的语法是Class::static_method，实例如下：
	cars.forEach( Car::collide );

3. 特定类的任意对象的方法引用：它的语法是Class::method实例如下：
	cars.forEach( Car::repair );

4. 特定对象的方法引用：它的语法是instance::method实例如下：
	final Car police = Car.create( Car::new );
	cars.forEach( police::follow );

方法重载：

若方法名称相同，参数列表（类型、个数、顺序）不同，这样的方法之间构成重载关系(Overload)。
和返回类型无关。
实际意义
	调用者只需要记住一个方法名就可以调用各种不同的版本，来实现各种不同的功能。

this关键字:

若在构造方法中出现了this关键字，则代表当前正在构造的对象。可以print验证。
若在成员方法中出现了this关键字，则代表当前正在调用的对象。
this关键字本质上就是当前类类型的引用变量。
工作原理：
	在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于汉语中"我的"，
	当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之不同。
使用方式：
	1.当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量是成员变量（重中之重）。
	2.this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以作为方法的返回值（重点）。
	3.在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法（了解）。

递归：

使用递归必须有递归的规律以及退出条件。
使用递归必须使得问题简单化而不是复杂化。
若递归影响到程序的执行性能，则使用递推取代之。比如费氏数列

代码拆分：

默认导入同级的class，main方法单独放到xxxTest.java当中。

封装：

私有化成员变量，使用private关键字修饰。
提供公有的get和set方法，并在方法体中进行合理值的判断。
在构造方法中调用set方法进行合理值的判断。
JavaBean
	一种Java语言写成的可重用组件，其它Java 类可以通过反射机制发现和操作这些JavaBean 的属性。
	JavaBean本质上就是符合以下标准的Java类：
		类是公共的
		有一个无参的公共的构造器
		有属性，且有对应的get、set方法

static关键字：

基本概念：

使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。
static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。	

使用方式：

在非静态成员方法中既能访问非静态的成员又能访问静态的成员。(成员：成员变量+ 成员方法，静态成员被所有对象共享)
在静态成员方法中只能访问静态成员不能访问非静态成员。(成员：成员变量+ 成员方法，因为此时可能还没有创建对象)
	静态变量可以通过静态方法修改访问
在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰。(不能滥用static关键字)

内存结构：

静态变量位于方法区（代码区）。指向可能是堆区（单例模式的对象）。

单例设计模式：

流程：

1.私有化构造方法，使用private关键字修饰。
2.声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰。
3.提供公有的get方法负责将对象返回出去，并使用public static关键字共同修饰。

实现方式：

饿汉式和懒汉式（if null==xxx再创建），在以后的开发中推荐饿汉式（避免多线程问题）。
双重检查锁
	问题：
		并发场景下，初始化Singleton 和 将对象地址写到instance字段 的顺序是不确定的。
		在某个线程new Singleton()时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了。
		然而该对象可能还没有初始化（初始化赋值的业务逻辑）。此时若另外一个线程来调用getInstance，取到的就是状态不正确的对象。（比如一些变量还没赋值完成。））
双重检查锁 + volatile：
	禁止未初始化完成时，就将内存地址赋值给instance字段。

构造块和静态代码块：

构造块：

在类体中直接使用{}括起来的代码块。每创建一个对象都会执行一次构造块。

静态代码块：

使用static关键字修饰的构造块。静态代码块随着类加载时执行一次。先于构造块执行（加载阶段），比如加载数据库的驱动包等。

子类构造时执行顺序：

先加载父类，再加载子类，在执行父类的无参构造方法（会先执行构造块），再执行子类的构造方法

继承：

概念：

当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。

格式：

在Java语言中使用extends(扩展)关键字来表示继承关系。
public class Worker extends Person{} -表示Worker类继承自Person类
	其中Person类叫做超类、父类、基类。
	其中Worker类叫做派生类、子类、孩子类。
使用继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件。

特点：

子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问（可以通过public方法来访问）。
无论使用何种方式构造子类的对象时，都会首先自动调用父类的无参构造方法（没有super的情况下），来初始化从父类中继承的成员变量以及自己的单独成员变量（super()方法做的事情）。
相当于在构造方法的第一行增加代码super()的效果。
	可以手动加super()则解释器不再加（不是第一行会报错）。
	也可以super(实参列表)，这样就不再调用父类的无参构造方法
	如果子类不定义任何构造方法，如果父类定义有参，需要父类定义无参构造方法以便super调用。
	如果子类定义了无参构造方法，也需要父类定义无参构造方法以便super隐式或者显式调用。
	如果子类定义了有参构造方法，可以不定义无参，需要父类定义有参或者无参构造方法，以便super隐式或者显式调用。
	总结：一般都定义比较好。
Java语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类。

方法重写：

从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做方法的重写（Override）
调用父类方法：
	super.function()
示例： 
	@override			# 说明重写，若没有重写则编译报错。
	public void show(){
		super.function()
		xxx
	}
原则：
	要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许返回类型为子类类型。
	要求方法的访问权限不能变小，可以相同或者变大。（继承本身是扩展，不能变小）
	要求方法不能抛出更大的异常(异常机制)。
静态方法： 
	不能标注@override，但可以起同名的。

访问控制符：

public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
default (即默认）: 在同一包内可见（不同包内的子类不行），不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

package包：

格式：

package 包名;
package 包名1.包名2.包名3...包名n;

规范：

org.apache.commons.lang.StringUtil
其中StringUtils是类名而org.apache.commons.lang是多层包名，其含义如下：
org.apache表示公司或组织的信息（是这个公司（或组织）域名的反写）；common 表示项目的名称信息；lang 表示模块的名称信息。	

导入：

使用import关键字导入包。
使用import关键字导入一个包的静态成员，从Java5.0开始支持。

final关键字：

final关键字修饰类体现在该类不能被继承。
	-主要用于防止滥用继承，如：java.lang.String类等。
final关键字修饰成员方法体现在该方法不能被重写但可以被继承（即只能调用）。
	-主要用于防止不经意间造成重写，如：java.text.Dateformat类中format方法等。
final关键字修饰成员变量体现在该变量必须初始化（一开始显式初始化或者延迟在构造块/方法中初始化）且不能改变。
	-主要用于防止不经意间造成改变，如：java.lang.Thread类中MAX_PRIORITY等。

常量：

在以后的开发中很少单独使用final关键字来修饰成员变量
通常使用public static final关键字共同修饰成员变量来表达常量的含义，常量的命名规范要求是所有字母都要大写，不同的单词之间采用下划线连。
	public static 修饰的常量作用域是全局的，不需要创建对象就可以访问它

多态：

格式：

父类类型引用变量名= new 子类类型();
如Shape sr= new Rect();

特点：

当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法，不可以直接调用子类独有的方法(编译会报错，需要强转)。		
对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）（如果子类没有则调用父类）。
对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。

引用数据类型之间的转换：

引用数据类型之间的转换方式有两种：自动类型转换和强制类型转换。
	自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也叫做向上转型。（多态调用）
	强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也叫做向下转型或显式类型转换。
条件：
	1.引用数据类型之间的转换必须发生在父子类之间，否则编译报错。
	2.如果转换发生在父级和兄弟子类或者孙类这种不是父子关系时，编译阶段不报错，但运行阶段会报ClassCastException。
		若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常。
使用：
	为了避免上述错误的发生，应该在强转之前进行判断，格式如下：
		if(引用变量instanceof数据类型)
	判断引用变量指向的对象是否为后面的数据类型

实际意义:

屏蔽不同子类的差异性实现通用的编程带来不同的效果。

多态存在的三个必要条件：

1.继承

2.重写

3.父类引用指向子类对象 //Parent p = new Child();

多态的实现方式：

方式一：重写
方式二：接口
方式三：抽象类和抽象方法	

多态的使用场景：

1.通过方法的参数传递形成多态

2.抽象类或接口类的引用指向子类,在方法体中直接使用多态的语法格式

3.通过方法的返回值类型形成多态

虚函数：

虚函数的存在是为了多态。
Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。
如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。
重写： 
	当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。要想调用父类中被重写的方法，则必须使用关键字 super。
示例：	
	Salary s = new Salary("员工 A", "北京", 3, 3600.00);
	Employee e = new Salary("员工 B", "上海", 2, 2400.00);
	在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 
	但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法
	以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。
	Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。	

抽象方法：

概述：

主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体。

格式：

访问权限 abstract 返回值类型 方法名(形参列表);

兼容的访问权限：

不能private，私有方法不能继承
不能final，需要修改。
不能static，抽象方法不能提升为类层级
default需要同一包内。

抽象类：

概念：

主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。
和普通类的区别：
	不能具体实例化
	声明了抽象方法。

特点：

抽象类中可以有成员变量、构造方法、成员方法（供子类super调用）
抽象类中可以没有抽象方法，也可以有抽象方法（抽象类不能实例化，防止误调用抽象方法）；
拥有抽象方法的类必须是抽象类
因此真正意义上的抽象类应该是具有抽象方法（不能实例化的意义所在）并且使用abstract关键字修饰的类。

实际意义：

抽象类的实际意义不在于创建对象而在于被继承。
当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。

格式：

public abstract class Employee
{
   public abstract double computePay();
   //其余代码
}

接口：

概述：

一种比抽象类还抽象的类，体现在所有方法都为抽象方法。

定义：

定义类的关键字是class，而定义接口的关键字是interface。
里面只能声明常量，可以忽略public static final 
从jdk1.9开始允许接口出现私有方法。
方法可以忽略public abstract

支持的修饰符：

public 
private

实际意义：

类可以实现多个接口，达到多继承的效果

格式：

Interface关键字用来声明一个接口。
[可见度] interface 接口名称 [extends 其他的接口名] {
		// 声明变量
		// 抽象方法
}

使用：

implements A,B 支持多实现，接口之间可以继承。
然后
	A xxx = new yyy();可以调用A接口的方法
	B xxx = new yyy();可以调用B接口的方法

标记接口：

最常用的继承接口是没有包含任何方法的接口。
标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。
	public interface EventListener
	{}
没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：
	1. 建立一个公共的父接口：
		正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。
		例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
	2. 向一个类添加数据类型：
		这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。		

类和接口之间的关系：

名称							关键字							关系
类和类之间的关系  		使用extends关键字表达继承关系  		支持单继承
类和接口之间的关系 		使用implements关键字表达实现关系  	支持多实现
接口和接口之间的关系 	使用extends关键字表达继承关系 		支持多继承

抽象类和接口的主要区别：

定义抽象类的关键字是abstract class，而定义接口的关键字是interface。
继承抽象类的关键字是extends，而实现接口的关键字是implements。
继承抽象类支持单继承，而实现接口支持多实现。（区别3）
抽象类中可以有构造方法，而接口中不可以有构造方法。（区别1）
抽象类中可以有成员变量，而接口中只可以有常量。（区别2）
抽象类中可以有成员方法，而接口中只可以有抽象方法。
抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需要重写（Java8以前的版本）。
从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法（工具类功能），但非抽象方法需要使用default关键字修饰(表示接口的默认功能方法，子类可以选择性重写)。
从Java9开始增加新特性，接口中允许出现私有方法。（一般用于定义一些基础方法，供default和static方法调用）

函数式接口：

一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。
如：
	@FunctionalInterface
	interface GreetingService 
	{
		void sayMessage(String message);
	}
那么就可以使用Lambda表达式来表示该接口的一个实现(注：JAVA 8 之前一般是用匿名类实现的)：
	GreetingService greetService1 = message -> System.out.println("Hello " + message);

内部类：

基本概念：

当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。
# 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类。

实际作用：

当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。

分类：

普通内部类-直接将一个类的定义放在另外一个类的类体中。
静态内部类-使用static关键字修饰的内部类，隶属于类层级。
局部内部类-直接将一个类的定义放在方法体的内部时。
匿名内部类-就是指没有名字的内部类。

普通（成员）内部类：

定义：

属于外部类的一个成员，能直接调用外部类的其他成员

特点：

普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
普通内部类和普通类一样可以使用final(限制内部类的继承)或者abstract关键字修饰。
普通内部类还可以使用private（不能用于实例化）或protected关键字进行修饰。
普通内部类需要使用外部类对象来创建对象。Outer.Inner in = ot.new Inner();
如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字。（遵循局部优先原则，this/Outer.this分别访问内部和外部对象）

静态内部类：

格式：

访问修饰符staticclass 内部类的类名

使用方式：

静态内部类不能直接访问外部类的非静态成员，可以直接访问静态成员。
静态内部类可以直接创建对象。Outer.Inner in = new Outer.Inner();
如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。

局部（方法）内部类:

格式：

class 内部类的类名
没有修饰符（类似局部变量）

使用方式：

局部内部类只能在该方法的内部可以使用。
局部内部类可以在方法体内部直接创建对象。
局部内部类不能使用访问控制符和static关键字修饰符。
局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
	默认的局部变量从java8开始默认理解为final关键字修饰的变量，如果修改了，会报错。
	原因是防止局部变量拷贝到内部类中修改了，造成内外不一致。（防止修改）

回调模式：

如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。
使用： 
	自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递；
	使用上述匿名内部类的语法格式得到接口/类类型的引用即可；

匿名内部类：

格式：

接口/父类类型 引用变量名= new 接口/父类类型() {方法的重写};
# lambda表达式更简单()->{}

优点：

省去了为类起名字的烦恼

lambda表达式：

概述：

声明一个函数
一种没有声明的方法，即没有访问修饰符，返回值声明和名称。（但是可以返回，类型推断机制）

用途：

1.简写函数式接口（Functional Interface）

2.声明函数，用于其他高阶函数接收，比如列表foreach，字典map

限制：

不能使用闭包
在lambda表达式中对变量的操作都是基于原变量的副本，不会影响到原变量的值。
只能引用标记了 final 的外层局部变量，否则会误以为外部变量的值能够在lambda表达式中被改变。

更先进的写法：

双冒号操作符

枚举：

概述：

在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类型。

之前的实现方法：

在class中定义多个常量，给外部访问。
缺点：
	重复声明比较多

定义：

•使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
•枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。
•枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的。

示例：

public enum DirectionEnum {
	UP("up"),DOWN("down");

	private final String desc;

	private DirectionEnum(String desc) {
		this.desc = desc;
	}
}

switch使用：

function(Enum de){
	switch(de){
		case UP:
		case DOWN:
	}
}
更简洁，对输入类型更限制

Enum类：

概念：

所有的枚举类都继承自java.lang.Enum类

方法：

static T[] values()返回当前枚举类中的所有对象
String toString()返回当前枚举类对象的名称
intordinal()获取枚举对象在枚举类中的索引位置
static T valueOf(String str)将参数指定的字符串名转为当前枚举类的对象，要求字符串必须对应存在
intcompareTo (E o)比较两个枚举对象在定义时的顺序，结果为1，0，-1，-2等，当调用对象在参数对象之后时，获取到的比较结果为正数。

实现接口：

不能继承，可以实现。
枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象都重写。
每个对象都重写：
	UP("up"){重写方法}
	本质上是匿名内部类

注解：

基本概念：

注解（Annotation）又叫标注，是从Java5开始增加的一种引用数据类型。
注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理。

语法格式：

访问修饰符@interface 注解名称{
	注解成员;
}
自定义注解自动继承java.lang.annotation.Annotation接口。
若一个注解中没有任何的成员，则这样的注解叫做标注注解/标识注解。
注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。
如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum类型及Annotation类型。
成员变量可以有默认值：private String value() default "";
如： 
	public String value();

使用：

通过@注解名称的方式可以修饰包、类、成员方法、成员变量、构造方法、参数、局部变量的声明等。
@MyAnnotation(value=xxx,value2=yyy)

元注解:

概述：

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。

分类：

元注解主要有@Retention、@Documented、@Target、@Inherited、@Repeatable。

元注解@Retention:

•@Retention 应用到一个注解上用于说明该注解的的生命周期，取值如下：

•RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
•RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到JVM 中，默认方式。
•RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到JVM 中，所以在程序运行时可以获取到它们。
元注解@Documented
•使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容。
•@Documented用于指定被该注解将被javadoc工具提取成文档。
•定义为@Documented的注解必须设置Retention值为RUNTIME。
元注解@Target
用于指定被修饰的注解能用于哪些元素的修饰
ElementType.ANNOTATION_TYPE可以给一个注解进行注解
ElementType.CONSTRUCTOR可以给构造方法进行注解
ElementType.FIELD可以给属性进行注解
ElementType.LOCAL_VARIABLE可以给局部变量进行注解
ElementType.METHOD可以给方法进行注解
ElementType.PACKAGE可以给一个包进行注解
ElementType.PARAMETER可以给一个方法内的参数进行注解
ElementType.TYPE可以给类型进行注解，比如类、接口、枚举

从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：

ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中，如：泛型。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。场景更广泛。

元注解@Inherited:

@Inherited并不是说注解本身可以继承，而是说如果一个超类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解。

元注解@Repeatable:

表示自然可重复的含义，从Java8开始增加的新特性。
示例： 
	@Repeatable(value=ManTypes.class)
默认不能重复。java8之前可以通过注解数组的方式@manTypes({@ManType(value=""),@ManType(value="")})

常见的预制注解：

@author标明开发该类模块的作者，多个作者之间使用,分割
@version标明该类模块的版本
@see参考转向，也就是相关主题
@since从哪个版本开始增加的
@param对方法中某参数的说明，如果没有参数就不能写
@return对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception对方法可能抛出的异常进行说明	
@Override限定重写父类方法, 该注解只能用于方法
@Deprecated用于表示所修饰的元素(类, 方法等)已过时
@SuppressWarnings抑制编译器警告

Object类：

基本概念：

java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类。
如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类。
Object类定义了“对象”的基本行为, 被子类默认继承。

常用的方法：

Object() 使用无参方式构造对象
boolean equals(Object obj)用于判断调用对象是否与参数对象相等。该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致若希望比较两个对象的内容，则需要重写该方法。
	若该方法被重写后，则应该重写hashCode方法来保证结果的一致性（不然放到字典中时，两个相等的对象存的位置不同）。
	需要强转来调用子类的独有方法。
	自反性、对称的、传递性、一致的、对于任何非空的参考值x ， x.equals(null)应该返回false。 
	优化：需要判断是否地址相同，是否为null
int hashCode()用于获取调用对象的哈希码值(内存地址的编号)。
	若两个对象调用equals方法相等，则各自调用该方法的结果必须相同。
	若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同。
	为了使得该方法与equals方法保持一致，需要重写该方法。一般加个固定值。不然很可能会因为存储了两个equals相等的数据而导致存储数据的不唯一性，导致内存泄露。
	非基本类型可以用对应的引用类型的hashCode方法
String toString()用于获取调用对象的字符串形式。该方法默认返回的字符串为：包名.类名@哈希码值的十六进制。
	为了返回更有意义的数据，需要重写该方法。使用print或println打印引用或字符串拼接+引用都会自动调用该方法
Class getClass() 用于返回调用对象执行时的Class实例，反射机制使用

包装类：

概念：

通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。	

内置：

java.lang.Byte 			byte
java.lang.Short 		short
java.lang.Integer 		int
java.lang.Long 			long
java.lang.Float 		float
java.lang.Double 		double		// java.lang.Number类是个抽象类，是上述类的父类来描述所有类共有的成员。
java.lang.Boolean 		boolean
java.lang.Character 	char

Integer类：

基本概念：

java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。

常用的常量：

public static final int MAX_VALUE 表示int类型可以描述的最大值，即2^31-1
public static final int MIN_VALUE 表示int类型可以描述的最小值，即-2^31
public static final int SIZE 表示int类型采用二进制补码形式的位数
public static final int BYTES 表示int类型所占的字节个数
public static final Class TYPE 表示int类型的Class实例

常用的方法：

Integer(int value) 根据参数指定的整数来构造对象（已过时）
Integer(String s) 根据参数指定的字符串来构造对象 （已过时）
int intValue() 获取调用对象中的整数值并返回
static Integer valueOf(int i) 根据参数指定整数值得到Integer类型对象，也可以传string
boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等
String toString() 返回描述调用对象数值的字符串形式
static int parseInt(String s) 将字符串类型转换为int类型并返回
static String toString(int i) 获取参数指定整数的十进制字符串形式
static String toBinaryString(int i) 获取参数指定整数的二进制字符串形式
static String toHexString(int i) 获取参数指定整数的十六进制字符串形式
static String toOctalString(int i) 获取参数指定整数的八进制字符串形式

装箱和拆箱的概念：

在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。
从Java5开始增加了自动拆箱和自动装箱的功能。

自动装箱池：

在Integer类的内部提供了自动装箱池技术（vm cache，可以调优），将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
	Interger it = 100;	注意会自动装箱，超过128的会导致it1==it2为false，但数值相等。小于128的内存地址会一致。
	int ib = it;

Double类：

概述：

java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法。

常用的方法：

double doubleValue() 获取调用对象中的浮点数据并返回
static Double valueOf(double d) 根据参数指定浮点数据得到Double类型对象
static double parseDouble(String s) 将字符串类型转换为double类型并返回
boolean isNaN() 判断调用对象的数值是否为非数字。0/0.0为nan

装箱和拆箱：

Double d = 3.14;
double d2 = d;
没有装箱池

Boolean类:

概述；
	java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean类型的包装并提供boolean类型到String类之间的转换等方法。
常用的方法:
	boolean booleanValue() 获取调用对象中的布尔数值并返回
	static Boolean valueOf(boolean b) 根据参数指定布尔数值得到Boolean类型对象，内部调用parseBoolean方法
	static boolean parseBoolean(String s) 将字符串类型转换为boolean类型并返回，内部用的是"true".equalsIgnoreCase(s)，其他情况都返回false
装箱和拆箱：
	类似

Character类：

概述：

主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。

常用的方法：

char charValue() 获取调用对象中的字符数据并返回
static Character valueOf(char c) 根据参数指定字符数据得到Character类型对象
boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等
String toString() 返回描述调用对象数值的字符串形式
static boolean isUpperCase(char ch) 判断参数指定字符是否为大写字符
static boolean isLowerCase(char ch) 判断参数指定字符是否为小写字符
static boolean isDigit(char ch) 判断参数指定字符是否为数字字符
static char toUpperCase(char ch) 将参数指定的字符转换为大写字符
static char toLowerCase(char ch) 将参数指定的字符转换为小写字符

数学处理类:

math类：

java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。
常用的方法:
	static int max(int a, int b) 返回两个参数中的最大值
	static int min(int a, int b) 返回两个参数中的最小值
	static double pow(double a, double b) 返回第一个参数的幂
	static int abs(int a) 返回参数指定数值的绝对值
	static long round(double a) 返回参数四舍五入的结果
	static double sqrt(double a) 返回参数的平方根
	static double random() 返回0.0到1.0的随机数

BigDecimal类：

概念：

由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型加以描述。
常用的方法
BigDecimal(String val) 根据参数指定的字符串来构造对象
BigDecimal add(BigDecimal augend) 用于实现加法运算
BigDecimal subtract(BigDecimal subtrahend) 用于实现减法运算
BigDecimal multiply(BigDecimal multiplicand) 用于实现乘法运算
BigDecimal divide(BigDecimal divisor) 用于实现除法运算，注意：必须要除尽。否则抛出ArithmeticException。
BigDecimal divide​(BigDecimal divisor, int roundingMode)常用RoundingMode.HALF_UP，需要import

BigInteger类：

概念：

若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述。

常用的方法：

BigInteger(String val) 根据参数指定的字符串来构造对象
BigInteger add(BigInteger val) 用于实现加法运算
BigInteger subtract(BigInteger val) 用于实现减法运算
BigInteger multiply(BigInteger val) 用于实现乘法运算
BigInteger divide(BigInteger val) 用于实现除法运算
BigInteger remainder(BigInteger val) 用于实现取余运算
BigInteger[] divideAndRemainder(BigInteger val) 用于实现取商和余数的运算

String类:

概念（重点）：

1.java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如："abc"。
	只有String可以new + 字面值
2.该类由final关键字修饰，表示该类不能被继承。
3.从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成 byte[]（1个字节）加上编码标记，从而节约了一些空间。
4.该类描述的字符串内容是个常量不可更改，因此可以被共享使用。
	如：
		String str1 = “abc”; - 其中"abc"这个字符串是个常量不可改变。在方法区（常量区）声明这个常量后，将地址返回给变量。
		str1 = “123”; - 将“123”字符串的地址赋值给变量str1。
					  - 改变str1的指向并没有改变指向的内容

常量池的概念（原理）：

由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，
从而提高了性能。
特殊情况：
	"ab"和"a"+"b"是同一个，常量优化机制。常量是固定的。
	如果是其中一个是变量，则不是同一个地址。
	即String s1 = "abc";		String s2 = "a" + "bc";		s1==s2;
	而String s11 = "a";		String s22 = "bc";		String s6 = s11 + s22;	s1!=s6;
验证： 
	声明两个相同的字符串，比较两个变量的内存地址即可。
intern()方法：
	首先检查字符串池中是否有”abc”这个字符串，如果存在则返回这个字符串的引用，否则就将这个字符串添加到字符串池中，然会返回这个字符串的引用。

常用的构造方法：

String() 使用无参方式构造对象得到空字符序列
String(byte[] bytes, int offset, int length)使用bytes数组（ascii码）中下标从offset位置开始的length个字节来构造对象。原理：逐个翻译字节数字。
String(byte[] bytes) 使用bytes数组中的所有内容构造对象
String(char[] value, int offset, int count)使用value数组中下标从offset位置开始的count个字符来构造对象
String(char[] value) 使用value数组中的所有内容构造对象
String(String original)根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本。两个对象，一个在常量池，一个在堆区（new）。

常用的成员方法：

String toString() 返回字符串本身
byte[] getBytes() 将当前字符串内容转换为byte数组并返回		思路：拆分字符串为多个字符，然后转换为数字
char[] toCharArray() 用于将当前字符串内容转换为char数组并返回	

char charAt(int index) 方法charAt用于返回字符串指定位置的字符。
int length() 返回字符串字符序列的长度。
boolean isEmpty() 判断字符串是否为空，底层判断长度。

int compareTo(String anotherString) 用于比较调用对象和参数对象的大小关系。逐字符比较，返回的一个不同字符的ascii码数值相差。如果是长度不同，返回的一个长度减去第二个长度。
int compareToIgnoreCase(String str) 不考虑大小写，也就是'a'和'A'是相等的关系

String concat(String str) 用于实现字符串的拼接。更简单用+
boolean contains(CharSequence s) 用于判断当前字符串是否包含参数指定的内容,CharSequence是接口，String实现了该接口
String toLowerCase() 返回字符串的小写形式
String toUpperCase() 返回字符串的大写形式
String trim() 返回去掉前导和后继空白的字符串
boolean startsWith(String prefix) 判断字符串是否以参数字符串开头
boolean startsWith(String prefix, int toffset) 从指定位置开始是否以参数字符串开头
boolean endsWith(String suffix) 判断字符串是否以参数字符串结尾

boolean equals(Object anObject) 用于比较字符串内容是否相等并返回，逐字符比较。
int hashCode() 获取调用对象的哈希码值
boolean equalsIgnoreCase(String anotherString)用于比较字符串内容是否相等并返回，不考虑大小写，如：'A'和'a'是相等

int indexOf(int ch)用于返回当前字符串中参数ch指定的字符第一次出现的下标，失败返回-1
int indexOf(int ch, int fromIndex) 用于从fromIndex位置开始查找ch指定的字符
int indexOf(String str)在字符串中检索str返回其第一次出现的位置（第一个字符的下标），若找不到返回-1
int indexOf(String str, int fromIndex)表示从字符串的fromIndex位置开始检索str第一次出现的位置
int lastIndexOf(int ch) 用于返回参数ch指定的字符最后一次出现的下标
int lastIndexOf(int ch, int fromIndex)用于从fromIndex位置开始反向查找ch指定字符出现的下标
int lastIndexOf(String str) 返回str指定字符串最后一次出现的下标
int lastIndexOf(String str, int fromIndex)用于从fromIndex位置开始反向搜索的第一次出现的下标。

String substring(int beginIndex, int endIndex)返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串
String substring(int beginIndex)返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串

boolean matches(String regex)判断当前正在调用的字符串是否匹配参数指定的正则表达式规则

String[] split(String regex)参数regex为正则表达式，以regex所表示的字符串为分隔符，将字符串拆分成字符串数组
String replace(char oldChar, char newChar)使用参数newChar替换此字符串中出现的所有参数oldChar
String replaceFirst(String regex,String replacement)替换此字符串匹配给定的正则表达式的第一个子字符串
String replaceAll(String regex,String replacement)将字符串中匹配正则表达式regex的字符串替换成replacement

字符串数字转整数：

int ib=0;
for(int i=0;i

整数转字符串：

String.valueof()
""+123

可变字符串类：

基本概念：

由于String类描述的字符串内容是个常量不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。
为了解决上述问题，可以使用java.lang.StringBuilder类和java.lang.StringBuffer类来描述字符序列可以改变的字符串，如："ab"。
StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低。
StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，效率比较高。
作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder会改变其值。
为什么修改本身，还有返回本身？
	为了连续调用。
如何在StringBuilder和String之间互转？
	toString方法
	构造方法
性能排行？
	string < stringBuffer < stringBuilder

常用的构造方法：

StringBuilder() 使用无参方式构造对象，容量为16
StringBuilder(int capacity) 根据参数指定的容量来构造对象，容量为参数指定大小
StringBuilder(String str) 根据参数指定的字符串来构造对象，容量为：16+字符串长度

常用的成员方法：

int capacity() 用于返回调用对象的容量
int length() 用于返回字符串的长度，也就是字符的个数
StringBuilder insert(int offset, String str)插入字符串并返回调用对象的引用，就是自己。原值也改变了（不同于String）。
StringBuilder append(String str) 追加字符串，还可以是CharSequence、StringBuffer等形参。
StringBuilder deleteCharAt(int index)将当前字符串中下标为index位置的单个字符删除
StringBuilder delete(int start，int end) 删除字符串
StringBuilder replace(int start，int end，String str)替换字符串
StringBuilder reverse() 字符串反转
还有charAt查找、indexOf、LastIndexOf、subString、setCharAt等。

容量的扩容算法：

底层采用byte[]来存放
ensureCapacityInternal(count + len);	确保容量往后满足。
        putStringAt(count, str);		放到count的位置。coutn表示当前char用了多少

private void ensureCapacityInternal(int minimumCapacity) {
	int oldCapacity = value.length >> coder;		# value是底层byte数组。coder是编码相关，在utf16是1，在LATIN1是0
	if (minimumCapacity - oldCapacity > 0) {		# 容量不满足时，发生扩容
		value = Arrays.copyOf(value,
				newCapacity(minimumCapacity) << coder);		# 翻倍
	}
}
newCapacity方法具体算出新容量，utf16为最低长度的2倍或者2*旧容量+4，LATIN1是2*旧容量+2或者最低长度，具体配置通过COMPACT_STRINGS

时间：

System类:

基本概念：

Java.lang.System类中提供了一些有用的类字段和方法。

常用的方法：

static long currentTimeMillis()	返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差

Date类的概述：

基本概念：

java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒。

常用的方法：

Date() 使用无参的方式构造对象，也就是当前系统时间
Date(long date)根据参数指定毫秒数构造对象， 参数为距离1970年1月1日0时0分0秒的毫秒数
long getTime() 获取调用对象距离1970年1月1日0时0分0秒的毫秒数
void setTime(long time)设置调用对象为距离基准时间time毫秒的时间点

SimpleDateFormat类：

基本概念：

java.text.SimpleDateFormat类主要用于实现日期和文本之间的转换。

常用的方法：

SimpleDateFormat() 使用无参方式构造对象
SimpleDateFormat(String pattern)根据参数指定的模式来构造对象，模式主要有: y-年 M-月 d-日 H-时 m-分 s-秒
final String format(Date date)用于将日期类型转换为文本类型
Date parse(String source) 用于将文本类型转换为日期类型

Calendar类：

基本概念：

java.util.Calender类主要用于描述特定的瞬间，取代Date类中的过时方法实现全球化。
该类是个抽象类，因此不能实例化对象，其具体子类针对不同国家的日历系统，其中应用最广泛的是GregorianCalendar（格里高利历），对应世界上绝大多数国家/地区使用的标准日历系统。

常用的方法：

static Calendar getInstance()用于获取Calendar类型的引用
void set(int year, int month, int date, int hourOfDay, int minute, int second)用于设置年月日时分秒信息，month从0开始，需要减1
void setTime(Date date)
Date getTime()用于将Calendar类型转换为Date类型
void set(int field, int value) 设置指定字段的数值，Calendar.YEAR
void add(int field, int amount) 向指定字段增加数值

注意：

Calendar本身是abstract（有构造方法但只能super调用），为啥可以返回类型的对象？

该静态方法返回的是子类。
多态的场景之三：返回类型形成多态

Java8日期类：

由来：

JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。
它们面临的问题是：
	Date类中的年份是从1900开始的，而月份都从0开始。
	格式化只对Date类有用，对Calendar类则不能使用。
	非线程安全等。

概述:

Java 8通过发布新的Date-Time API来进一步加强对 日期与时间的处理。
java.time包：该包日期/时间API的基础包。
java.time.chrono包：该包提供对不同日历系统的访问。
java.time.format包：该包能够格式化和解析日期时间对象。
java.time.temporal包：该包包含底层框架和扩展特性。
java.time.zone包：该包支持不同时区以及相关规则的类。

LocalDate类:

基本概念：

java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息。

常用的方法：

static LocalDate now() 在默认时区中从系统时钟获取当前日期

LocalTime类：

基本概念：

java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒。

常用的方法：

static LocalTime now() 从默认时区的系统时间中获取当前时间
static LocalTime now(ZoneId zone) 获取指定时区的当前时间

LocalDateTime类:

基本概念：

java.time.LocalDateTime类主要用于描述ISO-8601日历系统中没有时区的日期时间，如2007-12-03T10:15:30。

常用的方法：

static LocalDateTime now()从默认时区的系统时间中获取当前日期时间
static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)根据参数指定的年月日时分秒信息来设置日期时间
static LocalDateTime LocalDateTime.ofInstant(Instant instant, ZoneId zone)根据Instant来设置日期时间
int getYear() 获取年份字段的数值
int getMonthValue() 获取1到12之间的月份字段
int getDayOfMonth() 获取日期字段
int getHour() 获取小时数
int getMinute() 获取分钟数
int getSecond() 获取秒数
LocalDateTime withYear(int year) 设置为参数指定的年，返回的是同类型新对象，和String类型相似
LocalDateTime withSecond(int second) 设置为参数指定的秒
LocalDateTime plusYears(long years) 加上参数指定的年
LocalDateTime plusSeconds(long seconds) 加上参数指定的秒
LocalDateTime minusYears(long years) 减去参数指定的年
LocalDateTime minusSeconds(long seconds) 减去参数指定的秒

Instant类：

基本概念：

java.time.Instant类主要用于描述瞬间的时间点信息。

常用的方法：

static Instant now() 从系统时钟上获取当前时间，utc时区
OffsetDateTime atOffset(ZoneOffset offset)将此瞬间与偏移量组合以创建偏移日期时间，ZoneOffset.ofHours(8)
static Instant ofEpochMilli(long epochMilli)根据参数指定的毫秒数来构造对象，参数为距离1970年1月1日0时0分0秒的毫秒数
long toEpochMilli() 获取距离1970年1月1日0时0分0秒的毫秒数

DateTimeFormatter类：

基本概念：

java.time.format.DateTimeFormatter类主要用于格式化和解析日期。

常用的方法：

static DateTimeFormatter ofPattern(String pattern) 根据参数指定的模式来获取对象
String format(TemporalAccessor temporal) 将参数指定日期时间转换为字符串，TemporalAccessor是接口，可以传Instant、LocalDateTime
TemporalAccessor parse(CharSequence text) 将参数指定字符串转换为日期时间

集合类库：

集合：

由来：

当需要在Java程序中记录单个数据内容时，则声明一个变量。
当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组。
当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。
当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组。
当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。

集合的框架结构：

Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。
其中Collection集合中存取元素的基本单位是：单个元素。
其中Map集合中存取元素的基本单位是：单对元素。

关系图：

                     collection                                                             Map
   set 			                    List 	      queue                                                      SortedMap
              SortedSet   
HashSet LinkedSet TreeSet    ArrayList Vector LinkedList  PriorityQueue         HashMap  LinkedHashMap  HashMap  TreeMap

Collection集合：

基本概念：

java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法
既可用于操作List集合，也可用于操作Queue集合和Set集合。

常用的方法：

boolean add(E e); 向集合中添加对象
boolean addAll(Collection c)用于将参数指定集合c中的所有元素添加到当前集合中
boolean contains(Object o); 判断是否包含指定对象，原理是Objects.equals(o, e)，这句话相当于1.判断null，2.判断自身，3.该类型的方法e.equals(o)
boolean containsAll(Collection c) 判断是否包含参数指定的所有对象
boolean retainAll(Collection c) 保留当前集合中存在且参数集合中存在的所有对象，交集。如果此集合因调用而更改就返回true。取代原集合。
boolean remove(Object o); 从集合中删除对象，成功返回true。多个只删除一个，原理是删除元素e ，使其为Objects.equals(o, e)
boolean removeAll(Collection c) 从集合中删除参数指定的所有对象，改变了就返回true
void clear(); 清空集合
int size(); 返回包含对象的个数
boolean isEmpty(); 判断是否为空，底层是判断size==0
boolean equals(Object o) 判断是否相等
int hashCode() 获取当前集合的哈希码值
Object[] toArray() 将集合转换为数组，Arrays.asList(object数组)可以逆转
Iterator iterator() 获取当前集合的迭代器

Iterator接口：

基本概念：

java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素。
java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭代器对象。

常用的方法：

boolean hasNext() 判断集合中是否有可以迭代/访问的元素，
E next() 用于取出一个元素并指向下一个元素，位置会变化，不能多次遍历，可以再次调用iterator方法
void remove() 用于删除最后一个访问到的元素，这样可以防止超删。collection.remove(next获取到的obj)方法会发生并发修改异常。

应用：

官方的toString方法就是迭代拼接print

for each循环：

基本概念：

Java5推出了增强型for循环语句，可以应用数组和集合的遍历。是经典迭代的“简化版”。

底层原理：

迭代器

语法格式：

for(元素类型 变量名 : 数组/集合名称) {
	循环体;
}	

执行流程：

不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止。

List集合：

基本概念：

java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。
该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。
ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。
LinkedList类的底层是采用双向链表进行数据管理的，访问不方便（内存不连续），增删元素方便。
	可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。
Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)。
Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低，以后开发中基本不用。扩容一般为2倍
	类似StringBuilder和StringBuffer的区别。

ArrayList类：

概念：

底层是数组，但可以动态修改（有个临时变量）

遍历中删除：

1.使用for index++的方式，list.remove(e)会更新索引下标。
	解决：index要不增。或者倒序遍历。
2.使用高级for循环(增强for循环)遍历删除/增加操作
	for (type e : es ){
		// 如果break不会报错
	}					}
	可能会报ConcurrentModificationException异常。

源码分析扩容：

1.声明new ArrayList();构造方法里

this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
其中transient Object[] elementData; 
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 是一个长度为0的数组

2.add方法添加元素时，

首先：

判断长度是否满了s == elementData.length。

满了的情况下发生扩容：

判断是否是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是，先申请大小为10的object数组
否则，取1.5倍*旧容量或旧容量+1的最大值。// addAll的情况下就不是1了，而是参数集合的size。

线程不安全：

1.判断容量时，size可能都判断满足，但写入就越界了。
	elementData[size++] = e 
2.有可能元素会被覆盖。
	elementData[size] = e;		//多个线程执行了这步。
	size = size + 1;

解决：

CopyOnWriteArrayList，写时，加锁，复制原数组，写入，再将原容器的引用指向新的setArray(newElements)。
适合读多写少的场景，缺点时是每次写时需要复制，容易GC。

LinkedList类:

常用方法：

void addFirst(E e)
void addLast(E e)
E removeFirst()
E removeLast()

源码分析add过程：

1.new时声明first和last变量

transient Node first;

2.add方法会判断修改first和last，将旧的node.next指向新的last

常用的方法
	void add(int index, E element) 向集合中指定位置添加元素，与collect不同。
	boolean addAll(int index, Collection c) 向集合中添加所有元素
	E get(int index) 从集合中获取指定位置元素，返回类型为object，需要强转（但可能不是父子类型，发生类型转换异常）
	int indexOf(Object o) 查找参数指定的对象
	int lastIndexOf(Object o) 反向查找参数指定的对象
	E set(int index, E element) 修改指定位置的元素，返回原有元素
	E remove(int index) 删除指定位置的元素。注意for循环，size每次会减小（倒着删也可以）；元素自动填充，后面的元素会补位。
		注意，本身还有remove(Object e)的方法，重载了。
	List subList(int fromIndex, int toIndex) 用于获取子List，共享内存空间。

Stack类:

常用方法：

boolean empty() 测试此堆栈是否为空。  
E peek() 查看此堆栈顶部的对象，而不将其从堆栈中删除。  
E pop() 移除此堆栈顶部的对象，并将该对象作为此函数的值返回。  
E push​(E item) 将项目推到此堆栈的顶部。  
int search​(Object o) 返回对象在此堆栈上的从1开始的位置。 

Queue集合：

基本概念：

java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。
该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)。
该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。

常用的方法：

boolean offer(E e) 将一个对象添加至队尾，若添加成功则返回true
E poll() 从队首删除并返回一个元素
E peek() 返回队首的元素（但并不删除）

Set集合：

基本概念：

java.util.Set集合是Collection集合的子集合，与List集合平级。
该集合中元素没有先后放入次序，且不允许重复。
该集合的主要实现类是：HashSet类 和 TreeSet类以及LinkedHashSet类。
其中HashSet类的底层是采用哈希表进行数据管理的。
其中TreeSet类的底层是采用红黑树进行数据管理的。
其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。

常用的方法：

参考Collection集合中的方法即可！

元素放入HashSet集合的原理：

使用元素调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算出该元素在数组中的索引位置。
若该位置没有元素，则将该元素直接放入即可。
若该位置有元素，则使用新元素与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。
	若新元素与已有元素的哈希值相同，则使用新元素调用equals方法与已有元素依次比较。
	若相等则添加元素失败，否则将元素直接放入即可。

TreeSet集合：

概念：

由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使用新元素与集合中已有的元素依次比较来确定新元素的合理位置。
元素默认从小到大排序了。
比较元素大小的规则有两种方式：
	使用元素的自然（自身）排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；（至少实现这个，不然报错ClassCastException）
	使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；
自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序；

自然排序：

负数表示新对象小于参数对象。0表示不放入。
implements Comparable{}

@Override
public int compareTo(Person o) {
	return this.getName().compareTo(o.getName());
}

比较器规则：

实现接口，选择匿名类（lambda表达式也可以）、实现接口的子类都可以。负数表示o1小于o2
Comparator comparator = new Comparator() {
	@Override
	public int compare(Person o1, Person o2) {
		return 0;
	}
};	

Map集合：

基本概念：

java.util.Map集合中存取元素的基本单位是：单对元素，其中类型参数如下：

K - 此映射所维护的键(Key)的类型，相当于目录。
V - 映射值(Value)的类型，相当于内容。
该集合中key是不允许重复的，而且一个key只能对应一个value。
该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类。
其中HashMap类的底层是采用哈希表进行数据管理的。
其中TreeMap类的底层是采用红黑树进行数据管理的。
其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。
其中Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类型的。
Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能。经常用于根据key检索value的业务场景。

常用的方法:

V put(K key, V value)将Key-Value对存入Map，若集合中已经包含该Key，则替换该Key所对应的Value，返回值为该Key原来所对应的Value，若没有则返回null
V get(Object key) 返回与参数Key所对应的Value对象，如果不存在则返回null
boolean containsKey(Object key);判断集合中是否包含指定的Key
boolean containsValue(Object value);判断集合中是否包含指定的Value
V remove(Object key) 根据参数指定的key进行删除
Set keySet() 返回此映射中包含的键的Set视图
Collection values() 返回此映射中包含的值的Set视图
Set> entrySet() 返回此映射中包含的映射的Set视图，每个元素是Map.Entry

HashMap集合:

java7和java8的变化：

链表数组 -> 链表超过一定长度后变为红黑树	TREEIFY_THRESHOLD

源码分析：

1.new声明，只是this.loadFactor = DEFAULT_LOAD_FACTOR。
2.put过程：
	先hash键，通过(h = key.hashCode()) ^ (h >>> 16)和(n - 1) & hash得到数组的索引位置i
	判断数组容量是否为0或者null，发生扩容。
	根据索引位置i找到元素：
		若该位置没有元素，则将该键值对直接放入即可。然后++modCount，超过thr时调用resize。
		若该位置有元素p，则使用key与已有元素依次比较key的哈希值
			若p.key调用equals方法与p相同，则将该元素的value直接赋值给该Node。
			若元素是TreeNode，调用putTreeVal方法
			若key不相同
				判断p.next是否为空，如果为空直接放到next，然后分析是否超过TREEIFY_THRESHOLD（默认是8），再决定是否建树treeifyBin
													（里面会先判断链表长度是否超过MIN_TREEIFY_CAPACITY，64，如果没超过就resize）。
				判断当前链表的Node的key是否相等，相等就更新值。
3.扩容过程：
	一开始容量和thr都为0，赋值为DEFAULT_INITIAL_CAPACITY=16，thr为16*0.75=12。初始化一个数组Node[] newTab = (Node[])new Node[newCap];
	容量和thr不为0的情况下，newCap = oldCap << 1和newThr = oldThr << 1都翻倍了。
		遍历旧数组得到e，先置空旧位置
			看e是否有next，没有通过e.hash & (newCap - 1)放到新位置
			如果是TreeNode，((TreeNode)e).split(this, newTab, j, oldCap)
			否则，e有next，桶的情况，顺序放到j或者j + oldCap的位置
		一次转移完旧数据。

遍历：

EntrySet，只需要取一次。

缺点：

1.并发情况下扩容会出现死循环，因为要遍历链表将新元素加入新数组，遍历过程中不断将变量e.next指向newTable[i]。并发情况下有可能死循环。
	int i = indexFor(e.hash, newCapacity);
	e.next = newTable[i];	// 将当前元素指向上一个元素，相当于将原链表倒序了。
	newTable[i] = e;
	比如：
		线程A的e=1，next=3。还没执行e.next时挂起，线程B的e=3,next=5,newTable[i]=1，执行e.next=newTable[i]，即3.next=1，newTable[i]=3，next=5
		这个时候线程A再执行，就会变为1.next=3,newTable[i]=1。形成死循环。
	解决：
		1.8通过head和tail，每次tail.next=e来保证顺序遍历链表，修复了。保证每个node永远执行下一个next，那么无论多线程执行在哪个环节，都不会出现问题。
		与运算解析：
			新数组下标：newTab[e.hash & (newCap - 1)] = e;  新容量为2倍，那么二进制最高位刚好多了一个1。hash在这个最高位有两种情况，1或者0。
			if ((e.hash & oldCap) == 0) 判断hash后的值是否在最高位有1。
			如果有1，说明新下标为j + oldCap。没有1，说明新下标还是j。
2.仍然存在并发数据丢失的问题（比如应该hash冲突的，但现在只有一个key了）。

ConcurrentHashMap：

1.7采用了分段锁技术，其中 Segment 继承于 ReentrantLock。能支持 N 个 Segment 这么多次数的并发。
1.8使用 如果为空CAS尝试插入（尝试需要依赖底层硬件来判断是否成功） + 不然synchronized。因为 jdk对 synchronized 优化是很到位的。

Collections类：

基本概念：

java.util.Collections类主要提供了对集合操作或者返回集合的静态方法。

常用的方法：

static > T
max(Collection coll)根据元素的自然顺序返回给定集合的最大元素
static T max(Collection coll, Comparator comp)根据指定比较器引发的顺序返回给定集合的最大元素
static > T min(Collection coll)根据元素的自然顺序返回给定集合的最小元素
static T min(Collection coll, Comparator comp)根据指定比较器引发的顺序返回给定集合的最小元素
static void copy(List dest, List src)将一个列表中的所有元素复制到另一个列表中，需要dest的size大于src的。
static void reverse(List list) 反转指定列表中元素的顺序
static void shuffle(List list) 使用默认的随机源随机置换指定的列表
static > void sort(List list)根据其元素的自然顺序将指定列表按升序排序
static void sort(List list, Comparator c)根据指定比较器指定的顺序对指定列表进行排序
static void swap(List list, int i, int j) 交换指定列表中指定位置的元素

泛型机制：

基本概念：

只能引用类型
通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，
	为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。
为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，
	若放入其它类型的元素则编译报错。泛型只在编译时期有效，在运行时期不区分是什么类型。

本质：

参数化类型。
泛型参数T只存在于编译时，在编译后会被擦除。
泛型类型在逻辑上看以看成是多个不同的类型，实际上运行时，都是相同的底层基本类型。
在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

底层原理：

泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，用于给形式参数E进行初始化，
从而使得集合中所有的E被实际参数替换，由于实际参数可以传递各种各样广泛的数据类型，因此得名为泛型。

示例：

List l = new LinkedList();		
List l = new LinkedList<>();			从java7开始的新特性：菱形特性，不用再写两遍

自定义泛型接口：

泛型接口和普通接口的区别就是后面添加了类型参数列表，可以有多个类型参数，如：等。	

自定义泛型类：

泛型类和普通类的区别就是类名后面添加了类型参数列表，可以有多个类型参数，如：等。
实例化时没有指定类型时，默认是Object类型。
实例化泛型类时应该指定具体的数据类型，并且是引用数据类型而不是基本数据类型（基本类型可以用包装类）。
继承：
	父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。
		如果不保留泛型和没有指定泛型，则父类的T为默认Object。
			A extends B
		如果不保留泛型但指定了泛型，则父类的T为指定类型
			A extends B
		可以保留泛型
			A extends B	
	子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。
			A extends B
示例： 
	public class Person {
		private T gender;
	}

自定义泛型方法：

介绍：

泛型方法就是我们输入参数的时候，输入的是泛型参数，而不是具体的参数。我们在调用这个泛型方法的时需要对泛型参数进行实例化或者static。

泛型方法的格式：

[访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) { 方法体; }
在静态方法中使用泛型参数的时候，需要我们把静态方法定义为泛型方法。
用到类的泛型参数的方法不能static

泛型方法的实现：

注意泛型方法只能实现，不能重写(接口没有这个概念)，但可以重载。
必须实现 void xxx的方法。
重载可以 void xxx(T a)，使用不用的泛型。（多态接口的变量不能使用重载的方法，因为接口没有定义，解决：泛型接口的继承，实现类可以指定具体子类）
触发：
	传入father对象时，触发第一个方法。
	传入son对象以及son的子类对象时，触发第二个方法，而且对象a的成员变量为son的值，而不是son的子类的值。
	传入otherSon对象时，仍然触发father的方法。

泛型方法的继承：

子类中可以对方法重写override，也可以重载overload。
重载示例：
	@Override
  				 void print(T a)  // 重写，只能保持泛形一模一样。
	 void print(T a)		// 重载，如果没有用到参数T，那么会提示错误，因为两个方法擦除泛型后都是同样的方法，both methods have same erasure
重载后触发：
	与普通方法类似，根据传参来确定。

泛型在继承上的体现：

如果B是A的一个子类或子接口，而G是具有泛型声明的类或接口，则G并不是G的子类型！
比如：String是Object的子类，但是List并不是List