一、Arrays类
1.定义
Arrays是一个用于操作数组的工具类。
2.常用方法
1.toString方法
public class Demo {
public static void main(String[] args) {
//toString 将数组变成字符串
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
} 
通过源码可以发现，就是很普通的遍历数组，将数组元素添加到 StringBuilder 对象中。
2.binarySearch方法
public class Demo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//binarySearch 二分查找法查找元素（前提：数组必须有序且升序）
System.out.println(Arrays.binarySearch(arr, 10));//9
System.out.println(Arrays.binarySearch(arr, 2));//1
System.out.println(Arrays.binarySearch(arr, 20));//-11
}
}细节：
① 二分查找的前提是有序表，但是对于 binarySearch 方法，还需要是升序的。
② 如果要查找的元素存在，返回索引；如果不存在，返回的是 -插入位置 - 1。
question：为什么需要 -1 呢？
对于该数组，如果要查找数字 0 ，此时 0 是不存在的。
如果只返回 -插入位置，也就是 -0 ，即 0 。
此时就没法确定，返回的这个 0 是表示数字 0 存在时返回的索引，还是不存在时的返回值。
为了避免这样的情况产生，java在此基础上，进行了 -1。
3.copyOf 方法
public class Demo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//copyOf 拷贝数组
int[] newArr = Arrays.copyOf(arr, 20);
System.out.println(Arrays.toString(newArr));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
}
}细节：
① 方法底层实际上调用的就是 System 类的 arraycopy 方法。
② 参数一是原数组，参数二表示新数组的长度。方法的底层会根据第二个参数来创建新的数组。
I. 如果新数组的长度 < 原数组的长度，则部份拷贝
II. 如果新数组的长度 = 原数组的长度，则完全拷贝
III. 如果新数组的长度 > 原数组的长度，则会补上默认初始化值。
4.copyOfRange方法
public class Demo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//copyOfRange 拷贝数组（指定范围）--> 包头不包尾，包左不包右
int[] newArr = Arrays.copyOfRange(arr, 0, 9);
System.out.println(Arrays.toString(newArr));
//[1, 2, 3, 4, 5, 6, 7, 8, 9]
}
}细节：
copyOfRange 方法在拷贝数组时，包头不包尾，包左不包右。
5.fill 方法
public class Demo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//fill 填充数组
Arrays.fill(arr, 100);
System.out.println(Arrays.toString(arr));
//[100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
}
}细节：
在底层，实质上就是一个 for 循环，将数组的每一个元素进行覆盖。
6.sort 方法
public class Demo {
public static void main(String[] args) {
int[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};
//sort 排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
}细节：
默认情况下，给基本数据类型进行升序排列，底层使用的是快速排序
question：如果我想对数组进行降序，如何实现？
**************************************************************************************************************
7.sort 重载方法
public class Demo {
public static void main(String[] args) {
Integer[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};
//public static void(数组, 排序规则) 按照指定规则进行排序
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
System.out.println(Arrays.toString(arr));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
}细节：
① 该方法只能给引用数据类型进行排序，如果数组是基本数据类型，需要变成其对应的包装类。
② 该方法的第二个参数是一个接口，表示排序规则。所以调用方法时，可以使用匿名内部类来作为这个接口的实现类对象。
③ 底层原理是使用折半插入排序（插入排序 + 二分查找）。
④ compare 方法的形参：
I. o1 表示在无序序列中，遍历得到的每一个元素；
II. o2 表示有序序列中的元素（按二分查找的顺序）。
compare 方法的返回值：
I. 负数：表示当前要插入的元素 < 已排好的元素，插在前面
II. 正数：表示当前要插入的元素 > 已排好的元素，插在后面
III. 0 ： 表示当前要插入的元素 = 已排好的元素，同样也插在后面
结论：
（1）待排（o1）-已排（o2）为正，说明待排 > 已排，待排放已排右边，即是升序。
（2）已排（o2）-待排（o1）为正，说明已排 > 待排，已排放待排右边，既是降序。
二、lambda表达式
1.函数式编程
面向对象编程：先创建对象，再让对象做事情。、
对于这种写法中，我们只关心方法中的逻辑（方法体），并不关心是哪个对象调用了这个方法。
但是对于面向对象编程，又不得不先创建对象，所以造成了一定的麻烦。
**************************************************************************************************************
函数式编程：忽略面向对象的复杂语法，强调做什么，而不是谁去做。
2.函数式接口
函数式接口：有且仅有一个抽象方法的接口（两个条件缺一不可）。
接口上方可以加上 @FunctionalInterface 注解进行验证，若不满足条件，则会报错。
3.Lambda表达式
Lambda表达式是JDK8开始后的一种新的语法格式。
（1）Lambda表达式的完整格式
省略 new，接口名，函数名等，用一个箭头让形参指向方法体,即：() -> {}
注意点：
① Lambda表达式可以用来简化匿名内部类的书写
② Lambda表达式只能简化函数式接口的匿名内部类的写法。
public class Demo {
public static void main(String[] args) {
Integer[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};
//public static void(数组, 排序规则) 按照指定规则进行排序
Arrays.sort(arr,(Integer o1, Integer o2) -> {
return o1 - o2;
}
);
System.out.println(Arrays.toString(arr));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
}（2） Lambda表达式的简写格式
即：凡是能推导出来的，都可以省略。
具体省略规则：
① 参数的数据类型可以省略不写
② 如果只有一个参数，参数类型可以省略，同时（）也可以省略。
public class Demo {
public static void main(String[] args) {
Greeting greeting = name -> {
System.out.println("Hello " + name);
};
greeting.greet("John");
}
}
@FunctionalInterface
interface Greeting {
public abstract void greet(String name);
}
③ 如果方法体只有一行，{}，分号，return，都可以省略不写，但必须同时省略。
public class Demo {
public static void main(String[] args) {
Integer[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};
//public static void(数组, 排序规则) 按照指定规则进行排序
Arrays.sort(arr,(o1, o2) -> o1 - o2);
System.out.println(Arrays.toString(arr));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
}
