JAVA函数式接口\二维数组

时间 2019-11-15

标签 java 函数接口二维数组栏目 Java 繁體版

原文原文链接

1.函数式接口

1)Lambda表达式

它能够简化匿名内部类,使用它的前提是拥有函数式接口,即只有一个抽象方法的接口.java

咱们来写个函数式接口:数组

interfance Playing{
    String play();
}
复制代码

接下来咱们写个匿名内部类ide

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表达式写法1spa

s=()->{System.out.println("我边游泳边吃饭");};
		s.swim();
复制代码

Lambda表达式写法2 当语句体只有一句的时候,先后{}均可以省略code

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));
    }
}
复制代码