JAVA函數式接口\二維數組

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));
    }
}
複製代碼