一、Arrays
操作数组的工具类
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args){
int[] arr=new int[]{1,2,3,4,5,6,7,8,9};
//将数组变为字符串 toString
System.out.println(Arrays.toString(arr)); //[1, 2, 3, 4, 5, 6, 7, 8, 9]
//二分法查询元素 binarySearch
//若元素存在则返回索引值，若不存在则返回 -插入点-1 （为了避免0时 -0 和 +0一样，导致错误
System.out.println(Arrays.binarySearch(arr,2)); //返回索引值 1
System.out.println(Arrays.binarySearch(arr,0)); //返回-插入点-1 ： -1
System.out.println(Arrays.binarySearch(arr,10)); //返回-插入点-1 ： -10
//拷贝数组 copyOf
//参数一：老数组 参数二：新数组的长度
//会根据第二个参数来创建一个新的数组：若新数组比老数组长度小，则会部分拷贝，若一致则完全拷贝，若长则会完全拷贝后补上默认值。
int[] arr1=Arrays.copyOf(arr,9);
System.out.println(Arrays.toString(arr1));
//指定范围拷贝数组 copyOfRange 包头不包尾，包左不包右
//参数一：老数组 参数二：起始索引 参数三：结束索引（不包含）
int[] arr2=Arrays.copyOfRange(arr,0,5);
System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 4, 5] 不包括索引为5的元素
//填充数组 fill
int[] arr3=new int[5];
Arrays.fill(arr3,100);
System.out.println(Arrays.toString(arr3)); //[100, 100, 100, 100, 100]
//排序 Sort
//情况一：默认情况下给数组进行升序排序，底层使用快速排序
int[] arr4=new int[]{5,8,2,3,4,8,1,6,10};
Arrays.sort(arr4);
System.out.println(Arrays.toString(arr4)); //[1, 2, 3, 4, 5, 6, 8, 8, 10]
//情况二： 指定排序规则
//参数一：要排序的数组 参数二：要排序的规则
//只能给引用数据类型的数组进行排序
//如果数组是基本数据类型的，需要变成对应的封装类
//参数二的规则是一个接口类型，因此在调用方法时，需要用一个该接口的实现类对象，作为排序的规则。
//这个实现类只需要使用一次，因此可以直接使用匿名内部类的方式
//底层原理：插入排序+二分查找的方式进行排序
//默认把0索引的数据当成是有序序列，0索引到最后都是无序序列
//遍历无序序列得到里面的每一个元素，假设为A，将A插入有序序列，插入时通过二分查找确定A的插入点
//通过Compare函数将A与插入点元素进行比较，若返回值为正数或者0，则将A继续与后面的元素进行比较。
//若返回值为负数，将A与前面的元素进行比较。直到确定A的最终插入位置。
//Compare函数 参数一：无序序列中遍历得到的每一个元素 参数二：有序序列中的元素
//返回值： 负数——表示当前要插入的元素小于拿来比较的元素，需要放在元素前面
// 0/正数——表示当前要插入的元素大于等于拿来比较的元素，需要放在元素后面
// o1-o2 升序排列 o2-o1 降序排列
Integer[] arr5=new Integer[]{10,5,6,8,1,2,7,3,5,4,9};
Arrays.sort(arr5, 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(arr5)); //[1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]
}二、Lambda表达式
产生于jdk8
面向对象：先找对象，让对象做事情
标准格式：
（）对应方法的形参
-> 固定格式
{ } 对应方法的方法体
注意：
①Lambda表达式可以用来简化匿名内部类的书写
②Lmabda表达式只能简化函数式接口的匿名内部类方法
③函数式接口： 有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加上 @FunctionalInterface注解
例：
public interface Swim {
public abstract void swimming();
}
public class Main {
public static void main(String[] args){
method(new Swim() {
@Override
public void swimming() {
System.out.println("正在游泳");
}
});
System.out.println("__________________");
method(
()->{
System.out.println("正在游泳");
});
}
public static void method(Swim s){
s.swimming();
}
}
省略格式：
核心：可推导，可省略
①参数类型可以省略不写
②如果只有一个参数，参数类型可以省略，同时（）也可以省略
③如果Lambda表达式的方法只有一行，大括号、分号、return可以省略不写，需要同时省略
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args){
Integer[] arr=new Integer[]{1,2,1,5,8,6,1,2,4,2};
//匿名内部类
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;
}
});
System.out.println(Arrays.toString(arr));//[1, 1, 1, 2, 2, 2, 4, 5, 6, 8]
System.out.println("____________________");
//lambda完整格式
Arrays.sort(arr,
(Integer o1,Integer o2)->{
return o2-o1;
});
System.out.println(Arrays.toString(arr));//[8, 6, 5, 4, 2, 2, 2, 1, 1, 1]
System.out.println("____________________");
//省略写法
Arrays.sort(arr, (o1,o2)-> o1-o2);
System.out.println(Arrays.toString(arr));//[1, 1, 1, 2, 2, 2, 4, 5, 6, 8]
System.out.println("____________________");
}
}
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args){
//按照字符串长度进行排序
String[] arr=new String[]{"aa","aaa","a","aaaaa","aaaa"};
Arrays.sort(arr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
Arrays.sort(arr, (o1,o2)->o1.length()-o2.length());
System.out.println(Arrays.toString(arr));
}
}
