目录
Arrays
没有构造方法，不用创建对象，方法都是静态，直接调用
操作数组的工具类
toString
将数组变成字符串，底层就是字符串容器的代码，前面文章写过
System.out .print1n("-----------------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]
binarySearch
二分查找法查找元素
细节1:二分查找的前提:数组中的元素必须是有序，数组中的元素必须是升序的
细节2:如果要查找的元素是存在的，那么返回的是真实的索引
但是，如果要查找的元素是不存在的，返回的是-插入点-1
疑问:为什么要减1呢?
解释:如果此时，我现在要查找数字0，那么如果返回的值是-插入点，就会出现问题了。
如果要查找数字0，此时0是不存在的，但是按照上面的规则-插入点，应该就是-0，为了避免这样的情况，Java在这个基础上又减一。|
System.out.print1n("------------------binarySearch-----------------------");
System.out.print1n(Arrays.binarySearch(arr,key: 10));//9
System.out.println(Arrays.binarySearch(arr，key:2));//1
System.out.println(Arrays.binarySearch(arr, key: 20));//-11
copyOf
拷贝数组
参数一:老数组
参数二:新数组的长度
方法的底层会根据第二个参数来创建新的数组
- 如果新数组的长度是小于老数组的长度，会部分拷贝
- 如果新数组的长度是等于老数组的长度，会完全拷贝
- 如果新数组的长度是大于老数组的长度，会补上默认初始值
System.out.println("-------------------copy0f----------------------");
int[] newArr1 = Arrays.copy0f(arr, newLength: 20);
System.out.print1n(Arrays.toString(newArr1));//[1，2，3，4，5，6，7，8，9，10]
copyOfRange
拷贝数组(指定范围)
细节：包头不包尾，包左不包右
System.out.print1n("-------------------copy0fRange----------------------");
int[] newArr2 = Arrays.copy0fRange(arr, from: 0,to: 9);
System.out.println(Arrays.toString(newArr2));[1，2，3，4，5，6，7，8，9]
fill
填充数组
System.out.print1n("--------------------fill-------------------");
Arrays.fill(arr,val:100);
System.out.println(Arrays.toString(arr));//[100,100，100,100,100，100，100，100，100,100]
sort
排序
一个参数，默认情况下，给基本数据类型进行升序排列，底层使用的是快速排序。
System.out.println("--------------------sort---------------------");
int[] arr2 = {10，2，3，5，6，1,7，8， 4，9};
Arrays.sort(arr2);I
System.out.println(Arrays.toString(arr2));//[1，2，3，4，5，6，7，8，9，10]
两个参数
public static void sort(数组，排序规则)
Integer[] arr = {2, 3，1，5， 6， 7，8， 4，9};
按照指定的规则排序
- 参数一:要排序的数组
- 参数二:排序的规则
细节:
只能给引用数据类型的数组进行排序
如果数组是基本数据类型的，需要变成其对于的包装类
第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。但是这个实现类，只要使用一次，所以就没有必要单独的去写一个类，直接采取匿名内部类的方式就可以了
底层原理:
利用插入排序+二分查找的方式进行排序的。
默认把0索引的数据当做是有序的序列，1索引到最后认为是无序的序列。
遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点。
拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
- 如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
- 如果方法的返回值是正数，拿着A维续跟后面的数据进行比较
- 如果方法的返回值是0，也拿着A跟后面的数据进行比较
直到能确定A的最终位置
compare方法的形式参数:
参数一 o1:表示在无序序列中，遍历得到的每一个元素
参数二 o2:有序序列中的元素
返回值:
负数:表示当前要插入的元素是小的，放在前面
正数:表示当前要插入的元素是大的，放在后面
0:表示当前要插入的元素跟现在的元素比是一样的们也会放在后面
简单理解:
o1 - o2 :升序排列
o2 - 01 :降序排序
重写：
//Integer[] arr = {2, 3, 1,5, 6, 7，8， 4,9};
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println("------------------");
System.out.println("o1 : "+ o1);
System.out.println("o2 : "+ o2);
return o1- o2;
});
System.out.print1n(Arrays.toString(arr));// 1 2 3 5
Lambda表达式
Lambda表达式是JDK8开始后的一种新语法形式。
- ()对应着方法的形参
- ->固定格式
- {}对应着方法的方法体
Lambda表达式可以用来简化匿名内部类的书写
Lambda表达式只能简化函数式接口的匿名内部类的写法
函数式接口:
有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FunctionalInterface注解
//1.利用匿名内部类的形式去调用下面的方法
//调用一个方法的时候，如果方法的形参是一个接口，那么我们要传递这个接口的实现类对象
//如果实现类对象只要用到一次，就可以用匿名内部类的形式进行书写
/*method(new Swim(){
@override
public void swimming() {
System.out.println("正在游泳~~~");
});
}*/
method(
()->{
System.out.println("正在游泳~~~");
}
);
public static void method(Swim s){
s.swimming( );
}
interface Swim{
public abstract void swimming();
}
lambda的省略规则:
1.参数类型可以省略不写。
2.如果只有一个参数，参数类型可以省略，同时()也可以省略。
3.如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略。
经典算法题
排序
/*定义数组并存储一些女朋友对象，利用Arrays中的sort方法进行排序
要求1:属性有姓名、年龄、身高。
要求2:按照年龄的大小进行排序，年龄一样，按照身高排序，身高一样按照姓名的字母进行排序。
(姓名中不要有中文或特殊字符，会涉及到后面的知识)*/
//1.创建三个女朋友的对象
GirlFriend gf1 = new GirlFriend( "xiaoshishi", 18,1.67);
GirlFriend gf2 = new GirlFriend( "xiaodandan", 19,1.72);
GirlFriend gf3 = new GirlFriend( "xiaohuihui", 19,:1.78);
GirlFriend gf4 = new GirlFriend( "abc", 19,1.78);
//2.定义数组存储女朋友的信息
GirlFriend[] arr = {gf1，gf2，gf3，gf4};
//3.利用Arrays中的sort方法进行排序
//匿名内部类lambda表达式
Arrays.sort(arr, new Comparator<dirlFriend>(){
@override
public int compare(GirlFriend o1, GirlFriend o2) {
//按照年龄的大小进行排序，年龄一样，按照身高排序，身高一样按照姓名的字母进行排序
double temp = o1.getAge() - o2.getAge();
temp = temp == 0 ? o1.getHeight() - o2.getHeight(): temp;
temp = temp == 0 ? o1.getName().compareTo(o2.getName()): temp;
if(temp > 0){
return 1;
}else if(temp < 0){
return -1;
}else{
return 0;
}
}
});
//4.展示一下数组中的内容
System.out.println(Arrays.toString(arr));
斐波那契数列
/*小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第十二个月的兔子对数为多少?
1月:1
2月:1
3月:2
4月:3
5月:5
6月:8
特点:从第三个数据开始，是前两个数据和(斐波那契数列)
*/
//求解1:
//1.创建一个长度为12的数组
int[] arr = new int[12];
//2.手动给0索引和1索引的数据进行赋值
arr[0]= 1;
arr[1]= 1;
//3.利用循环给剩余的数据进行赋值
for (int i = 2; i < arr.length; i++) {
arr[i] = arr[i - 1]+ arr[i- 2];
}
//1 1 2 3 5 8
//4.获取最大索引上的数据即可
System.out.print1n(arr[11]);//144
//求解2:
//递归的方式去完成
//1.递归的出口
//2.找到递归的规律
//Fn(12) = Fn(11) + Fn(10);
//Fn(11) = Fn(10) + Fn(9);
//Fn(10) = Fn(9) + Fn(8);
//...
//Fn(3) = Fn(1) + Fn(2);
//Fn(2) = 1;
//Fn(1)=1;
System.out.println(getSum(month:12));//144
public static int getSum(int month){
if(month == 1 ||month == 2){
return 1;
}else{
return getSum( month - 1)+ getSum( month - 2);
}
猴子吃桃子
/*有一堆桃子，猴子第一天吃了其中的一半，并多吃了一个
以后每天猴子都吃当前剩下来的一半，然后再多吃一个，
第10天的时候(还没吃)，发现只剩下一个桃子了，请问，最初总共多少个桃子?
day10: 1
day9:
(day10 + 1) * 2 =4
day8:
(day9 + 1) * 2 =10
1.出口
day== 10
剩下1
2.规律
每一天的桃子数量都是后一天数量加1，乘以2
*/
public static int getCount(int day) {//1
if (day <= 0 || day >= 11) {
System.out.println("当前时间错误");
return -1;
}
//递归的出口
if(day == 10){
return 1;
}
//书写规律
//每一天的桃子数量都是后一天数量加1，乘以2
return (getCount( day: day + 1) + 1)* 2;
}
爬楼梯
public static void main(String[] args){
/*
可爱的小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，有的时候一次爬两个台阶。
如果这个楼梯有100个台阶，小明一共有多少种爬法呢?
运算结果:
1层台阶 1种爬法
2层台阶2种爬法
7层台阶 21种爬法
*/
System.out.println(getCount( 20));//10946
}
public static int getCount(int n){
if(n == 1){
return 1;
}
if(n == 2){
return 2;
}
return getCount(n - 1)+ getCount(n- 2);
}
