JAVASE

IDEA快捷键

1)删除当前行，默认是ctrl+Y自己配置ctrl+ d
2)复制当前行，自己配置 ctrl+ alt+向下光标
3)补全代码alt +/
4)添加注释和取消注释ctrl+/【第一次是添加注释，第二次是取消注释】
5)导入该行需要的类先配置 auto import，然后使用alt+enter即可
6)快速格式化代码ctrl+ alt+L
7)快速运行程序自己定义alt＋R
8)生成构造器等alt + insert[提高开发效率]
9)查看一个类的层级关系 ctrl+H[学习继承后，非常有用]
10)将光标放在一个方法上，输入 cturl+B，可以定位到方法[学继承后，非常有用]
11)自动的分配变量名，通过在后面假.var[老师最喜欢的]

java11JDK

基础语法

• 整型常量默认为int，声明long型常量后面要加L/I
• boolean，一字节，只允许取值true/false

类型转换

• 自动类型转换
  • 小转大

int a = 'c';//true
double d = 80; //false

• 强制类型转换
  • 大转小
• 基本数据类型和Sting类型的转换
  • 基本类型值+“ ”
  • 基本类型包装类的parseXX方法

    

运算符

算数运算符

%本质：
// % 取模 ,取余 
// 在 % 的本质 看一个公式!!!! a % b = a - a / b * b 
// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1

int i = 1;//i->1 
    i = i++; //规则使用临时变量: (1) temp = i; (2) i = i + 1; (3) i = temp; 
    System.out.println(i); // 1
    int j = 1; 
    j = ++j; //规则使用临时变量: (1) j = j + 1; (2) temp = j; (3) j = temp;
    System.out.println(j); //2

关系运算符(比较运算符)

逻辑运算符

• &

  逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低

• &&

  短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高

如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高

• ^
• !

赋值运算符

= 、 += ，-= ，*= ， /= ，%=等

复合赋值运算符会进行类型转换

byte b = 3;
b += 2;// == b = (byte)(b+2);
b++; //b = (byte)(b+1);

优先级

键盘录入

• Scanner sc = new Scanner(System.in);

String name = sc.next();//录入的值作为字符串返回

随机数产生

• Random r = new Random();

int a = r.nextInt(10)+1;//+1代表0-10，要不是0-9。

数组

数组概念

数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

数组初始化

数组的两种常见初始化方式：

1. 动态初始化（指定长度）
2. 静态初始化（指定内容）

方式一：动态初始化

• 格式：

数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[数组长度];
数组存储的数据类型 数组名字[ ] = new 数组存储的数据类型[数组长度];

• 数组定义格式详解：
  • 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
  • [] : 表示数组。
  • 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
  • new：关键字，创建数组使用的关键字。
  • 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
  • [长度]：数组的长度，表示数组容器中可以存储多少个元素。
  • 注意：数组有定长特性，长度一旦指定，不可更改。
    • 和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。
  • 举例:
    定义可以存储3个整数的数组容器，代码如下：

    int[] arr = new int[3];  
    int   arr[] = new int[3];
    // 可以拆分 
    int[] arr;
    arr = new int[3];
    12345

方式二: 静态初始化

• 格式：

  数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};

• 举例： 定义存储1，2，3，4，5整数的数组容器。

  int[] arr = new int[]{1,2,3,4,5}; 
  // 可以拆分 
  int[] arr;
  arr = new int[]{1,2,3,4,5};
  1234

方式三 ：静态初始化省略格式（不能拆分）

• 格式：

  数据类型[] 数组名 = {元素1,元素2,元素3…};

• 举例：
  定义存储1，2，3，4，5整数的数组容器

  int[] arr = {1,2,3,4,5};
  1

@扩展方法： Arrays.fill快速初始化，填充一个数组

java中的数组初始值都为零，若快速填充一个其他值的数组，即将数组批量填充相同的值，可以用 Arrays.fill 方法，但只能填充一个一维数组，多维数组还得用循环。

举例：

import java.util.Arrays;
public class HelloWorld {
    public static void main(String[] args) {
        int[] arr = new int[5];
        Arrays.fill(arr, 1);
        System.out.println(Arrays.toString(arr));  // [1, 1, 1, 1, 1]
    }
}
12345678910

虽然Arrays.fill方法不能填充二维数组，不过在下面这种情况下，还是可以用一下的：

  int[][] map=new int[4][5];
   int[] row={1,2,6,3,6,1,7};
   Arrays.fill(map,row);  
123

当row中的数值不固定，也不一定有规律时，可以用Arrays.fill()来填充二维数组，使其每一行都是｛1，2，6，3，6，1，7｝

数组的访问

• 索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的元素。
• 格式：

  数组名[索引]

• 数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1。

  public static void main(String[] args) {
    int[] arr = new int[]{1,2,3,4,5}; 
    //打印数组的属性，输出结果是5
     System.out.println(arr.length);
  }
  12345

• 索引访问数组中的元素：
  • 数组名[索引] = 数值，为数组中的元素赋值
  • 变量 = 数组名[索引]，获取出数组中的元素

public static void main(String[] args) {
 //定义存储int类型数组，赋值元素1，2，3，4，5 
 int[] arr = {1,2,3,4,5};
  //为0索引元素赋值为6 
  arr[0] = 6; 
  //获取数组0索引上的元素 
  int i = arr[0]; 
  System.out.println(i); 
  //直接输出数组0索引元素 
  System.out.println(arr[0]); 
}
1234567891011

二维数组操作

二维数组初始化

同一维数组一样，共有4总不同形式的定义方法：

int[][] array1 = new int[10][10];
int array2[][] = new int[10][10];
int array3[][] = { { 1, 1, 1 }, { 2, 2, 2 } };
int array4[][] = new int[][] { { 1, 1, 1 }, { 2, 2, 2 } };
1234

不定长二维数组

int[][] array = new int[3][];
array[0] = new int[1];
array[1] = new int[2];
array[2] = new int[3];
1234

获取二维数组的长度

int length1 = array.length;
int length2 = array[0].length;
// 获取二维数组的第一维长度（3）
System.out.println(length1);
// 获取二维数组的第一维的第一个数组长度（1）
System.out.println(length2);
123456

数组原理内存图

内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。 Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

Java虚拟机的内存划分

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

• JVM的内存划分 | 区域名称 | 作用 | | —- | —- | | 寄存器 | 给CPU使用，和我们开发无关。 | | 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。 | | 方法区 | 存储可以运行的class文件。 | | 堆内存 | 存储对象或者数组，new来创建的，都存储在堆内存。 | | 方法栈 | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |

数组在内存中的存储

1. 一个数组内存图

public static void main(String[] args) { 
        int[] arr = new int[3]; 
        System.out.println(arr);     // [I@5f150435 
}
1234

以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆 内存中存储的，而方法中的变量arr保存的是数组的地址。

输出arr[0]，就会输出arr保存的内存地址中数组中0索引上的元素

实例：

程序执行流程：

1. main方法进入方法栈执行
2. 创建数组，JVM会在堆内存中开辟空间，存储数组
3. 数组在内存中会有自己的内存地址，以十六进制数表示
4. 数组中有3个元素，默认值为0
5. JVM将数组的内存地址赋值给引用类型变量array
6. 变量array保存的是数组内存中的地址，而不是一个具体数值，因此称为引用数据类型。

2. 两个数组内存图

3. 两个变量指向一个数组

数组遍历

• 数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

  public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 }; 
    System.out.println(arr[0]); 
    System.out.println(arr[1]); 
    System.out.println(arr[2]); 
    System.out.println(arr[3]); 
    System.out.println(arr[4]);
  } 
  12345678

  
  以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。

• for循环遍历方式

  public static void main(String[] args) { 
  int[] arr = { 1, 2, 3, 4, 5 }; 
  for (int i = 0; i < arr.length; i++) { 
  System.out.println(arr[i]); 
   }
  }
  123456

• foreach遍历方式

  public static void main(String[] args) { 
  int[] arr = { 1, 2, 3, 4, 5 }; 
  for (int i : arr) { 
  System.out.println(i); 
   }
  }
  123456

数组常见异常

数组越界异常

观察一下代码，运行后会出现什么结果?

public static void main(String[] args) {
 int[] arr = {1,2,3}; 
 System.out.println(arr[3])
 } 
1234

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一 旦出现了，就必须要修改我们编写的代码。

数组空指针异常

观察一下代码，运行后会出现什么结果。

public static void main(String[] args) { 
    int[] arr = {1,2,3};
    arr = null;
     System.out.println(arr[0]); 
｝
12345

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候 会抛出 NullPointerException 空指针异常。在开发中，数组的空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

空指针异常内存图

数组常见操作

数组反转

数组的反转： 数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1

实现思想： 对称位置的元素交换

• 实现反转，就需要将数组对称元素位置交换
• 定义两个变量，保存数组的最小索引和最大索引
• 两个索引上的元素交换位置 最小索引++，最大索引--，再次交换位置
• 最小索引超过了最大索引，数组反转操作结束

实现思路：

1. 把数组最小索引元素和数组的最大索引元素交换
2. 把数组次小索引元素和数组索引次大索引元素交换
3. …
4. 定义两个索引，一个指向最小索引，一个指向最大索引
   int min = 0； int max = arr.length - 1;
5. 遍历数组，让两个索引变化
   min++，max–， 交换条件 min < max;
6. 交换最小索引元素 和最大索引元素
   需要定义三方变量
   int temp = arr[min];
   arr[min] = arr[max];
   arr[max] = temp;
   
   代码实现：

   public static void main(String[] args) { 
   int[] arr = { 1, 2, 3, 4, 5 }; 
   /*循环中定义变量min=0最小索引 max=arr.length‐1最大索引 
   min++,max‐‐ 
   */ 
   for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) { 
       //利用第三方变量完成数组中的元素交换 
       int temp = arr[min]; 
       arr[min] = arr[max]; 
       arr[max] = temp; }// 反转后，遍历数组
   for (int i = 0; i < arr.length; i++) { 
       System.out.println(arr[i]);
    } 
   }
   1234567891011121314

数组获取最大元素

最大值获取：从数组的所有元素中找出最大值。

实现思路：

• 定义变量 max，保存数组0索引上的元素
• 遍历数组，获取出数组中的每个元素
• 将遍历到的元素和保存数组0索引上值的max变量进行比较
• 如果数组元素的值大于了变量的值，变量记录住新的值
• 数组循环遍历结束，变量保存的就是数组中的最大值

public static void main(String[] args) { 
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 }; //定义变量，保存数组中0索引的元素 
    int max = arr[0]; //遍历数组，取出每个元素
    for (int i = 0; i < arr.length; i++) { 
        //遍历到的元素和变量max比较 
        //如果数组元素大于max 
        if (arr[i] > max) { 
        //max记录住大值 max = arr[i];
         }
        }
        System.out.println("数组最大值是： " + max); 
}
123456789101112

数组排序

public static void main(String[] args) {
    int[] array = { 3, 2, 1, 4, 5 };
    Arrays.sort(array);
    System.out.println(Arrays.toString(array));   // [1, 2, 3, 4, 5]
}
123456

Java常用API

输出数组 Arrays.toString()

 int[] array = { 1, 2, 3 };
 System.out.println(Arrays.toString(array));
12

数组转List Arrays.asList()

    String[] array2 = {"a", "b", "c", "d"};
    System.out.println(array2);  // [Ljava.lang.String;@13b6d03
    List list = new ArrayList(Arrays.asList(array2));
    System.out.println(list);   // [a, b, c, d]
    list.add("GG");
    System.out.println(list);  // [a, b, c, d, GG]
123456

数组转Set Arrays.asList()

    String[] array = { "a", "b", "c", "d", "e" };
    Set set = new HashSet(Arrays.asList(array));
    System.out.println(set);
123

List转数组 toArray()

    List list = new ArrayList();
    list.add("a");
    list.add("b");
    list.add("c");
    String[] array = new String[list.size()];
    list.toArray(array);
    for (String s : array)
    System.out.println(s);
12345678

数组中是否包含某个值

String[] array = { "a", "b", "c", "d", "e" };
boolean isEle = Arrays.asList(array).contains("a");
System.out.println(isEle);
123

数组复制

int array[] = new int[] { 1, 2, 3, 4 };
int array1[] = new int[array.length];
System.arraycopy(array, 0, array1, 0, array.length);
123

数组合并

int[] array1 = { 1, 2, 3, 4, 5 };
int[] array2 = { 6, 7, 8, 9, 10 };
int[] array = org.apache.commons.lang.ArrayUtils.addAll(array1, array2);
System.out.println(Arrays.toString(array));
String数组转字符串（使用指定字符拼接）
String[] array = { "a", "b", "c" };
String str = org.apache.commons.lang.StringUtils.join(array, ", ");
System.out.println(str);
12345678

数组逆序

int[] array = { 1, 2, 3, 4, 5 };
org.apache.commons.lang.ArrayUtils.reverse(array);
System.out.println(Arrays.toString(array));
123

数组元素移除

int[] array = { 1, 2, 3, 4, 5 };
int[] removed = org.apache.commons.lang.ArrayUtils.removeElement(array, 3);
System.out.println(Arrays.toString(removed));  
123

数组作为方法参数和返回值

7.1. 数组作为方法参数

以前的方法中我们所了解的方法的参数和返回值都是使用的基本数据类型。那么作为引用类型的数组能否作为方法的参数进行传递呢，当然是可以的。 数组作为方法参数传递，传递的参数是数组内存的地址。

public static void main(String[] args) { 
    int[] arr = { 1, 3, 5, 7, 9 }; 
    //调用方法，传递数组
     printArray(arr); 
 }
 /* 创建方法，方法接收数组类型的参数 进行数组的遍历 */
 public static void printArray(int[] arr) { 
     for (int i = 0; i < arr.length; i++) { 
         System.out.println(arr[i]); 
     } 
 }
1234567891011

内存图示例：

7.2. 数组作为方法返回值

数组作为方法的返回值，返回的是数组的内存地址

public static void main(String[] args) { 
    //调用方法，接收数组的返回值 
    //接收到的是数组的内存地址 
    int[] arr = getArray(); 
    for (int i = 0; i < arr.length; i++) { 
    System.out.println(arr[i]); 
    } 
}
/* 创建方法，返回值是数组类型
创建方法，返回值是数组类型 return返回数组的地址 */
public static int[] getArray() { 
    int[] arr = { 1, 3, 5, 7, 9 }; 
    //返回数组的地址，返回到调用者 
    return arr; 
}
12345678910111213141516

内存图：

7.3. 方法的参数类型区别

代码分析

1.分析下列程序代码，计算输出结果。

public static void main(String[] args) { 
            int a = 1; 
            int b = 2; 
            System.out.println(a);     // 1
           System.out.println(b);    // 2
           change(a, b); 
           System.out.println(a);  // 1
           System.out.println(b);  // 2
}
public static void change(int a, int b) { 
           a = a + b; 
           b = b + a; 
}

2.分析下列程序代码，计算输出结果。

public static void main(String[] args) { 
    int[] arr = {1,3,5}; 
    System.out.println(arr[0]);    // 1
    change(arr); 
    System.out.println(arr[0]);   // 200
 }
 public static void change(int[] arr) { 
     arr[0] = 200; 
}

总结: 方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.

方法

• 不能嵌套调用
• 方法重载
  • 多个方法在同一个类中
  • 多个方法具有相同的方法名
  • 多个方法的参数不相同，类型不同或者数量不同

总结性小案例

• 买飞机票
• 找素数
• 生成随机验证码
• 复制数组
• 评委打分计算
• 数字加密
• 红包抽奖
• 彩票兑奖

面向对象

初识

• 构造器
  • 有参
  • 无参
• this关键字
• 封装
  • getter
  • setter
• javaBean

static

• 静态成员变量
  〈有static修饰，属于类，内存中加载一次）
• 实例成员变量
  〈无static修饰，存在于每个对象中)
• 访问方法/变量
  • 类名.静态
  • 实例.成员
• 工具类
  :一是方便调用，二是提高了代码复用
  • 构造器私有
• 代码块
  • 静态~
    • static{} 随着类的加载而加载，并且自动触发、只执行一次；常用作一些静态数据的初始化操作，以便后续使用。
  • 构造~
    • {} 每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。 初始化实例成员
• 单例模式
  • 饿汉~
    • 实现
  • 懒汉~
    • 实现

继承

子类们相同特征（共性属性，共性方法）放在父类中定义，子类独有的的属性和行为应该定义在子类自己里面

• 内存图
• 特点
  • 单继承
  • 所有类是Object子类
  • 构造器不继承
• 成员变量/方法寻找链
  • 子类局部->子类成员->父类成员
  • 子父类重名
    • 子类优先
    • super可指定父类
• 方法重写
  • @override
  • 私有方法、父类静态方法不可
  • 名称、参数一致
  • 重写父类方法权限>=ta
• 子类构造器
  • 特点
    • 先访问父类的（默认无参），默认第一句super（）
    • super（…）调用有参
  • 利用this调用自己对象的构造器
    public Student(String name) {
    // 借用兄弟构造器！
    this(name, “黑马培训中心”);
    }
    public Student(String name, String schoolName) {
    this.name = name;
    this.schoolName = schoolName;
    }

包

• 定义
• 建包
• 导包
  • 若有两个同名类，默认只导一个，另一个带包名访问

权限修饰符

• private
• 缺省
• protected
• public
• 自己定义类的一般要求
  成员变量一般私有。
  方法一般公开。
  如果该成员只希望本类访问，使用private修饰
  如果该成员只希望本类，同一个包下的其他类和子类访问，使用protected修饰。

final关键字

final关键字的作用：

final关键字修饰类, 修饰字段, 修饰方法,修饰局部变量,修饰方法的形参

final修饰类,表示最终类, 不能被继承,不能作为父类存在

final修饰字段,在定义时必须显示初始化, 不能被修改, 一般与static同时使用,所有字母都大写,称为final常量

final修饰方法,不能被覆盖(重写)

final修饰局部变量, 一旦初始化就不能再修改, 注意final修饰引用类型变量,是指这个变量不能再指向 其他对象 , 可以修改它的字段值

final修饰方法形参, 在方法体中不能修改final参数的值

常量

• public static final修饰
• 命名规范
• 执行原理

枚举

• 是什么，作用
• 格式
• 反编译后特征
  l 枚举类都是继承了枚举类型：java.lang.Enum
  l 枚举都是最终类，不可以被继承。
  l 构造器都是私有的，枚举对外不能创建对象。
  l 枚举类的第一行默认都是罗列枚举对象的名称的。
  l 枚举类相当于是多例模式。
• 使用场景

抽象类

• 由来，作用
• 抽象方法
• 注意点
  Ø 类有的成员（成员变量、方法、构造器）抽象类都具备
  Ø 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类.
  Ø 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。.
  Ø 不能用abstract修饰变量、代码块、构造器。
• 模板方法（final）
  • 把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码。
  • 模板方法中不能决定的功能定义成抽象方法让具体子类去实现。

接口

一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类。

• 格式
• 实现
• 多继承
• 新增方法
• 默认
  • 静态
  • 私有
• 注意事项
  • 1、接口不能创建对象
  • 2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。
  • 3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
  • 4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
  • 5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。

接口中的默认方法与静态方法（java8）

Java 8中允许接口中包含具有具体实现的方法，该方法称为 “默认方法” ，默认方法使用 default 关键字修饰。

例如

接口默认方法的”类优先”原则

若一个接口中定义了一个默认方法，而另外一个父类或接口中 又定义了一个同名的方法时

⚫ 选择父类中的方法。如果一个父类提供了具体的实现，那么 接口中具有相同名称和参数的默认方法会被忽略。

⚫ 接口冲突。如果一个父接口提供一个默认方法，而另一个接 口也提供了一个具有相同名称和参数列表的方法（不管方法 是否是默认方法），那么必须覆盖该方法来解决冲突

接口中的静态方法

Optional

简介

java8中新引入了optional特性，官方说法是更优雅的处理空指针异常，用来表示一个变量的值可以为空也可以不为空，此处引用java 8实战里面的描述：

在你的代码中始终如一地使用Optional，能非常清晰地界定出变量值的缺失是结构上的问
题，还是你算法上的缺陷，抑或是你数据中的问题。另外，我们还想特别强调，引入Optional
类的意图并非要消除每一个null引用。与此相反，它的目标是帮助你更好地设计出普适的API，
让程序员看到方法签名，就能了解它是否接受一个Optional的值。这种强制会让你更积极地将
变量从Optional中解包出来，直面缺失的变量值

所以，optional的作用是显示的表达变量的状态，而不是为了完全消灭NPE。

Option之前

talk is cheap,show me the code:

//根据客户信息获取车辆保险公司的名称
public String getCarInsuranceName(Person person) { 
//对客户判空
 if (person == null) { 
 return "Unknown"; 
 } 
 //对车辆判空
 Car car = person.getCar(); 
 if (car == null) { 
 return "Unknown"; 
 } 
 //对保险公司判空
 Insurance insurance = car.getInsurance(); 
 if (insurance == null) { 
 return "Unknown"; 
 } 
 return insurance.getName(); 
} 
12345678910111213141516171819

以上代码，可能是我日常开发经常遇到的，过多的NullPointerException检查，影响到了代码的可读性以及优雅性，而且存在潜在的风险，假设其中某个环节未做空指针的检查，则会看到我们熟悉而又讨厌的NullPointerException；

Option特性

创建Optional对象

1. 声明一个空的Optional对象

Optional<Car> optCar = Optional.empty(); 
123

1. 依据一个非空值创建Optional

Optional<Car> optCar = Optional.of(car); 
12

Optional.of为静态工厂方法，参数为非控制，如果为空，则会直接抛出个NullPointerException

1. 可接受null的Optional

Optional<Car> optCar = Optional.ofNullable(car);
1

Optional.ofNullable同样为静态方法，只是参与可为空，如上代码，如果car为null，则会直接返回一个空的Optional对象

Optional对象相关操作方法

get（）

Optional对象调用该方法，可以直接获取内容，但是前提是，Optional对象不能为空，否则会抛出NoSuchElementException异常；所以这种方法只有在确定Optional对象非空的情况下调用才是安全的。其实我们只需判断Optional是有值即可，这里官方的api也提供了相关方法，isPresent()返回布尔值来表明Optional对象是否为空

Optional<String> optional= Optional.of("test");
if (optional.isPresent()){ 
  String value = optional1.get();//test
}
1234

orElse(T other)

它允许你在Optional对象不包含值时提供一个默认值，如下：

String nullName = null;
String name=Optional.ofNullable(nullName).orElse("otherName");
12

1. orElseGet(Supplier<? extends T> other)
   orElseGet是orElse的延伸版，supplier方法只有在optional对象为空的时候才会执行

String name = Optional.ofNullable(nullName).orElseGet(() -> "otherName");
1

ifPresent(Consumer<? super T>)

顾名思义，就是当Optional值存在的时候，执行consume函数方法

Optional<String> optional = Optional.of("test");
optional.ifPresent(s -> System.out.println(s));
123

orElseThrow(Supplier<? extends X> exceptionSupplier)

当Optional值不存的时候，我们也可以抛出异常，异常可以自定义

其他

Optional对象也可以使用java8中的steam闲逛的方法，比如map、flatMap、filter这三种函数，引用java8实战中的样例，如下：
找出年龄大于或者等于minAge参数的Person所对应的保险公司列表。

public String getCarInsuranceName(Optional<Person> person, int minAge) { 
 return person.filter(p -> p.getAge() >= minAge) 
 .flatMap(Person::getCar) 
 .flatMap(Car::getInsurance) 
 .map(Insurance::getName) 
 .orElse("Unknown"); 
} 
12345678

注：当Optional对象为空时，则后面的map、flatMap、filter都不会继续执行

Optional实践

用于封装可能为null的值

Object value = map.get("key");
1

此时，map.get(“key”)可能为空，这里可用使用Optional进行良好的封装处理，如下：

Optional<Object> value = Optional.ofNullable(map.get("key"));
1

这样一来，只要看到这段代码，后面的人就知道该处的value值可能为空，很好的传达了程序处理的合理性，如果像上面那样，可能直接被当成存在对象使用，而引发空指针异常。

尽量不用于域模型中的某些类型

Optional的设计者并没有考虑将其作为类的字段使用，所以并没有实现Serializable接口，当使用到关于序列化的相关需求时，可能会引发的程序错误。如果确实有需求，可以采用以下方法作为替代方案：

public class Person { 
 private Car car; 
 public Optional<Car> getCarAsOptional() { 
     return Optional.ofNullable(car); 
 } 
} 
123456

总结

Optional主要是通过类型系统让你的域模型中隐藏的知识显式地体现在你的代码中，换句话说，你永远都不应该忘记语言的首要功能就是沟通，即使对程序设计语言而言也没有什么不同。声明方法接受一个Optional参数，或者将结果作为Optional类型返回，让你的同事或者未来你方法的使用者，很清楚地知道它可以接受空值，或者它可能返回一个空值。

多态

• 常见形式
  • 父类类型 对象名称 = new 子类构造器;
  • 接口 对象名称 = new 实现类构造器;
• 访问特点
  • 方法调用
  • 变量调用
• 前提条件
• 类型转换
  • 自动（子到父）
  • 强制（父到子）
    • 实现调用子类独有功能
  • instanceof

内部类

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

• 静态内部类
• 成员内部类
• 局部内部类
• 匿名内部类
  • 特点
    • 匿名内部类是一个没有名字的内部类。
    • 匿名内部类写出来就会产生一个匿名内部类的对象。
    • 匿名内部类的对象类型相当于是当前new的那个的类型的子类类型
• 格式
  • 匿名内部类可以作为方法的实际参数进行传输。

String类

在Java语言中，所有类似“ABC”的字面值，都是String类的实例；String类位于java.lang包下，是Java语言的核心类，提供了字符串的比较、查找、截取、大小写转换等操作；Java语言为“+”连接符（字符串连接符）以及对象转换为字符串提供了特殊的支持，字符串对象可以使用“+”连接其他对象。String类的部分源码如下

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    /** Cache the hash code for the string */
    private int hash; // Default to 0
    ...
}

从上面可以看出

1）String类被final关键字修饰，意味着String类不能被继承，并且它的成员方法都默认为final方法；字符串一旦创建就不能再修改。
2）String类实现了Serializable、CharSequence、 Comparable接口。
3）String实例的值是通过字符数组实现字符串存储的。

为什么是不可变类型

在面向对象及函数编程y语言中，不可变对象是一种对象，在被创造之后，它的状态就不可以被改变。

我们可理解为：

一个对象创建完成之后，它的状态就不能再改变，包括的对象里面的成员变量，基本数据类型的值都不能改变，这样就叫做不可变对象

理解定义不叫简单，但是实际情况下我们总会混淆引用与对象，进而以为String可变，比如下面代码：

输出：

那么是String类型的s发生变化了才将abc改变成了123吗?

显然不是的，s只是一个引用，真正的对象是后面的abc和123，所以在内存中的关系这样的

abc对象并没有改变，而是将引用重新指向了一个新的对象123.

我们再从源码的角度看

我们点进String类，可以看到String类是被final修饰的。

我们看到final修饰了类就不能被继承，就是最终类了，它的方法不能被继承重写

String类型其实使用char类型的数组存放的，而这个数组也被final关键字修饰了

在整个String类中并没有一个用来修改对象值的方法

综上我们说java 中的String是不可变的

        String s = "abc";
        System.out.println(s);
        s = "123";
        System.out.println(s);

常用方法

构造方法

/*
 * 关于String类中的构造方法:
 *  1、String s = new String("");
 *  2、String s = "";  //最常用
 *  3、String s = new String(char数组);
 *  4、String s = new String(char数组，起始下标，长度);
 *  5、String s = new String(byte数组）;
 *  6、String s = new String(byte数组，起始下标，长度);
*/
public class StringTest01 {
    public static void main(String[] args) {
        byte [] bytes = {97,98,99}; //abc
        //String(字节数组，数组元素下标的起始位置，长度)
        String s1 = new String(bytes,1,2); //可将byte数组中一部分元素转为字符串
        String s2 = new String(bytes); //将byte数组全部转为字符串
        System.out.println(s1); //输出bc
        System.out.println(s2); //输出abc
        char[] chars ={'你','好','啊'};
        String s3 = new String(chars);
        String s4 = new String(chars,0,1);
        System.out.println("s3:"+ s3 + "s4:"+s4);
    }
}

• 赋值创建和构造方法创建区别
• ==比较
  • 基本类型
  • 引用类型

“+”连接符

“+”连接符的实现原理

Java语言为“+”连接符以及对象转换为字符串提供了特殊的支持，字符串对象可以使用“+”连接其他对象。

其中字符串连接是通过 StringBuilder（或 StringBuffer）类及其append 方法实现的

对象转换为字符串是通过 toString 方法实现的，该方法由 Object 类定义，并可被 Java 中的所有类继承。

我们可以通过反编译验证一下

/**
 * 测试代码
 */
public class Test {
    public static void main(String[] args) {
        int i = 10;
        String s = "abc";
        System.out.println(s + i);
    }
}
/**
 * 反编译后
 */
public class Test {
    public static void main(String args[]) {    //删除了默认构造函数和字节码
        byte byte0 = 10;      
        String s = "abc";      
        System.out.println((new StringBuilder()).append(s).append(byte0).toString());
    }
}

由上可以看出，Java中使用”+”连接字符串对象时，会创建一个StringBuilder()对象，并调用append()方法将数据拼接，最后调用toString()方法返回拼接好的字符串。由于append()方法的各种重载形式会调用String.valueOf方法，所以我们可以认为：

//以下两者是等价的
s = i + ""
s = String.valueOf(i);
//以下两者也是等价的
s = "abc" + i;
s = new StringBuilder("abc").append(i).toString();
1234567

“+”连接符的效率

使用“+”连接符时，JVM会隐式创建StringBuilder对象，这种方式在大部分情况下并不会造成效率的损失，不过在进行大量循环拼接字符串时则需要注意。

String s = "abc";
for (int i=0; i<10000; i++) {
    s += "abc";
}
/**
 * 反编译后
 */
String s = "abc";
for(int i = 0; i < 1000; i++) {
     s = (new StringBuilder()).append(s).append("abc").toString();    
}

这样由于大量StringBuilder创建在堆内存中，肯定会造成效率的损失，所以在这种情况下建议在循环体外创建一个StringBuilder对象调用append()方法手动拼接（如上面例子如果使用手动拼接运行时间将缩小到1/200左右）。

/**
 * 循环中使用StringBuilder代替“+”连接符
 */
StringBuilder sb = new StringBuilder("abc");
for (int i = 0; i < 1000; i++) {
    sb.append("abc");
}
sb.toString();

与此之外还有一种特殊情况，也就是当”+”两端均为编译期确定的字符串常量时，编译器会进行相应的优化，直接将两个字符串常量拼接好，例如：

System.out.println("Hello" + "World");
/**
 * 反编译后
 */
System.out.println("HelloWorld");
/**
 * 编译期确定
 * 对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。
 * 所以此时的"a" + s1和"a" + "b"效果是一样的。故结果为true。
 */
String s0 = "ab"; 
final String s1 = "b"; 
String s2 = "a" + s1;  
System.out.println((s0 == s2)); //result = true
/**
 * 编译期无法确定
 * 这里面虽然将s1用final修饰了，但是由于其赋值是通过方法调用返回的，那么它的值只能在运行期间确定
 * 因此s0和s2指向的不是同一个对象，故上面程序的结果为false。
 */
String s0 = "ab"; 
final String s1 = getS1(); 
String s2 = "a" + s1; 
System.out.println((s0 == s2)); //result = false 
public String getS1() {  
    return "b";   
}

综上，“+”连接符对于直接相加的字符串常量效率很高，因为在编译期间便确定了它的值，也就是说形如”I”+“love”+“java”; 的字符串相加，在编译期间便被优化成了”Ilovejava”。对于间接相加（即包含字符串引用，且编译期无法确定值的），形如s1+s2+s3; 效率要比直接相加低，因为在编译器不会对引用变量进行优化。

字符串常量池

在Java的内存分配中，总共3种常量池，分别是Class常量池、运行时常量池、字符串常量池。

字符串的分配和其他对象分配一样，是需要消耗高昂的时间和空间的，而且字符串使用的非常多。JVM为了提高性能和减少内存的开销，在实例化字符串的时候进行了一些优化：使用字符串常量池。每当创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就直接返回常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中。由于String字符串的不可变性，常量池中一定不存在两个相同的字符串。

/**
 * 字符串常量池中的字符串只存在一份！
 * 运行结果为true
 */
String s1 = "hello world!";
String s2 = "hello world!";
System.out.println(s1 == s2);

内存区域

在HotSpot VM中字符串常量池是通过一个StringTable类实现的，它是一个Hash表，默认值大小长度是1009；这个StringTable在每个HotSpot VM的实例中只有一份，被所有的类共享；字符串常量由一个一个字符组成，放在了StringTable上。要注意的是，如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降（因为要一个一个找）。

在JDK6及之前版本，字符串常量池是放在Perm Gen区(也就是方法区)中的，StringTable的长度是固定的1009；在JDK7版本中，字符串常量池被移到了堆中，StringTable的长度可以通过-XX:StringTableSize=66666参数指定。至于JDK7为什么把常量池移动到堆上实现，原因可能是由于方法区的内存空间太小且不方便扩展，而堆的内存空间比较大且扩展方便。

存放的内容

在JDK6及之前版本中，String Pool里放的都是字符串常量；在JDK7.0中，由于String.intern()发生了改变，因此String Pool中也可以存放放于堆内的字符串对象的引用。

/**
 * 运行结果为true false
 */
String s1 = "AB";
String s2 = "AB";
String s3 = new String("AB");
System.out.println(s1 == s2);
System.out.println(s1 == s3);

由于常量池中不存在两个相同的对象，所以s1和s2都是指向JVM字符串常量池中的”AB”对象。new关键字一定会产生一个对象，并且这个对象存储在堆中。所以String s3 = new String(“AB”);产生了两个对象：保存在栈中的s3和保存堆中的String对象。

当执行String s1 = “AB”时，JVM首先会去字符串常量池中检查是否存在”AB”对象，如果不存在，则在字符串常量池中创建”AB”对象，并将”AB”对象的地址返回给s1；如果存在，则不创建任何对象，直接将字符串常量池中”AB”对象的地址返回给s1。

intern方法*

直接使用双引号声明出来的String对象会直接存储在字符串常量池中，如果不是用双引号声明的String对象，可以使用String提供的intern方法。intern 方法是一个native方法，intern方法会从字符串常量池中查询当前字符串是否存在，如果存在，就直接返回当前字符串；如果不存在就会将当前字符串放入常量池中，之后再返回。

JDK1.7的改动：

1. 将String常量池 从 Perm 区移动到了 Java Heap区
2. String.intern() 方法时，如果存在堆中的对象，会直接保存对象的引用，而不会重新创建对象。

/**
 * Returns a canonical representation for the string object.
 * <p>
 * A pool of strings, initially empty, is maintained privately by the
 * class {@code String}.
 * <p>
 * When the intern method is invoked, if the pool already contains a
 * string equal to this {@code String} object as determined by
 * the {@link #equals(Object)} method, then the string from the pool is
 * returned. Otherwise, this {@code String} object is added to the
 * pool and a reference to this {@code String} object is returned.
 * <p>
 * It follows that for any two strings {@code s} and {@code t},
 * {@code s.intern() == t.intern()} is {@code true}
 * if and only if {@code s.equals(t)} is {@code true}.
 * <p>
 * All literal strings and string-valued constant expressions are
 * interned. String literals are defined in section 3.10.5 of the
 * <cite>The Java&trade; Language Specification</cite>.
 *
 * @return  a string that has the same contents as this string, but is
 *          guaranteed to be from a pool of unique strings.
 */
public native String intern();

intern的用法

static final int MAX = 1000 * 10000;
static final String[] arr = new String[MAX];
public static void main(String[] args) throws Exception {
    Integer[] DB_DATA = new Integer[10];
    Random random = new Random(10 * 10000);
    for (int i = 0; i < DB_DATA.length; i++) {
        DB_DATA[i] = random.nextInt();
    }
    long t = System.currentTimeMillis();
    for (int i = 0; i < MAX; i++) {
        //arr[i] = new String(String.valueOf(DB_DATA[i % DB_DATA.length]));
         arr[i] = new String(String.valueOf(DB_DATA[i % DB_DATA.length])).intern();
    }
    System.out.println((System.currentTimeMillis() - t) + "ms");
    System.gc();
}

运行的参数是：-Xmx2g -Xms2g -Xmn1500M 上述代码是一个演示代码，其中有两条语句不一样，一条是未使用 intern，一条是使用 intern。结果如下图

未使用intern，耗时826ms：

使用intern，耗时2160ms：

通过上述结果，我们发现不使用 intern 的代码生成了1000w 个字符串，占用了大约640m 空间。 使用了 intern 的代码生成了1345个字符串，占用总空间 133k 左右。其实通过观察程序中只是用到了10个字符串，所以准确计算后应该是正好相差100w 倍。虽然例子有些极端，但确实能准确反应出 intern 使用后产生的巨大空间节省。

细心的同学会发现使用了 intern 方法后时间上有了一些增长。这是因为程序中每次都是用了 new String 后，然后又进行 intern 操作的耗时时间，这一点如果在内存空间充足的情况下确实是无法避免的，但我们平时使用时，内存空间肯定不是无限大的，不使用 intern 占用空间导致 jvm 垃圾回收的时间是要远远大于这点时间的。 毕竟这里使用了1000w次intern 才多出来1秒钟多的时间。

String、StringBuilder和StringBuffer

继承结构

主要区别

1）String是不可变字符序列，StringBuilder和StringBuffer是可变字符序列。
2）执行速度StringBuilder > StringBuffer > String。
3）StringBuilder是非线程安全的，StringBuffer是线程安全的。

1. 线程安全
   首先就是：什么是线程 指路
   StringBuffer：线程安全，StringBuilder：线程不安全。
   因为 StringBuffer 的所有公开方法都是 synchronized 修饰的，而 StringBuilder 并没有 synchronized 修饰。
   StringBuffer代码片段：

   @Override
   public synchronized StringBuffer append(String str) {
   toStringCache = null;
   super.append(str);
   return this;
   }
   123456

   
   关于两者的线程安全上的问题的具体原因可以参考这里
   针对Synchronized关键字的原理可以参考这里：个人总结起来是这样的：通过对象监视器(monitor)基于底层操作系统的互斥锁(Mutex Lock)来实现了对方法、同步块的同步。

2. 缓冲区
   StringBulider代码片段：

   private transient char[] toStringCache;
   @Override
   public synchronized String toString() {
   if (toStringCache == null) {
       toStringCache = Arrays.copyOfRange(value, 0, count);
   }
   return new String(toStringCache, true);
   }
   12345678

   
   StringBuilder代码片段
   可以看出，StringBuffer 每次获取 toString 都会直接使用缓存区的 toStringCache 值来构造一个字符串。
   而 StringBuilder 则每次都需要复制一次字符数组，再构造一个字符串。
   所以，缓存冲这也是对 StringBuffer 的一个优化吧，不过 StringBuffer 的这个toString 方法仍然是同步的。

3. 性能
   既然StringBuffer是线程安全的，他的所有公开方法都是同步的，StringBuilder是没有对方法加锁同步的，所以毫无疑问，StringBuilder的性能要远大于StringBuffer。

所以：

String：适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

常用方法

StringBuffer s = new StringBuffer();

这样初始化出的StringBuffer对象是一个空的对象，

StringBuffer sb1=new StringBuffer(512);
分配了长度512字节的字符缓冲区。

StringBuffer sb2=new StringBuffer(“how are you?”)

创建带有内容的StringBuffer对象，在字符缓冲区中存放字符串“how are you?”

1、append方法

public StringBuffer append(boolean b)
//该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接，调用该方法以后，StringBuffer对象的内容也发生改 变，例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.append(true);
//则对象sb的值将变成”abctrue”
//使用该方法进行字符串的连接，将比String更加节约内容，经常应用于数据库SQL语句的连接。

2、deleteCharAt方法

public StringBuffer deleteCharAt(int index)
//该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“KMing”);
sb. deleteCharAt(1);
//该代码的作用删除字符串对象sb中索引值为1的字符，也就是删除第二个字符，剩余的内容组成一个新的字符串。所以对象sb的值变 为”King”。
//还存在一个功能类似的delete方法：
public StringBuffer delete(int start,int end)
//该方法的作用是删除指定区间以内的所有字符，包含start，不包含end索引值的区间。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb. delete (1,4);
//该代码的作用是删除索引值1(包括)到索引值4(不包括)之间的所有字符，剩余的字符形成新的字符串。则对象sb的值是”TString”。

3、insert方法

public StringBuffer insert(int offset, boolean b),
//该方法的作用是在StringBuffer对象中插入内容，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb.insert(4,false);
//该示例代码的作用是在对象sb的索引值4的位置插入false值，形成新的字符串，则执行以后对象sb的值是”TestfalseString”。

4、reverse方法

public StringBuffer reverse()
//该方法的作用是将StringBuffer对象中的内容反转，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.reverse();
//经过反转以后，对象sb中的内容将变为”cba”。

5、setCharAt方法

public void setCharAt(int index, char ch)该方法的作用是修改对象中索引值为index位置的字符为新的字符ch。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.setCharAt(1,’D’);
则对象sb的值将变成”aDc”。

6、trimToSize方法

public void trimToSize()
该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费，和String的trim()是一样的作用

7、length方法

该方法的作用是获取字符串长度

8、setlength方法

//该方法的作用是设置字符串缓冲区大小。
StringBuffer sb=new StringBuffer();
sb.setlength(100);
//如果用小于当前字符串长度的值调用setlength()方法，则新长度后面的字符将丢失。

9、sb.capacity方法

//该方法的作用是获取字符串的容量。
StringBuffer sb=new StringBuffer(“string”);
int i=sb.capacity();

10、ensureCapacity方法

该方法的作用是重新设置字符串容量的大小。
StringBuffer sb=new StringBuffer();
sb.ensureCapacity(32); //预先设置sb的容量为32

11、getChars方法

该方法的作用是将字符串的子字符串复制给数组。
getChars(int start,int end,char chars[],int charStart);
StringBuffer sb = new StringBuffer(“I love You”);
int begin = 0;
int end = 5;
//注意ch字符数组的长度一定要大于等于begin到end之间字符的长度
//小于的话会报ArrayIndexOutOfBoundsException
//如果大于的话，大于的字符会以空格补齐
char[] ch = new char[end-begin];
sb.getChars(begin, end, ch, 0);
System.out.println(ch);
结果：I lov

总结

String类是我们使用频率最高的类之一，也是面试官经常考察的题目，下面是一个小测验。

public static void main(String[] args) {
    String s1 = "AB";
    String s2 = new String("AB");
    String s3 = "A";
    String s4 = "B";
    String s5 = "A" + "B";
    String s6 = s3 + s4;
    System.out.println(s1 == s2);
    System.out.println(s1 == s5);
    System.out.println(s1 == s6);
    System.out.println(s1 == s6.intern());
    System.out.println(s2 == s2.intern());
}

运行结果：

解析：真正理解此题目需要清楚以下三点
1）直接使用双引号声明出来的String对象会直接存储在常量池中；
2）String对象的intern方法会得到字符串对象在常量池中对应的引用，如果常量池中没有对应的字符串，则该字符串将被添加到常量池中，然后返回常量池中字符串的引用；
3） 字符串的+操作其本质是创建了StringBuilder对象进行append操作，然后将拼接后的StringBuilder对象用toString方法处理成String对象，这一点可以用javap -c命令获得class文件对应的JVM字节码指令就可以看出来。

ATM系统

常用API

Object

• toString
• equals

Objects

• equals
• isNull

Math

• public static int abs (int a) 获取参数绝对值
• public static double ceil (double a) 向上取整
• public static double floor (double a) 向下取整
• public static int round (float a) 四舍五入
• public static int max (int a,int b) 获取两个int值中的较大值
• public static double pow (double a,double b) 返回a的b次幂的值
• public static double random () 返回值为double的随机值，范围[0.0,1.0)

System

• public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
• public static long currentTimeMillis() 返回当前系统的时间毫秒值形式
• public static void arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)

BigDecimal

• 作用
• 获取对象
  • BigDecimal b1 = BigDecimal.valueOf(0.1)
• 方法
  • public BigDecimal add(BigDecimal b)
  • public BigDecimal subtract(BigDecimal b)
  • public BigDecimal multiply(BigDecimal b)
  • public BigDecimal divide(BigDecimal b)
  • public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式) 除法

日期与时间

• date

   public static void main(String[] args) {
       // 1、创建一个Date类的对象：代表系统此刻日期时间对象
       Date d = new Date();
       System.out.println(d);
       // 2、获取时间毫秒值
       long time = d.getTime();
       System.out.println(time);
       System.out.println("----------------------------");
       // 1、得到当前时间
       Date d1 = new Date();
       System.out.println(d1);
       // 2、当前时间往后走 1小时  121s
       long time2 = System.currentTimeMillis();
       time2 += (60 * 60 + 121) * 1000;
       // 3、把时间毫秒值转换成对应的日期对象。
       // Date d2 = new Date(time2);
       // System.out.println(d2);
       Date d3 = new Date();
       d3.setTime(time2);
       System.out.println(d3);
   }

• SimpleDate ```java SimpleDateFormat函数的继承关系：

java.lang.Object | +——java.text.Format | +——java.text.DateFormat | +——java.text.SimpleDateFormat

下面一个小例子：

import java.text.*; import java.util.Date;

/** SimpleDateFormat函数语法：

G 年代标志符 y 年 M 月 d 日 h 时 在上午或下午 (1~12) H 时 在一天中 (0~23) m 分 s 秒 S 毫秒 E 星期 D 一年中的第几天 F 一月中第几个星期几 w 一年中第几个星期 W 一月中第几个星期 a 上午 / 下午 标记符 k 时 在一天中 (1~24) K 时 在上午或下午 (0~11) z 时区 */ public class FormatDateTime {

public static void main(String[] args) {
    SimpleDateFormat myFmt=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
    SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm"); 
    SimpleDateFormat myFmt2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//等价于now.toLocaleString()
    SimpleDateFormat myFmt3=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");
    SimpleDateFormat myFmt4=new SimpleDateFormat(
            "一年中的第 D 天 一年中第w个星期 一月中第W个星期 在一天中k时 z时区");
    Date now=new Date();
    System.out.println(myFmt.format(now));
    System.out.println(myFmt1.format(now));
    System.out.println(myFmt2.format(now));
    System.out.println(myFmt3.format(now));
    System.out.println(myFmt4.format(now));
    System.out.println(now.toGMTString());
    System.out.println(now.toLocaleString());
    System.out.println(now.toString());
}    

}

效果： 2017年10月17日 20时57分00秒 17/10/17 20:57 2017-10-17 20:57:00 2017年10月17日 20时57分00秒 星期二 一年中的第 290 天 一年中第42个星期 一月中第3个星期 在一天中20时 CST时区 17 Oct 2017 12:57:00 GMT 2017-10-17 20:57:00 Tue Oct 17 20:57:00 CST 2017

-  Calendar 
```java
/**
    目标：日历类Calendar的使用,可以得到更加丰富的信息。
    Calendar代表了系统此刻日期对应的日历对象。
    Calendar是一个抽象类，不能直接创建对象。
    Calendar日历类创建日历对象的语法：
        Calendar rightNow = Calendar.getInstance();
    Calendar的方法：
        1.public static Calendar getInstance(): 返回一个日历类的对象。
        2.public int get(int field)：取日期中的某个字段信息。
        3.public void set(int field,int value)：修改日历的某个字段信息。
        4.public void add(int field,int amount)：为某个字段增加/减少指定的值
        5.public final Date getTime(): 拿到此刻日期对象。
        6.public long getTimeInMillis(): 拿到此刻时间毫秒值
    小结：
        记住。
 */
public class CalendarDemo{
    public static void main(String[] args) {
        // 1、拿到系统此刻日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
        // 2、获取日历的信息:public int get(int field)：取日期中的某个字段信息。
        int year = cal.get(Calendar.YEAR);
        System.out.println(year);
        int mm = cal.get(Calendar.MONTH) + 1;
        System.out.println(mm);
        int days = cal.get(Calendar.DAY_OF_YEAR) ;
        System.out.println(days);
        // 3、public void set(int field,int value)：修改日历的某个字段信息。
        // cal.set(Calendar.HOUR , 12);
        // System.out.println(cal);
        // 4.public void add(int field,int amount)：为某个字段增加/减少指定的值
        // 请问64天后是什么时间
        cal.add(Calendar.DAY_OF_YEAR , 64);
        cal.add(Calendar.MINUTE , 59);
        //  5.public final Date getTime(): 拿到此刻日期对象。
        Date d = cal.getTime();
        System.out.println(d);
        //  6.public long getTimeInMillis(): 拿到此刻时间毫秒值
        long time = cal.getTimeInMillis();
        System.out.println(time);
    }
}

UTC

协调世界时（Coordinated Universal Time）又称世界统一时间、世界标准时间，由于英文（CUT）和法文（TUC）的缩写不同，作为妥协，简称UTC。

时区

由于世界各国家与地区经度不同，地方时也有所不同，因此会划分为不同的时区

地球是自西向东自转，东边比西边先看到太阳，东边的时间也比西边的早。东边时刻与西边时刻的差值不仅要以时计，而且还要以分和秒来计算，这给人们带来不便

为了克服时间上的混乱，1884年在华盛顿召开的一次国际经度会议（又称国际子午线会议）上，规定将全球划分为24个时区（东、西各12个时区）。规定英国（格林尼治天文台旧址）为中时区（零时区）、东1—12区，西1—12区。每个时区横跨经度15度，时间正好是1小时。最后的东、西第12区各跨经度7.5度，以东、西经180度为界。每个时区的中央经线上的时间就是这个时区内统一采用的时间，称为区时，相邻两个时区的时间相差1小时 《摘自百度百科》

因为北京属于东8区，所以需要在世界统一时间（UTC）的基础上加8小时

java.time包简介

java.time包主要提供了日期、时间、瞬间、持续时间的api

主要的日期时间概念，包括时刻，持续时间，日期，时间，时区和时段。 基于ISO日历系统，所有的类都是不可变的，线程安全的

按类型主要分为：

• 日期和时间
  • Instant本质上是一个数字时间戳。
  • LocalDate存储没有时间的日期，如2010-07-09
  • LocalTime 存储没有日期的时间，如22：18
  • LocalDateTime 存储日期和时间。如2020-07-09T22:18
  • ZonedDateTime 存储带时区的日期和时间
• 期限
  • Duration 存储期间和持续时间。以纳秒为单位的时间线的简单测量
• 附加的类型
  • Month 存储一个月。如“十一月”
  • DayOfWeek 存储一周中的一天，如“Tuesday”
  • Year 存储年，如“2020”
  • YearMonth 存储年和月，如“2020-10”，可用于信用卡上的到期
  • MonthDay 存储月和日，如“12-14”，可用于存储生日
  • OffsetTime 存储与UTC没有日期的时间和偏移量
  • OffsetDateTime存储与UTC的日期时间和偏移量

下面来分别看一下各自的用法

Instant

Instant表示的是时间线上的瞬间点，本质上就是时间戳

        Instant instant = Instant.now();
        //默认时间比北京时间相差8小时
        System.out.println(instant);// 2020-07-10T12:52:56.053Z
        //设置时区后，显示正常时间
        System.out.println(instant.atZone(ZoneId.systemDefault()));//2020-07-10T20:52:56.053+08:00[Asia/Shanghai]
        //获取当前时间戳的秒数
        System.out.println(instant.getEpochSecond());
        //获取当前时间戳的毫秒
        System.out.println(instant.toEpochMilli());
        //Date类型转换为Instant
        Instant instant1 = Instant.ofEpochMilli(new Date().getTime());
        System.out.println(instant1);
        //将字符串转换成Instant
        Instant instant2 = Instant.parse("2020-07-10T12:52:56.053Z");
        System.out.println(instant2);
        //将Clock转换成Instant
        Instant instant3 = Instant.now(Clock.systemUTC());
        System.out.println(instant3);
        //加3小时，注意加操作对instant对象本身来说没有影响
        System.out.println(instant.plus(3, ChronoUnit.HOURS)); //2020-07-10T16:32:16.570Z
        System.out.println(instant);//2020-07-10T13:32:16.570Z
        Instant ins1 = Instant.parse("2020-07-10T12:52:56.053Z");
        Instant ins2 = Instant.parse("2020-07-10T12:52:46.034Z");
        //时间戳比较
        System.out.println(ins1.isAfter(ins2));
        System.out.println(ins1.isBefore(ins2));
12345678910111213141516171819202122232425262728293031