Arrays
说明：
操作数组的工具类。
常用成员方法：
| 方法名 | 说明 |
| public static String toString (数组) | 把数组拼接成 一个字符串 |
| public static int binarySearch (数组，查找的元素) | 二分查找法 查找元素 |
| public static int[] copyOf (原数组，新数组长度) | 拷贝数组 |
| public static int[] copyOfRange (原数组,起始索引,结束索引) | 拷贝数组 (指定范围) |
| public static void fill (数组,元素) | 填充数组 |
| public static void sort (数组) | 按照默认方式 进行数组排序 |
| public static void sort (数组，排序规则) | 按照指定的 规则排序 |
代码演示：
import java.util.Arrays;public class Test1 {public static void main(String[] args) {int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9};//把数组拼接成一个字符串String str = Arrays.toString(arr1);System.out.println(str);//[1, 2, 3, 4, 5, 6, 7, 8, 9]//二分查找法查找元素//注意事项：//二分查找必须要求数组中元素是有序的，该方法进一步要求数组中元素是升序的//如果要查找的元素在数组中，返回该元素的索引//如果要查找的元素不在数组中，返回该元素应该插入的位置的索引的负值减1//减1：假如查找元素0时，不在数组中，返回应该插入的位置的索引的负值为-0//-0还是0，为了避免这样的情况，所以再减1，使其为-1int index1 = Arrays.binarySearch(arr1, 3);System.out.println(index1);//2int index2 = Arrays.binarySearch(arr1, 10);System.out.println(index2);//10int index3 = Arrays.binarySearch(arr1, 0);System.out.println(index3);//-1//拷贝数组//注意事项：//新数组长度如果小于原数组时，部分拷贝//新数组长度如果等于原数组时，完全拷贝//新数组长度如果大于原数组时，全部拷贝完后，剩余部分为默认初始化值int[] arr2 = Arrays.copyOf(arr1, 9);System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4, 5, 6, 7, 8, 9]int[] arr3 = Arrays.copyOf(arr1, 2);System.out.println(Arrays.toString(arr3));//[1, 2]int[] arr4 = Arrays.copyOf(arr1, 12);System.out.println(Arrays.toString(arr4));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0]//拷贝数组(指定范围)//包头不包尾int[] arr5 = Arrays.copyOfRange(arr1, 0, 5);System.out.println(Arrays.toString(arr5));//[1, 2, 3, 4, 5]//填充数组Arrays.fill(arr1, 10);System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10, 10, 10, 10, 10, 10]//按照默认方式进行数组排序int[] arr6 = {3, 4, 2, 7, 9, 1, 6, 8, 5};Arrays.sort(arr6);System.out.println(Arrays.toString(arr6));//[1, 2, 3, 4, 5, 6, 7, 8, 9]}
}
按照指定的规则排序：
注意事项：
第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。但是这个实现类，我只要使用一次，所以就没有必要单独的去写一个类，直接采取匿名内部类的方式就可以了
底层原理:
利用插入排序+二分查找的方式进行排序的。
默认把0索引的数据当做是有序的序列，1索引到最后认为是无序的序列。
遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点。
拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法。
compare方法的形式参数:
参数一 o1：表示在无序序列中，遍历得到的每一个元素
参数二 o2：有序序列中的元素
返回值:
负数：表示当前要插入的元素要放在前面
正数：表示当前要插入的元素要放在后面
0：表示当前要插入的元素跟现在的元素值是一样的，但也会放在后面
简单记忆：
compare方法方法体：
return o1-o2：升序排序
return o2-o1：降序排序
代码演示：
public class Test2 {public static void main(String[] args) {//public static void sort (数组，排序规则) 按照指定的规则排序Integer[] arr = {2, 5, 1, 3, 8, 6, 7, 9, 4};//升序排序Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1 - o2;}});System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 7, 8, 9]//2, 5, 1, 3, 8, 6, 7, 9, 4//5 2 1//降序排序Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;}});System.out.println(Arrays.toString(arr));//[9, 8, 7, 6, 5, 4, 3, 2, 1]}
}Lambda表达式：
说明：
Lambda表达式是JDK8开始后的一种新语法形式。
体现函数式思想，忽略面向对象的复杂语法，强调做什么，而不是谁去做。
标准格式：
() -> {}
()对应着方法的形参
-> 固定格式
{}对应着方法的方法体
注意事项：
Lambda表达式可以用来简化匿名内部类的书写
Lambda表达式只能简化函数式接口的匿名内部类的写法
函数式接口:
有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FunctionalInterface注解
代码演示：
import java.util.Arrays;
import java.util.Comparator;public class Test3 {public static void main(String[] args) {Integer[] arr = {9,6,7,5,8,3,1,4,2};//匿名内部类Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1-o2;}});//Lambda表达式Arrays.sort(arr,(Integer o1, Integer o2)-> {return o1-o2;});}
}
lambda的省略规则:
1.参数类型可以省略不写。
2.如果只有一个参数，参数类型可以省略，同时()也可以省略。
3.如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略。
代码演示：
public class Test3 {public static void main(String[] args) {Integer[] arr = {9,6,7,5,8,3,1,4,2};//匿名内部类Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1-o2;}});//Lambda表达式Arrays.sort(arr,(Integer o1, Integer o2)-> {return o1-o2;});//Lambda表达式,省略写法Arrays.sort(arr,(o1,o2)-> o1-o2);}
}Arrays及Lambda表达式综合练习：
需求：
定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
要求:
按照字符串的长度进行排序，短的在前面，长的在后面。
分析：
compare方法的形式参数:
参数一 o1：表示在无序序列中，遍历得到的每一个元素
参数二 o2：有序序列中的元素
返回值:
负数：表示当前要插入的元素要放在前面
正数：表示当前要插入的元素要放在后面
0：表示当前要插入的元素跟现在的元素值是一样的，但也会放在后面因此：
方法体为：return o1.length() - o2.length()
当无序序列中的元素的长度比有序序列中的元素的长度小，相减为负数，放在前面
当无序序列中的元素的长度比有序序列中的元素的长度大，相减为正数，放在后面
最终按照字符串长度从小到大排列
代码实现：
import java.util.Arrays;
import java.util.Comparator;public class Test4 {public static void main(String[] args) {String[] arr = {"aaa", "aa", "a", "aaaa"};//匿名内部类Arrays.sort(arr, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.length() - o2.length();}});System.out.println(Arrays.toString(arr));//[a, aa, aaa, aaaa]//Lambda表达式Arrays.sort(arr, (String o1, String o2) -> {return o1.length() - o2.length();});System.out.println(Arrays.toString(arr));//[a, aa, aaa, aaaa]//Lambda表达式，省略写法Arrays.sort(arr, (o1, o2) -> o1.length() - o2.length());System.out.println(Arrays.toString(arr));//[a, aa, aaa, aaaa]}
}
 与 models.objects.filter)