1. 包装类
（基本类型中没有多少我们能够使用的方法和属性，为了便捷我们需要自己去写）
针对每一种基本类型提供了对应的类的形式 --- 包装类
| byte | short | int | long | float | double | char | boolean | void |
| Byte | Short | Integer | Long | Float | Double | Character | Boolean | Void |
void 是一个最终类，不能被实例化。
package cn.tedu.baozhuang;
public class IntegerDemo1 {
public static void main(String[] args) {
int i = 7;
//封箱
Integer in = new Integer(i);
//自动封箱,都是 JDK1.5 的特性
//其实就是在底层默认调用 Interger 类身上的静态方法 valueOf，Double Boolean 这些也是这样的！！
//Integer in2 = Integer.valueOf(i);
Integer in2 = i;
Integer in3 = new Integer(5);
//自动拆箱，在底层调用对象身上的 IntegerValue()
//in3.IntegerValue();
int i3 = in3;
}
}
当把基本类型的变量直接赋值给对应的引用类型的对象，--- 自动封箱，底层是调用了对应类身上的 valueOf() 方法
当把引用类型的对象直接赋值给对应的基本类型的变量，---自动拆箱，底层是调用了对应类身上的***Value() 方法，
package cn.tedu.baozhuang;
public class IntegerDemo2 {
public static void main(String[] args) {
//Integer i1 = Integer.valueOf();
//如果这个值不在 -128~127 底层的 valueOf() 调用构造方法 new 一把，返回一个新对象！！！
//如果在 -128~127,从 cache 数组中对应下标位置上取值。
Integer i1 = 50;
Integer i2 = 50;
System.out.println(i1 == i2);
Integer in = 400;
int i = 400;
//包装类和基本类型比较时，会进行自动拆箱成基本类型
System.out.println(in == i);
}
}
四种整数型都有范围判断（-128~127），float 就没有，直接 new 了！
注意：凡是 Number 的子类都会提供将字符串转化为对应类型的构造方法
包装类产生的对象的哈希码是固定的，不随环境改变。
注意：字面量的哈希码不随环境不随系统而改变
2. 数学类
（是在代码中调用 Java 中写好的数学类）
Math --- 最终类，针对基本类型提供了基本的数学运算
BigDecimal --- 能够精确运算，要求参数以字符串形式传递
几个比较重要的方法对应如下代码：
package cn.tedu.math;
import java.util.Random;
public class MathDemo1 {
public static void main(String[] args) {
System.out.println(Math.abs(-5.86));
//求立方根
System.out.println(Math.cbrt(8));
//向上取整，返回一个double 类型的数据
System.out.println(Math.ceil(4.06));
//向下取整，都是返回double 类型的
System.out.println(Math.floor(4.06));
//四舍五入,返回一个 long 类型的
System.out.println(Math.round(3.68));
//返回一个[0,1)的一个随机小数
System.out.println(Math.random());
//获取 30-90 一个随机整数
System.out.println((int)(Math.random()*61+30));
//获取 0-30的数，只能是整数
Random r = new Random();
System.out.println(r.nextInt(30));
//抽奖系统,实际上要考虑权重问题（就是让那种经常到这里消费的人的概率高一些）
if(Math.random() * Math.random() > 0.95){
System.out.println("亲，恭喜你中奖啦！");
}
}
}
两个很大的数相乘，用一个数组存放。
int[ ] arr1 = new int[ n ];
int[ ] arr2 = new int[ n ];
int[ ] result = new int[ 2*n ];
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
int r = arr1[i] * arr2[j] + result[ i+j ];//是一个暂时的数，用于后面分别存放，是i+j位的数（其实就是上一位的 i + j +1 位）
result[ i+j ] = r % 10; //表示第 i + j 位的结果
result[ i+j+1 ] = r / 10; //表示第 i + j + 1 位结果，用于表示进位
}
}
3. Calender --- 抽象类
JDK1.8的特性：简书，51CTO，是以讹传讹，自己试试是不是正确。最准确的是别人的官网！！
Map<String, Integer> map = {"a":1, "b":2}; //别人说都没有说
package cn.tedu.time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) throws Exception {
//获取当前时间
System.out.println(new Date().toString());
//获取指定时间
//这个方法在 1990-01的基础上进行累加
@SuppressWarnings("deprecation")
//压制警告
//这个方法已过时
Date date = new Date(2000,2,9);
System.out.println(date);
//将字符串转化为日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date1 = sdf.parse("2000-12-15 18:58:45");
System.out.println(date1);
//将日期转化为字符串
//XX年XX月XX日
SimpleDateFormat sdf2 = new SimpleDateFormat("yy年MM月dd日 HH时mm分ss秒");
String str = sdf2.format(date1);
//格里高利历（GregorianCalendar），毫秒值（time=1534494939307），偏移量---表示当前时期到零时区的毫秒值（offset=28800000）
//WEEK_OF_MONTH=3(不完全周) DAY_OF_WEEK_IN_MONTH=3
// Calendar
}
}
1. 时间包
在 JDK 1.8 中对时间体系进行了全新的详细的划分，LocalDate，LocalTime
package cn.tedu.time;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class LocalDateDemo {
public static void main(String[] args) {
//LocalDate 是一个只包含日期，不包含时间
LocalDate date = LocalDate.now();
System.out.println(date);
//
LocalDate date1 = LocalDate.of(2014, 7, 8);
//向后加几个
System.out.println(date.plus(7,ChronoUnit.WEEKS));//表示周
System.out.println(date.minus(8,ChronoUnit.MONTHS));
System.out.println(date1.getDayOfMonth());
//在某一个日期的后面吗
System.out.println(date1.isAfter(LocalDate.now()));
//判断闰年
System.out.println(date1.isLeapYear());
}
}
2. 异常
ArithmeticException --- 运行时异常（比如 1/0）
ArrayIndexOutOfBoundsException ---（数组下标越界），运行时异常（a[10]）
NullPointerException ---- 运行时异常（str=null ,str.length()）
ClassCastException --- 运行时异常（String str = (str)o;）
StringIndexOutOfBoundsException ---运行时异常
NumberFormatException ---运行时异常(new Integer("abc"))
CloneNotSupportedException --- 编译时异常（new ExceptionDemo().clone()）
UnSupportedEncodingException --- 不支持编码异常（在getBytes() 中就是这样，要抛异常）--- 编译时异常（"abc".getBytes("abc");）
ParseException(在simpledateFormat() 参数没有指定时间格式) --- 编译时异常(new simpleDateFormate("yyyy").parse("2012");)
---异常是 Java 中用于问题处理的一套逻辑
运行时异常非得来处理一下，就使用try-catch(){} 捕获一把！！
throws PathNotExistException //告诉调用方法的对象，
2.1 Throwalbe --- 异常的顶级父类
Error --- 错误表示合理（无论在语法上还是在逻辑上都是正确的）的应用程序中出现了严重的问题，而且这个问题不应该试图捕获。 --- 意味着错误一旦出现不能处理。 --- StackOverflowError(递归层次太深，超过了范围)，OutOfMemory(堆内存的分配上) 是在虚拟机错误的子类！！
Exception --- 表示合理的应用程序想要捕获的问题，也因此可以处理。
编译时异常：在编译时期就已经出现要求处理。必须处理。
运行时异常：在运行时期出现要求处理。可以处理可以不处理 --- RuntimeException （运行时异常的小父类）
2.2 异常捕获方式
A. 如果多个异常的处理方式各不一样，可以使用多个catch分别捕获分别处理
B. 如果多个异常的处理方式是一样的，可以捕获它们的父类来进行处理
C. 如果多个异常进行了分组，那么同一组的异常之间用 | 隔开进行分组处理 --- 从 JDK1.7 开始（一个分组处理的过程，一个 catch 中写两个异常，中间用 | 分开就行）
（注意：如果先捕获了父类，那么它的子类不能捕获，所以要先子后父）
总结：方法的重载和方法的重写
重载：方法名相同，参数列表不同，可以有抛出所有的异常
重写：方法名，参数列表相同，方法体不同，只能抛出比父类范围更小的异常。
方法的重载和重写都是行为多态。方法重载是指在同一个类中，方法名一致而参数列表不同的方法，和修饰符、返回值类型以及异常没有关系。重载本身是一种编译时多态。方法的重写指在父子类中存在方法签名一致的非静态方法。子类在重写父类方法的时候，子类权限修饰符的范围要大于等于父类的权限修饰符的范围。如果父类中的方法的返回值类型的基本类型
注意：异常一旦抛出，后面的代码就不再运行。主方法中处理了就接着执行下面的代码（主函数是 jvm 调用，相当于把异常抛给了 jvm，会打印栈轨迹）。
（看栈轨迹：先看异常的名字（Number），再看冒号后面的那个异常信息（告诉你什么出错了），接着看一个异常的栈轨迹（你写的一个代码，调用别人的，别人再调用别人的，最后在java最底层，你是最后一个拿到的，所以栈轨迹首先出现的是在 Java 底层。你能够改的是你自己的，所以要栈轨迹要倒着看））e.printStatckTrace() //打印栈轨迹
finally (读文件无论成功与否，都要将文件关闭) --- 无论出现异常与否都要执行一次
如果在项目开发期间遇到异常，记录栈轨迹，找异常来源进行改正；如果项目已经上线，记录错误日志（是记录项目运行信息的，在某个链接上卡死，为后续统一工作提供参考），往往跳转错误页面（点进去就网页丢失了，）
3. 集合 --- Collection
（购物车，把东西加到购物车中，每个人买的东西不一样，容器也不一样）
存储多个统一类型的数据的容器 --- 大小不固定
3.1 <E> - 泛型 - 在集合中的作用是用于表示元素类型。- 由于泛型的限制，集合中只能存储对象。
String[] arr; arr 的数据类型是数组，元素类型是String
Collection<String> c; c 的数据类型是集合，元素类型是 String。
Collection<int[]> c; --- 表示集合中存储的是数组。int[] 是一个引用类型，也是对象。
3.2 List - 列表
有序（保证元素的存入顺序）的集合。怎么放就怎么拿出来。 --- 存在了下标，因此能够通过下标来操作这个列表。
package cn.tedu.collection;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
//保证元素的存入顺序
list.add("xiaofang");
list.add("daqiang");
list.add("weichang");
list.add("dadaxu");
//截取子列表
//获取指定元素在列表中第一次出现的位置
//遍历这个列表，是size
for(int i = 0; i < list.size(); i++)
System.out.println(list.get(i));
//向列表的指定的下标插入指定的元素，原位置就移到下一个位置上了，
//放在元素末尾，就是追加了，可以的，但是不能向末尾后面增加，不然就数组下标越界异常！！（移除超过了也会报这个异常）
list.add(2,"插入了");
System.out.println(list);
//替换指定位置上的元素，移除这个再插入一位，也有自己的set
list.set(2,"替换了");
System.out.println(list);
//比较两个列表的时候是逐位比较是否一致，元素中是new String("xiaoqiang")也是正确的！！
}
}
3.2.1 ArrayList - 顺序表
异常的顶级父类是 Throwable。
异常的捕获方式：多个catch；捕获父类，统一处理；将同一组异常之间用 | 隔开，分组处理 --- JDK1.7
1. List<E>中的元素是可以重复的。
1.1 ArrayList 扩容是增加一半，是通过右移实现的。增删操作相对复杂，查询操作相对简单。内存空间是连续的。是一个线程不安全的列表！！
1.2 LinkedList - 链表
基于节点（Node）来实现的。利用节点来存储数据以及维系链表之间每一个节点的关系。增删操作相对简单，查询操作相对复杂。内存空间不连续。随用随开辟，不需要初始容量。是一个线程不安全的。
2. Vector - 向量
最早的列表，依靠数组存储数据，初始容量默认是10。每次扩容默认增加两倍（也可以默认初始和增量）。是一个线程安全的列表。
elements() 返回迭代器（一个集合中有很多的元素，通过下标遍历是间接的过程，Java中提供了直接获取的方法，就是这个迭代器）
迭代器：创建指针，通过指针的移动就获取那个元素，指定谁谁就上。每挪动一次，都要判断 hasMoreElements()，找下一个是 nextElement()（候诊室叫号，有人的话就叫下一个）？？nextElement()
关于 nextElement() 查看API文档得知是返回这个元素的下一个元素，因为之前在 while 循环中判断了后面是否还有元素，所以在这一步是到不了最后那个元素的，所以不用考虑。
又去百度了一下，说的是nextElement() 如果 Enumeration 中是第一个元素，就取这个，接着联合 hasMoreElement()可以一次取下一个元素。
2.1 Stack - 栈
继承了Vector。遵循后进先出/先进后出的原则。（比如往盒子里放东西，从上往下挪，最后诺进去的东西就先拿出来）。最先放入栈中的元素 ---栈底元素，最后放入栈中的元素 --- 栈顶元素。将元素放入栈中 --- 入栈/压栈，将元素从栈中取出 --- 出栈/弹栈。
练习：使用数组/节点完成一个Stack --- empty peek pop push search
3. Set - 散列集合
包含的元素不重复。
3.1 HashSet
不包含重复的元素，不保证元素的存储顺序。底层基于HashMap来进行数据的存储。默认初始容量是16，默认加载因子是 0.75f。
HashMap 底层是基于数组 + 链表结构
3.2 TreeSet - 对元素进行整体的自然排序（升序），需要这个元素对应的类实现 comparable 接口
Comparator --- 用于给某个对象单独指定规则。