目录
一、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<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.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<Integer>() {
@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<Integer>() {
@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<String>() {
@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<GirlFriend>() {
@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);
}
}
