Arrays&Lambda表达式
目录
一、Arrays
1、Arrays操作数组的工具类编辑
二、Lambda表达式
1、Lambda初体验
编辑
2、函数式编程
编辑
3、Lambda表达式的标准格式
3.1 示例代码
4、小结
编辑5、Lambda表达式的省略写法
编辑5.1 示例代码
5.2 小结
编辑6、Lambda表达式的练习
6.1 Lambda表达式简化Comparator接口的匿名形式
三、综合练习
1、按照要求进行排序（Lambda）
2、不死神兔（递归）
3、猴子吃桃子（递归）
4、爬楼梯（递归）
一、Arrays
1、Arrays操作数组的工具类
代码示例：
import java.util.Arrays;
public class ArraysDemo1 {
public static void main(String[] args) {
/*
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(数组,排序规则) 按照指定的规则排序
*/
//toString：将数组变成字符串
System.out.println("---------------------toString---------------------");
int[] arr = {1,2,3,4,5,6,7,8,9,10};
System.out.println(Arrays.toString(arr));
//binarySearch：二分查找法查找元素
//细节1：二分查找的前提：数组中的元素必须是有序，数组中的元素必须是升序的
//细节2：如果查找的元素是不存在的，返回的是 -插入点 -1
//但是，如果要查找的元素是不存在的，返回的是-插入点，就会出现问题了
//如果要查找数组0.此时0是不存在的，但是按照上面的规则-插入点，应该就是-0
//为了避免这样的情况，Java在这个基础上又减一
System.out.println("---------------------binarySearch---------------------");
System.out.println(Arrays.binarySearch(arr,10));
System.out.println(Arrays.binarySearch(arr,2));
System.out.println(Arrays.binarySearch(arr,20));
//copyOf：拷贝数组
//参数一：老数组
//参数二：新数组长度
//方法底层会根据第二个参数来创建新的数组
//如果新数组的长度是小于老数组的长度，会拷贝部分
//如果新数组的长度是大于老数组的长度，会补上默认的初始值
System.out.println("---------------------copyOf---------------------");
int[] newArr1 = Arrays.copyOf(arr,20);
System.out.println(Arrays.toString(newArr1));
//copyOfRange：拷贝数组（指定范围）
//细节：包头不包尾，包左不包右
System.out.println("---------------------copyOfRange---------------------");
int[] newArr2 = Arrays.copyOfRange(arr, 0, 9);
System.out.println(Arrays.toString(newArr2));
//fill：填充数组
System.out.println("---------------------fill---------------------");
Arrays.fill(arr,100);
System.out.println(Arrays.toString(arr));
//sort：排序，默认情况下，给基本数据类型进行升序排列，底层使用的是快速排序
System.out.println("---------------------sort---------------------");
int[] arr2 = {10,2,3,5,6,1,7,8,4,9};
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
}
}
import java.util.Arrays;
import java.util.Comparator;
public class ArrayDemo2 {
public static void main(String[] args) {
/*
public static void sort(数组，排序规则) 按照指定的规则排序
参数一：要排序的数组
参数二：排序的规则
细节：
只能给引用数据类型的数组进行排序
如果数组是基本数据类型的，需要变成其对于的包装类
*/
Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};
//Arrays.sort(arr,规则);
//第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。
//但是这个实现类，我只要使用一次，所以就没有必要单独的去写一个类，直接采取匿名内部类的方式就可以了
//底层原理:
//利用插入排序 + 二分查找的方式进行排序的。
//默认把@索引的数据当做是有序的序列，1索引到最后认为是无序的序列。
//遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
//把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点。
//拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
//如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
//如果方法的返回值是正数，拿着A继续跟后面的数据进行比较
//如果方法的返回值是@，也拿着A跟后面的数据进行比较
//直到能确定A的最终位置为止。
//compare方法的形式参数:
//参数一 o1: 表示在无序序列中，遍历得到的每一个元素
//参数二 o2:有序序列中的元素
//返回值:
//负数: 表示当前要插入的元素是小的，放在前面
//正数:表示当前要插入的元素是大的，放在后面
//0: 表示当前要插入的元素跟现在的元素比是一样的们也会放在后面
//简单理解：
//o1-o2:升序排列
//o2-o1:降序排列
//Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};
Arrays.sort(arr, new Comparator() {
@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.println(Arrays.toString(arr));
}
}
示例代码比较数据时，分有序和无序，插入时，使用二分查找进行插入点的确认
此处不明白可以多看几遍视频Arrays
二、Lambda表达式
1、Lambda初体验
import java.util.Arrays;
public class LambdaDemo1 {
public static void main(String[] args) {
//初始lambda表达式
Integer[] arr = {2,3,1,5,6,7,8,4,9};
//匿名内部类
/*
Arrays.sort(arr, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
*/
//Lambda完整格式
Arrays.sort(arr, (Integer o1, Integer o2) -> {
return o1 - o2;
}
);
}
}
2、函数式编程
3、Lambda表达式的标准格式
加上注解后如果不满足要求，就会报错
3.1 示例代码
public class LambdaDemo2 {
public static void main(String[] args) {
/*
Lambda表达式的注意点:
1.Lambda表达式可以用来简化匿名内部类的书写
2.Lambda表达式只能简化函数式接口的匿名内部类的写法
3.函数式接口:
e
有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FunctionalInterface注解
*/
//1.利用匿名内部类的形式去调用下面的方法
//调用一个方法的时候，如果方法的形参是一个接口，那么我们要传递这个接口的实现类对象
//如果实现类对象只要用到一次，就可以用匿名内部类的形式进行书写
method(new Swim() {
@Override
public void swimmimg() {
System.out.println("正在游泳~~~");
}
});
//2.利用lambda表达式进行改写
//必须使用接口
method(
()->{
System.out.println("正在游泳~~~");
}
);
}
public static void method(Swim s){
s.swimmimg();
}
}
@FunctionalInterface
interface Swim {
public abstract void swimmimg();
}函数式接口：
@FunctionalInterface
interface Swim {
public abstract void swimmimg();
} 
4、小结
5、Lambda表达式的省略写法
5.1 示例代码
import java.util.Arrays;
public class LambdaDemo3 {
public static void main(String[] args) {
/*
lambda的省略规则：
1.参数类型可以省略不写
2.如果只有一个参数，参数类型可以省略，同时()也可以省略
3.如果Lambda表达式方法只有一行，大括号，分号，return可以省略不写，需要同时省略
*/
Integer[] arr = {2,3,1,5,6,7,8,4,9};
/*Arrays.sort(arr, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
//Lambda完整格式
Arrays.sort(arr, (Integer o1, Integer o2) -> {
return o1 - o2;
}
);*/
//Lambda省略方法
//o1-o2：正序
//o2-o1：倒序
Arrays.sort(arr,(o1,o2)->o1-o2);
System.out.println(Arrays.toString(arr));
}
}
5.2 小结
6、Lambda表达式的练习
6.1 Lambda表达式简化Comparator接口的匿名形式
定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
要求:
按照字符串的长度进行排序，短的在前面，长的在后面。
(暂时不比较字符串里面的内容)
代码实现：
import java.util.Arrays;
public class LambdaDemo4 {
public static void main(String[] args) {
/*
定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
要求:
按照字符串的长度进行排序，短的在前面，长的在后面。
(暂时不比较字符串里面的内容)
*/
String[] arr = {"a","aaaa","aaa","aa"};
//如果以后我们要把数组中的数据按照指定的方式进行排列，就需要用到sort方法，而且要指定排序的规则
/* Arrays.sort(arr, new Comparator() {
@Override
public int compare(String o1, String o2) {
//字符串的长度进行排序
return o1.length()-o2.length();
}
});
//Lambda完整格式
Arrays.sort(arr, (String o1, String o2)-> {
return 0;
}
);*/
//Lambda 简写格式
//小括号: 数据类型可以省略，如果参数只有一个，小括号还可以省略
//大括号: 如果方法体只有一行，return，分号，大括号都可以省略
Arrays.sort(arr,(o1,o2)->o1.length()-o2.length());
//打印数组
System.out.println(Arrays.toString(arr));
}
}
三、综合练习
1、按照要求进行排序（Lambda）
//JavaBean类
public class GirlFriend {
//要求1：属性有姓名、年龄、身高
private String name;
private int age;
private double height;
public GirlFriend() {
}
public GirlFriend(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return height
*/
public double getHeight() {
return height;
}
/**
* 设置
* @param height
*/
public void setHeight(double height) {
this.height = height;
}
public String toString() {
return "GirlFriend{name = " + name + ", age = " + age + ", height = " + height + "}";
}
}
//测试类
import java.util.Arrays;
public class Test1 {
public static void main(String[] args) {
/*定义数组并存储一些女朋友对象，利用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("xiaoshishi", 19, 1.78);
GirlFriend gf34 = new GirlFriend("abc", 19, 1.78);
//2.定义数组存储女朋友信息
GirlFriend[] arr = {gf1, gf2, gf3};
//3.利用Arrays中的sort方法进行排序
//匿名内部类 Lambda表达式
/*Arrays.sort(arr, new Comparator() {
@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;
}
}
});*/
//Lambda表达式
//() -> {}
//()：对应着抽象方法的形参
//{}：方法
Arrays.sort(arr, (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));
}
}
字符串比较
//字符串比较使用compareTo（）
String s1="abc";//99
String s2="abd";//100
int i = s1.compareTo(s2);
System.out.println(i);//-12、不死神兔（递归）
代码：
public class Test2 {
public static void main(String[] args) {
/* 有一个很有名的数学逻辑题叫做不死神兔问题，有一对兔子，从出生后第三个月起每个月都生一对兔子,
小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第十二个月的兔子对数为多少?
1月:1
2月:1
3月:2
4月:3
5月:5
6月:8
特点: 从第三个数据开始，是前两个数据和 (斐波那契数列)
*/
//求解1：
/* //1.创建一个长度为12的数组
int[] arr = new int[12];
//2.手动给0索引的数据进行赋值
arr[0] = 1;
arr[1] = 1;
//3.利用循环给剩余的数据进行赋值
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i-1]+arr[i-2];
}
//1 2 3 5 8 ....
//4.获取最大索引上的数据即可
System.out.println(arr[11]);*/
//求解2：
//递归的方式去完成
//1.递归的出口
//2.找到递归的规律
//Fn(12)=Fn(11)+Fn(10);
//Fn(11)=Fn(10)+Fn(9);
//Fn(10)=Fn(9)+Fn(8);
//...
//Fn(3)=Fn(2)+Fn(1);
//Fn(2)=1;
//Fn(1)=1;
System.out.println(getSum(12));//144
}
public static int getSum(int month){
if(month==1||month==2){
return 1;
}else{
return getSum(month-1)+getSum(month-2);
}
}
}
3、猴子吃桃子（递归）
代码
public class Test3 {
public static void main(String[] args) {
/*
有一堆桃子，猴子第一天吃了其中的一半，并多吃了一个!
以后每天猴子都吃当前剩下来的一半，然后再多吃一个，
第10天的时候(还没吃)，发现只剩下一个桃子了，请问，最初总共多少个桃了
day10: 1
day9: (day10 +1)*2 =4
day8: (day9 + 1)*2=1
1.出口
day== 10 剩下1
2.规律
每一天的桃子数量都是后一天数量加1，乘以2
*/
System.out.println(getCount(1));//1534
}
public static int getCount(int day){
if(day<=0||day>=11){
System.out.println("当前时间错误");
return -1;
}
//递归的出口
if(day==10){
return 1;
}
//书写规律
//每一天的桃子数量都是后一天数量加1，乘以2
return (getCount(day+1)+1)*2;
}
}
4、爬楼梯（递归）
代码：
public class Test4 {
public static void main(String[] args) {
/*
可爱的小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，有的时候一次爬两个台阶。
如果这个楼梯有10@个台阶，小明一共有多少种爬法呢?
运算结果:
1层台阶 1种爬法
2层台阶 2种爬法
7层台阶 21种爬法
*/
System.out.println(getCount(20));
}
public static int getCount(int n){
if (n == 1) {
return 1;
}else if(n==2){
return 2;
}
return getCount(n-1)+getCount(n-2);
}
}
/*
可爱的小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，
有的时候一次爬两个台阶，有的时候一次爬三个台阶。
如果这个楼梯有20个台阶，小明一共有多少种爬法呢
*/
public class Test5 {
public static void main(String[] args) {
/*
可爱的小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，
有的时候一次爬两个台阶，有的时候一次爬三个台阶。
如果这个楼梯有20个台阶，小明一共有多少种爬法呢
*/
System.out.println(getCount(20));//121415
}
public static int getCount(int n){
if (n == 1) {
return 1;
}else if(n==2){
return 2;
}else if(n==3){
return 4;
}
return getCount(n-1)+getCount(n-2)+getCount(n-3);
}
}