1.函数式接口
1)Lambda表达式
它可以简化匿名内部类,使用它的前提是拥有函数式接口,即只有一个抽象方法的接口.
我们来写个函数式接口:
interfance Playing{
String play();
}
接下来我们写个匿名内部类
public class Lambda {
public static void main(String[] args) {
new Abs(){
@Override
void haha() {
System.out.println("我是抽象类的匿名子类的对象");
}
}.haha();
Swimming s=new Swimming(){
@Override
public void swim() {
System.out.println("我想游泳");
}
};
}
}
@FunctionalInterface
interface Swimming{
void swim();
}
abstract class Abs{
abstract void haha();
}
接下来了解下lambda表达式的语法
- ()->{}
- ():匹配要重写的抽象方法的参数列表
- ->:lambdafu符号,箭头符号,具体上下文推导的作用
- {}:匹配要重写的抽象方法体
Lambda表达式写法1
s=()->{System.out.println("我边游泳边吃饭");};
s.swim();
Lambda表达式写法2 当语句体只有一句的时候,前后{}都可以省略
s=()->System.out.println("我边游泳边洗澡");
s.swim();
Lambda表达式写法3 ()中的数据类型可以省略
Swimming s=(x,y)->System.out.println("我边游泳边吃饭");
s.swim(3,5);
Lambda表达式写法4 ()中只有一个参数的时候,前后的()可以省略
Swimming s=x -> System.out.println("我边游泳边吃饭");
s.swim(3);
Lambda表达式写法4 {}中的语句只有一句,并且是return 返回值的语句,前后的{}+return关键字都可以省略
Swimming s=x->"哈哈"+x;
System.out.println(s.swim(5));
2.可变参数
1.定义:方法的参数类型一致,参数个数不确定,可以有可以没有,可以有多个
- 数据类型 ... 参数名 可变参数
- 自动在方法内部为可变参数构造数组,存储0~多个数据
- 如果参数列表中存在多个参数,可变参数一定要放在参数列表的最后位置
public class ParaDemo {
public static void main(String[] args) {
getSum(1,2,3,4,5);
}
static void getSum(int...i){
System.out.println(Arrays.toString(i));
}
}
我们可以通过给getSum输入数字,可变参数搭配Arrays.toString方法会自动帮我们输入的数字变成数组
public class ParaDemo {
public static void main(String[] args) {
getSum(1,2,3,4,5);
}
//num只为第一个数字
static void getSum(int num,int...i){
int sum=0;//设一个值存储计算值
for(int j=0;j<=i.length-1;j++){
sum+=i[j];//i这个数组内部数字之和
};
System.out.println(sum);
System.out.println(num);
System.out.println(Arrays.toString(i));
}
}
注意:可变参数只能放在正常参数的后面
3.二维数组
1.定义:二维数组:即数组中存储了数组,而不是数字,有种嵌套的感觉在里面
2.声明(三种形式)
- 数据类型 数组名 [ ] [ ]
- 数据类型 [ ] 数组名 [ ]
- 数据类型 数组名 [ ] [ ]
3.初始化
动态初始化
//二维数组的声明
int[][]arr1;
int arr2[][];
int [] arr3 [];
//二维数组的初始化
//动态初始化
arr1=new int[3][2];
arr1[0][0]=1;
arr1[0][1]=2;
arr1[1][0]=3;
arr1[1][1]=4;
arr1[2][0]=5;
arr1[2][1]=6;
//双层for循环遍历
for(int i=0;i<=arr1.length-1;i++){
for(int num:arr1[i]){
System.out.println(num);
}
}
静态初始化
arr3=new int[][]{{1,2,3},{1,2},{1},{1,2}};
for(int[]arr:arr3){
for(int i=0;i<=arr.length-1;i++){
System.out.println(arr[i]);
}
}
//就是简化了arr3的形式,把new int[][]简化掉
int[][]arr4={{1,2,3},{1,2},{1},{2,2}};
Arrays静态工厂常用方法
package clasapracitce;
import java.util.Arrays;
public class ArraysDemo04 {
public static void main(String[] args) {
String[] arr1={"hehe","haha","huohuo","heihei"};
String[] arr2={"hehe","haha","huohuo","heihei"};
int[][] arr3={{1,2,3},{1,2},{3,1,4}};
int[][] arr4={{1,2,3},{1,2},{3,1,4}};
//返回指定数组内容的字符串表示形式
//一维数组
System.out.println(Arrays.toString(arr1));
//二维数组
System.out.println(Arrays.deepToString(arr3));
//如果两个指定Object相等,返回true
//一维 比较地址
System.out.println(arr1==arr2);
//一维 比较内容
System.out.println(Arrays.equals(arr1, arr2));
//二维 比较地址
System.out.println(arr3==arr4);
//二维 比较 每个元素(外)中,第一个元素(内)的位置
System.out.println(Arrays.toString(arr3));
System.out.println(Arrays.equals(arr3, arr4));
//二维 比较 每个元素(外)中,每个元素(内)的内容
System.out.println(Arrays.deepEquals(arr3,arr4));
/*
* static<T> T[] copyOf(T[] original,int newLength) 截取或者填充
* 从索引为0的位置开始
* 参数:
* original 原数组
* newLength:新数组长度
* 返回值:新数组
*/
int[] arr5={1,2,3,6};
System.out.println("原数组"+Arrays.toString(arr5));
//若是新数组长度小于 原数组长度 则为 截取,从索引为0的位置开始截取
System.out.println("新数组长度"+Arrays.toString(Arrays.copyOf(arr5, 3)));
//若是新数组长度大于 原数组长度 则为 截取,从就数组最后的位置开始填充
//直到长度为新数组的长度,且默认为数据类型的默认值
System.out.println("新数组长度"+Arrays.toString(Arrays.copyOf(arr5, 5)));
/*
* static void fill(Object[] a, Object val) 将指定的 Object 引用分配给指定 Object 数组的每个元素。
*/
int[] arr12={1,2,3,5,7};
System.out.println("arr12原数组:"+Arrays.toString(arr12));
Arrays.fill(arr12, 132);
System.out.println("arr12填充后:"+Arrays.toString(arr12));
/*
* static void fill(Object[] a, int fromIndex, int toIndex, Object val) 将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
*/
int[] arr13={1,2,3,5,7};
System.out.println("arr13原数组:"+Arrays.toString(arr13));
Arrays.fill(arr13, 0,2,132);
System.out.println("arr13填充后:"+Arrays.toString(arr13));
/*
* static <T> T[] copyOfRange(T[] original, int from, int to) 将指定数组的指定范围复制到一个新数组。
* original原数组
* from 起始索引
* to 结束索引 (结束索引一般不包含)
*/
int[] arr6={1,2,6,7};
//从原数组的起始索引到结束索引(不包括)复制给新数组 复制原数组中索引为1和2的值
System.out.println(Arrays.toString(Arrays.copyOfRange(arr6, 1,3)));
/*
* static void sort(char[] a)
对指定的 char 型数组按数字升序进行排序。
static void sort(char[] a, int fromIndex, int toIndex)
对指定 char 型数组的指定范围按数字升序进行排序。
*/
int[] arr7=new int[]{1,3,4,6,7};
System.out.println("原数组"+Arrays.toString(arr7));
//对arr7进行升序排列 默认的,排序之后作用在 本身
Arrays.sort(arr7);
System.out.println(Arrays.toString(arr7));
//对arr7中索引到1-2进行升序排列 默认的,排序之后作用在 本身,默认不包括最后一个索引
int[] arr10=new int[]{1,9,4,6,7};
System.out.println("原数组 "+Arrays.toString(arr10));
Arrays.sort(arr10,1,4);
System.out.println("指定范围"+Arrays.toString(arr10));
//对arr8进行排序,安装unicode进行排序
char[] arr8=new char[]{'a','d','e','b'};
System.out.println("原数组"+Arrays.toString(arr8));
Arrays.sort(arr8);
System.out.println(Arrays.toString(arr8));
//对String类型进行排序,是从第一个字母开始比较
//如果第一个字母相同则比较第二个字母
String[] arr9 =new String[]{"ac","ad","be","bb"};
System.out.println("原数组"+Arrays.toString(arr9));
Arrays.sort(arr9);
System.out.println(Arrays.toString(arr9));
/*前提 要求: 先升序排序才可以
* static int binarySearch(int[] a, int key)
使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
*/
/*具体实现:先计算数组的中心的索引,如数组长度为5,则5/2=2
得出索引为2为中心,则比较索引为2的值与想要找寻的值的大小
如比它大,则索引为2+最后一个索引值4,得出中心索引为5,继续
比较以此类推,如没有找到则返回 (-预估算的位置)-1
*/
int[] arr11=new int[]{1,9,4,6,7};
System.out.println("原数组 "+Arrays.toString(arr11));
//先对其进行排序
Arrays.sort(arr11);
System.out.println("新数组 "+Arrays.toString(arr11));
//对其进行二分法查找
System.out.println(Arrays.binarySearch(arr11, 3));
}
}
