Arrays类为数组操作的工具类，提供了大量对数组进行操作的静态方法 （1）toString() 把数组变成字符串格式
int[] aa = {2,1,3,4,6}; String str = Arrays.toString(aa);（2）sort()排序 对数组的数据进行排序
int[] aa = {5,1,4,2,3}; Arrays.sort(aa); // 默认是升序排序——如何降序（需要传入比较器） String[] ss = {"aaaxxx","bbb","abc","baa","xyz"}; Arrays.sort(ss);（3）binarySearch(int[],int key) 二分法查找 查找某个值在数组的索引位置
int[] aa = {5,1,4,2,3}; Arrays.sort(aa); int index = Arrays.binarySearch(aa,3); System.out.println(index);（4）copy(数组，长度)数组拷贝
参数说明： 1 从哪个数据拷贝数据 2 拷贝多少个数据 返回值： 返回数组（拷贝后的数组）
int[] aa = {1,2,3,4,5}; int[] bb = Arrays.copyOf(aa,3); System.out.println(Arrays.toString(bb)); int[] cc = Arrays.copyOf(aa,10); System.out.println(Arrays.toString(cc));java.util.Date类。 Date表示日期的“逻辑值”，而不是日期显示的样式。样式另外的类（SimpleDateFormat）来控制。 （1）常用的Date类的构造方法 new Date() 系统当前时间 new Date(毫秒值) 创建一个距离1970-01-01 00:00:00 3000毫秒的时间。 其他构造方法都已过时
Date date = new Date(); //系统当前时间 system.out.println(date) Date date2 = new Date(1000); //得到一个距离1970-1-1 00:00:00 过了1000毫秒的时间 System.out.println(date2);（2）Date类常用方法 getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来 此 Date 对象表示的毫秒数 Date中的大部分方法都已过时，被Calendar类中的方法替代
long time = date.getTime(); // 获得date距离1970-1-1 00:00:00 过了多少毫秒（1）作用 对时间日期进行格式化处理 把Date对象转化为年月日时分秒格式字符串 把字符串转化为Date对象
（2）用法 创建SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat(“日期格式”); SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);//2011-09-21 SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”); SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”); //HH表示24小时制格式化 使用parse()方法，将字符串转换成日期 使用format()方法，将日期转换成字符串
（1）作用 由于Date类在设计上的一些缺陷，所以java提供了Calendar类来更好的处理时间和日期。 Calendar是一个抽象类，表示日历，不能直接实例化，通常使用getInstance() 方法来获取实例。
（2）用法 创建方式
Calendar calendar=Calendar.getInstance()Calendar类的常用方法：
getTime() 返回Date类型时间 get(Calendar.YEAR/MONTH/DATE) 获取年份、月份、日 set(2015,11,11,12,11,10) 设置时间到日历中，月份从0到11 add(Calendar.YEAR/MONTH/DATE,2) 在一个日期的年，月，日上添加对应的值示例
public static void main(String[] args) { //抽象类 Calendar cal = Calendar.getInstance(); // 系统当前时间 /* Date date = cal.getTime(); 返回Date类型时间 System.out.println(date); */ /* int year = cal.get(Calendar.YEAR); int month = cal.get(Calendar.MONTH); // 月份从0开始 int date = cal.get(Calendar.DATE); int hour = cal.get(Calendar.HOUR); int minute = cal.get(Calendar.MINUTE); int second = cal.get(Calendar.SECOND); int day = cal.get(Calendar.DAY_OF_WEEK); //获得的是这个星期的第几天 星期日是第一天 System.out.println(year+"-"+(month+1)+"-"+date+" "+hour+":"+minute+":"+second+" 星期"+(day-1)); */ /* cal.set(2017,10,20,11,11,11); System.out.println(cal.getTime()); */ /* cal.add(Calendar.DATE,25); System.out.println(cal.getTime()); cal.add(Calendar.MONTH, 13); System.out.println(cal.getTime()); */ }（1）作用 float、double两种浮点数类型运算是不够精确，不仅是java语言，很多编程语都有这样的问题。为了能够精确表示和计算浮点数，java提供了BigDecimal类。
（2）用法 add:加法 subtract:减法 multiply：乘法 divide：除法
public static void main(String[] args) { double x = 0.1; double y = 0.2; BigDecimal b1 = new BigDecimal(x+""); BigDecimal b2 = new BigDecimal(y+""); BigDecimal b3 = b1.add(b2); double result1 = b3.doubleValue(); System.out.println(result1); double result2 = b1.subtract(b2).doubleValue(); System.out.println(result2); double result3 = b1.multiply(b2).doubleValue(); System.out.println(result3); double result4 = b1.divide(b2).doubleValue(); System.out.println(result4); }（1）作用 Math类封装了很多数学的功能（都是静态方法和静态属性） （2）用法 ceil() 向上取整 floor() 向下取整 round() 四舍五入 random() 随机数 max() 最大值 min() 最小值 abs() 绝对值 cbrt() 立方根 sqrt() 平方根
public static void main(String[] args) { // 产生一个[0,1)的随机数 double random = Math.random(); System.out.println(random); //绝对值 int abs = Math.abs(5); int abs2 = Math.abs(-5); System.out.println(abs+" "+abs2); //立方根 double cbrt = Math.cbrt(27); System.out.println(cbrt); //平方根 double sqrt = Math.sqrt(16); System.out.println(sqrt); //天花板数 大于它的最小的整数 double ceil = Math.ceil(4.5); System.out.println(ceil); //地板数 小于它的最大的整数 double floor = Math.floor(4.5); System.out.println(floor); //最大值 最小值 int max = Math.max(10,8); int min = Math.min(10,8); int x = 11; int y = 8; int z = 5; int result = Math.max(Math.max(x, y),z); // 四舍五入取整数 long round = Math.round(4.4); System.out.println(round); }（1）作用 相对于Math的random方法只能生产 0 到 1之间的随机数 Java提供了一个功能更强大的随机数生产类 Random类
（2）用法 nextBoolean() 随机生产true 或false nextDouble() 随机生产 0 到1 之间的随机浮点数 nextFloat()随机生产 0 到1 之间的随机浮点数 nextInt()随机生产整数 nextLong() 随机生产整数 nextInt(n) 随机生产 0 到 n之间的整数 全部都是左闭右开区间
public static void main(String[] args) { Random r = new Random(); boolean b =r.nextBoolean(); System.out.println(b); double d = r.nextDouble(); //[0.1) System.out.println(d); int x = r.nextInt(); System.out.println(x); int y = r.nextInt(100); System.out.println(y); long z = r.nextLong(); System.out.println(z); }（1）作用 用于描述系统资源的类型，该类不用创建对象，直接使用静态变量和静态方法即可
（2）用法 常用字段： 1、 System.in：标准输入流，默认关联到键盘上 2、 System.out：标准输出流，默认关联到控制台上 3、 System.err：标准错误输出流，默认关联到控制台上，用于打印错误信息，在eclipse中，使用该流打印的内容是红色
常用方法： gc()：强制垃圾回收器回收内存中的垃圾 exit(int status)：结束虚拟机 取值为0 表示退出 currentTimeMillis()：返回当前时间的毫秒值，表示的是从1970年1月1日0时0分0秒开始到现在经历的毫秒值。1s = 1000ms
递归就是一个方法直接或者间接地调用自身。 递归是解决复杂问题的重要方法。 递归的思想就是数学上递推的思想。 把大任务降解为与之类似的规模更小的任务。
注意事项： 在使用递归算法时，必须找到递归的出口（也就是不再递归的条件）。 递归方法中必有选择语句。
栈是一种先进后出的数据结构。在调用方法时，就是一个进栈和出栈的过程。 入栈和退栈 满足先进后出，后进先出
对应每个基本数据类型，都有一个对象类型与之对应，为之服务。
包装类是基本类型与对象类型间的桥梁。
把基本类型转换成对象类型 格式
Integer i = new Integer(100) Double d = new Double(3.14);把引用数据类型还原成基本数据类型 格式
Double d = new Double(3.14); double x = d.doubleValue(); 还原成基本类型 Integer i = new Integer(100) int x = i.intValue()其他方法 Double类的方法： parseDouble(String s)：把串转化为浮点数 MAX_VALUE 属性。最大能表示的数字 Integer类的方法： parseInt(String s) 把串转化为整数 toBinaryString(int i) 转化为二进制的格式 toHexString(int i) 转化为十六进制的格式
就是在 int — Integer 之间，double ---- Double 之间等，进行相互转换的时候，可以不显式地写出代码。java会自动替我们完成转换。
在这里插入代码片Double d = 3.14; // 自动装箱 Integer ii = new Integer(15); int n = ii; // 自动拆箱
在一个类内部定义的类叫做内部类。包含这个内部类的类叫做外部类。
public class Demo01_内部类概述 { private int id; private String name; class MyInner{//内部类 } } class A{// 不是内部类 }生成的.class模式为：外部类名$内部类名。
内部类可以直接使用其外部类的私有成员。
（1）根据定义的位置不同，可以分为： 成员内部类 局部内部类
（2）成员内部类： 普通成员内部类 私有成员内部类 静态成员内部类
（3）局部内部类
（4）根据表示方式不同，可以分为： 有名字的内部类 [匿名内部类]
定义在成员位置上的类，就是成员内部类 格式
class 外部类{ class 内部类类名 { 内部类成员 } }成员内部类的说明： 1.内部类可以直接访问外部类的所有成员，包括私有成员 2.外部类访问内部类成员，需要先创建内部类的对象 3.在外部类外，创建内部类对象的格式： 外部类名.内部类名 内部类对象名 = new 外部类名().new 内部类名();
在普通成员内部类中有两个this
class Outer{ private int id = 1; private String name="张三"; class Inner{ private String name="小毛"; // 内部类中定义了一个和外部类同名的变量 public void sayHello(){ System.out.println(id); System.out.println(name); //内部类的成员 System.out.println(this.name); //内部类的成员 System.out.println(Outer.this.name); // 外部类成员 } } }也是一个成员内部类，在成员内部类前面加上一个private关键字 访问方式 1.在外部类以外，不能直接访问外部类中的私有成员内部类 2.在外部类中，定义一个访问私有成员内部类的公有方法，让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。
public class Demo03_私有成员内部类 { public static void main(String[] args) { Body2 b2 = new Body2(); b2.hello(); //Body2.Shen shen = new Body2().new Shen(); 在其他类中不能创建私有成员内部类的对象 } } class Body2{ //外部类 private double height=190.0; private class Shen{ // 私有成员内部类 int age = 40; public void show(){ System.out.println("该走心的时候别TM找我..." + height + "..." + age); } } public void hello(){ Shen shen = new Shen(); shen.show(); } }也是一个成员内部类，在成员内部类前面加上一个static关键字
访问方式 1.静态成员内部类是外部类的静态成员，所以可以通过外部累类名.内部类名的方式直接访问，而不需要创建外部类对象 2.静态内部类中的非静态成员，需要将所在内部类对象创建出来后，才能被调用。 3.总结：一个类是否需要创建对象，不取觉于该类本身是否是静态，而取决于要访问的成员是否为静态。 静态成员内部类的对象创建格式 外部类名.内部类名 内部类对象名 = new 外部类名().new 内部类名()；
public class Demo04_静态成员内部类 { public static void main(String[] args) { Body3.Gan gan = new Body3.Gan(); gan.show(); } } class Body3{ //外部类 private double height=150.0; static class Gan{ String color="黑色"; public void show(){ // 静态成员内部类中无法访问外部类的非静态成员 如果要访问，需要先创建外部类的对象 //System.out.println(height + "..." + color + "求你了哥，放过我吧别喝了"); } } public void hello(){ Gan gan = new Gan(); gan.show(); //Gan.show(); } }局部内部类：定义在方法中的内部类
局部内部类的访问方式 方法中的局部变量，外界都没有办法访问到 所以方法中定义的内部类，外界也没有办法访问到 解决方式 在方法内部，就创建局部内部类的对象，调用对象的方法 外界调用局部内部类所在的方法，间接的创建局部内部类的对象，间接的访问局部内部类的方法
public class Demo05_局部内部类 { public static void main(String[] args) { Body4 b = new Body4(); b.breath(); } } class Body4{ //外部类 private double height = 160.0; public void breath(){ int age = 30; class Fei{ // 局部内部类 private String color="黑色"; public void show(){ System.out.println(age + "..." + color + "...饶了我吧受不了了太呛了"+"..."+height); } } Fei fei = new Fei(); fei.show(); } }注意：当局部内部类中去访问方法的参数或者方法的局部变量时，要求方法的参数或者局部变量必须被final修饰。jdk1.8中没有强制添加final关键字
没有名字的内部类 格式
new 父类类名或者接口名() { 父类方法的重写或者是接口内容的实现 }本质 创建类一个类的子类对象。接口的实现类对象
