初识JAVA11:可变参数、二维数组、Arrays类、内部类

可变参数

jkd1.5新增

​ 多个参数的类型相同,参数的个数可变,0~n个参数

​ …表示可变参数

​ 方法的形参可以存在多个,如果存在可变参数,必须存在与参数列表的最后

​ 编译器会为可变参数隐式构建一个数组,所在方法中使用可变参数,使用操作数据的方式操作可变参数

public class Demo{
    public static void main(String[] args){
        System.out.println(Param.sum(1,2,3,4,5));
        System.out.println(Param.except(16,2));
        System.out.println(Param.except(16,2,2,2));
    }

}


class Param{
    //可变参数列表
    public static int sum(int... args){
        int sum=0;
        for(int i:args){
            sum += i;
        }
        return sum;
    }
    //如果要求方法至少存在n个参数,那么将固定参数写在可变参数前面
    public static int except(int a,int b,int... args){
            a /=b;
        for(int i:args){
            a /= i;
        }
        return a;
    }
}

二维数组

数组中嵌套数组

声明:

​ 数据类型[ ] [ ] 数组名;

初始化:

​ 动态初始化:先创建数组,后赋值

​ 数据类型[ ] [ ] 数组名 = new

​ 数据类型[外层的长度] [内层的长度];

​ 特点: 内层的每一个一维小数组长度固定

​ 内层二维的长度;

​ 规定了外层一维数组中的每一个格子中的小数组的长度

​ 数据类型[ ] [ ] 数组名 = new 数据类型[外层二维数组的长度][ ];

​ 特点:内层的内一个一维小数组对象还没有创建,需要在能够确定的时候单独创建每一个内层一维数组

​ 数组名[索引] = 一维数组对象|一维数组的创建方式(动态|静态初始化);

​ 静态初始化:创建数组的同时赋值

​ 数据类型[ ] [ ] 数组名 = new 数据类型[][]{{数据1,数据2…},{数据1,数据2…},…};

操作二维数组中的数据:
根据索引
数组名[外层索引][内层的索引]

public class Demo {
    public static void main(String[] args) {
        int[][] arr1 = new int[2][2];

        int[][] arr2 = new int[1][];
        arr2[0] = new int[1];
        arr2[1] = new int[]{1,2,3};
        //可以为二维数组中包含的一维数组可以为不等长数组
        int[][] arr3 = new int[][]{{1,2,3},{4},{5,6}};
    }
}

二维数组的遍历

双重循环嵌套:

​ 普通嵌套普通

​ 普通嵌套增强

​ 增强嵌套增强

​ 增强嵌套普通

public class Demo {
    public static void main(String[] args) {
        int[][] arr1 = new int[2][2];

        int[][] arr2 = new int[2][];
        arr2[0] = new int[1];
        arr2[1] = new int[]{1,2,3};
        //可以为二维数组中包含的一维数组可以为不等长数组
        int[][] arr3 = new int[][]{{1,2,3},{4},{5,6}};

        //普通嵌套普通
        for(int i = 0;i<arr3.length;i++){
            for(int j =0;j<arr3[i].length;j++){
                System.out.print(arr3[i][j]+" ");
            }
        }
        System.out.println();

        //普通嵌套增强
        for(int i = 0;i<arr3.length;i++){
            for(int j : arr3[i]){
                System.out.print(j+" ");
            }
        }
        System.out.println();

        //增强嵌套普通
        for(int[] arri:arr3){
            for(int i=0;i<arri.length;i++){
                System.out.print(arri[i]+" ");
            }
        }
        System.out.println();

        //增强嵌套增强
        for(int[] arri:arr3){
            for(int i :arri){
                System.out.print(i+" ");
            }
        }
    }
}

Arrays类

import java.util.Arrays; //使用前需要导包

数组遍历

Arrays.toString(数组类型[ ] 数组名)

返回指定数组内容的字符串表示形式 //遍历数组,将数据中的内容以字符串形式固定格式返回

Arrays.deepToString(Object[ ] a)

返回指定数组的“深层内容”的字符串表示形式。 //可以遍历二维数组

数组比较

Arrays.equals(数组1,数组2)

如果两个指定的数组彼此包含的内容相等则返回 true

Arrays.deepEquals(数组1,数组2)

如果两个指定的数组彼此包含的深层内容相等则返回 true

数组拷贝

Arrays.copyOf(原数组名,新数组的长度)

返回一个新数组

//当新数组的长度 = 原数组长度->完全拷贝

//当新数组的长度 < 原数组长度->截取 默认从所有为0的位置开始

//当新数组的长度 > 原数组长度->填充 默认原数组中所有位置完全拷贝,空闲位置默认值填充

Arrays.copyOfRange(原数组名,起始下标,结束下标)

拷贝原数组执行区间范围内的数据,结束索引不包含,返回一个新数组

数组填充

Arrays.fill(数组名,填充值)

无返回值

使用指定的数据填充整个数组,数组中原有的值被覆盖

Arrays.fill(数组名,起始下标,结束下标,填充值)

无返回值

填充数组中指定范围,结束索引位置不包含

数组排序

Arrays.sort(数组名)

无返回值,将指定的数组按升序排序。

二分查找

Arrays.binarySearch(数组名,需要查找的值)

要求先升序排序

如果数据存在返回索引位置,不存在,返回插入点-1的值

内部类

类中定义类

当类中的成员也表示为一个事物的时候,可以定义为内部类

分类

​ 成员内部类
​ 静态内部类
​ 私有内部类
​ 局部内部类
​ 匿名内部类 ****
​ lambda表达式 *****

成员内部类

类定义在外部类的成员位置,就是成员内部类,是成员,就具有成员的特点,是类就具有类的特点,可以继承,实现…

注意:

​ 成员内部类中不能定义静态内容,除了静态的常量

​ 只有静态内部类才能定义静态内容

​ 成员内部类中可以使用外部类的成员,包括私有的

​ 外部类中可以通过内部类的对象使用内部类的成员包括私有的

​ 成员内部类的对象通过外部类对象构建

私有内部类

​ 被private关键字修饰的成员内部类

​ 不能定义静态内容,除了静态的常量

​ 私有内部类中可以直接使用外部类的成员,包括 私有的

​ 在外部类中通过私有内部类的对象使用其成员,包括私有的

​ 私有内部类智能在所在的外部类中使用

静态内部类

​ 静态内部类中可以定义非静态成员,可以定义静态成员

​ 静态内部类中可以使用外部类的成员,静态内容可以直接使用,成员内容需要通过外部类对象使用

​ 外部类中可以通过静态内部类类名使用其静态成员,需要通过静态内部类的对象使用内部类的成员

​ 其他类中使用静态内部类中的内容,需要根据外部类的类名找到静态内部类,根据静态内部类类名使用其静态内容,根据静态内部类对象使用其成员

局部内部类

​ 不能被public,private,等,static修饰,可以被final修饰

​ 局部内部类中可以定义成员内容,除了静态的常量,其他静态内容不可以定义

​ 局部内部类只能在所在的方法中使用,通过对象使用成员

​ 如果在局部内部类中使用了所在的方法中的局部变量(方法参数),这个变量要求被final修饰,在jdk1.8及之后,默认被final修饰

匿名内部类

匿名对象:是对象,没有引用指向这个对象

匿名内部类:没有名字的一个内部类

​ 作用:

​ 没有类本身作用,只为了重写的一些抽象方法,方便调用这个方法,匿名内部类就可以简化这种实现类

​ 简化符合需求的实现类,子类->接口|抽象父类