[ java基础 ] 数组: 开发工具.数组内存划分.可变参数

IntelliJ IDEA

IDEA层次结构

idea的快捷模版和快捷键

• 快捷模版:
  变量输出语句 soutv
  正序循环 循环次数.fori
  倒序循环 循环次数.forr
• 快捷键:
  单行注释 Ctrl + /
  取消单行注释 Ctrl + /
  多行注释 Ctrl + Shift + /
  取消多行注释 Ctrl + Shift + /
  格式化 Ctrl + Alt + L
  抽取方法 Ctrl + Alt + M
  代码提示 Alt + /
  万能键 Alt + Enter

数组

数组特点

1.在程序中数组一旦初始化,大小(长度)是不可以改变
2.数组存储的元素在内存中必须是同一种数据类型
3.数组中存储的元素需是多个(可创建长度为0或者1的数组,但无意义)

数组的声明

• 数据类型[] 数组名(推荐)
  例如: int[] arr
  描述: 声明一个存储int类型元素的数组,数组名为arr
• 数据类型 数组名[]
  例如: int arr[]
  描述: 声明一个int类型变量,变量名为arr[]

数组初始化

• 动态初始化:
  只初始化数组的长度,不初始化数组中的具体数据
• 静态初始化
  不初始化数组的长度,初始化数组中具体的数据,JVM会通过元素的具体个数间接获取数组的长度

new:向内存申请区域,用来存储数组数据
数据类型:数组中元素的数据类型
数组长度:数组的大小

数组初始化的注意事项

1. 在进行数组声明初始化的时候,不允许动静结合的方式

2. 数组存储的元素在内存中必须是同一种数据类型

3. 静态初始化的简化格式不允许先声明,后初始化

原因:变量的初始化是取决于前面的数据类型,静态初始化简化格式直接定义初始化,数组的元素是直接根据接收变量的数据类型开辟内存空间,静态初始化简化格式先声明,后初始化,数组无法直接获取数组的数据类型,在内存中无法给其开辟内存空间,导致编译报错

int[] arr08;

arr08 = {11,22,33};//wrong

初始化代码:

public class ArrayDemo01 {
    public static void main(String[] args) {
        //动态初始化: 数据类型[] 数组名 = new 数据类型[数组长度];
        int[] arr01 = new int[3];
        //静态初始化1:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,......,元素n};
        int[] arr02 = new int[]{11,22,33};
        //静态初始化2:数据类型[] 数组名 = {元素1,元素2,......,元素n};
        int[] arr03 = {11,22,33};
        //在进行数组声明初始化的时候,不允许动静结合的方式
        //int[] arr04 = new int[3]{11,22,33};错误
        int[] arr05 = {11,22,33,'a'};
        //动态初始化:先声明,后初始化
        int[] arr06;
        arr06 = new int[3];
        //静态初始化标准格式:先声明,后初始化
        int[] arr07;
        arr07 = new int[] {11,22,33};
        //静态初始化简化格式:先声明,后初始化
        int[] arr08;
        //arr08 = {11,22,33};
    }
}

数组元素和数组的地址编码

获取数组中元素的方式
索引值:针对数组中元素的自动编号,编号从0开始,依次累加
格式:
数组名[索引值]

 System.out.println(arr);//[I@1b6d3586 人工模拟的地址编码(不是内存真正意义上的内存地址值)

动态获取数组长度

数组名.length

public class ArrayDemo03 {
    public static void main(String[] args) {
        //声明初始化数组
        int[] arr = {11,22,33};

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("==================================");

        for (int i = 0 ; i < 3 ; i++) {
            System.out.println(arr[i]);
        }

        System.out.println("==================================");

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

内存中的数组

JVM内存划分

ps:堆内存中的默认值

​ 除四类八种基本数据类型,其他都是引用数据类型

• 动态初始化内存图解

• 静态初始化内存图解

• 两个数组指向同一地址值的内存图解

• 数组长度不可改变的内存图解

数组的注意事项

1.ArrayIndexOutOfBoundsException:数组索引越界异常
产生原因:访问了不存在的索引或者错误索引
2.NullPointerException:空指针异常
产生原因:通过null访问数组中的索引(或者访问对象的成员)

null是字面值常量,是引用数据类型的默认值

public class ArrayDemo08 {
    public static void main(String[] args) {
        int[] arr = {11,22,33};

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //System.out.println(arr[3]);

        arr = null;//null是字面值常量,是引用数据类型的默认值
        System.out.println(arr);
        System.out.println(arr[0]);
    }
}

方法形参和实参的特点

• 当方法形参是基本数据类型时,形参数据值的改变不影响实际参数

​ 特点:参数的传递,传递的是数据值

• 当方法形参是引用数据类型时,形参地址值的改变不影响实际参数,但当形参地址值不改变时,形参地址值中数据值的改变影响实际参数地址值中的数据值

  ​ 特点:参数的传递,传递的是地址值

public class ArrayDemo09 {
    public static void main(String[] args) {
        /*int a = 10;
        int b = 20;
        System.out.println("a1 = " + a);
        System.out.println("b1 = " + b);
        System.out.println("================================");
        method(a,b);
        System.out.println("================================");
        System.out.println("a4 = " + a);//10
        System.out.println("b4 = " + b);//20  打印main()的变量a,变量b*/

        /*int[] arr = new int[3];
        System.out.println("arr1 = " + arr);
        System.out.println("================================");
        show(arr);
        System.out.println("================================");
        System.out.println("arr4 = " + arr);*/

        int[] arr = {11,22,33};
        System.out.println("arr1 = " + arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        change(arr);
        System.out.println("arr4 = " + arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }

    public static void change (int[] arr) {
        System.out.println("arr2 = " + arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        arr[0] = 100;
        arr[2] = 300;

        System.out.println("arr3 = " + arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }

    public static void show (int[] arr) {
        System.out.println("arr2 = " + arr);
        System.out.println("================================");
        arr = new int[5];
        System.out.println("arr3 = " + arr);
    }

    public static void method (int a, int b) { //method()的变量a,变量b
        System.out.println("a2 = " + a);
        System.out.println("b2 = " + b);
        System.out.println("================================");
        a = b;
        b += a;
        System.out.println("a3 = " + a);
        System.out.println("b3 = " + b);
    }
}

可变参数

• 可变参数:在调用方法时,可以接收同一种数据类型任意个数的实参(0个实参可以,多个实参也可以)
• 位置:
• 方法声明的形参列表中
• 格式:修饰符 返回值类型 方法名 (数据类型… 数组名) {}
• 特点:通过传递实参的个数,以静态初始化的方式创建数组
• 注意事项:
  • 当方法的形参列表中除了可变参数外,还存在其他参数,需要将可变参数写在最后面
  • 一个方法最多只能含有一个可变参数

public class ArrayDemo10 {
    public static void main(String[] args) {
        int[] arr01 = {11,22,33};
        print(arr01);
        System.out.println("==============");
        int[] arr02 = {11,22,33,44,55};
        print(arr02);
        System.out.println("==============");
        print(11,22,33,44);
        System.out.println("==============");
        show(11,22,33,44,55,66,77);

    }

    public static void show (double num, int... arr) {

    }

    public static void method (int... arr) {
        System.out.println(arr);
        System.out.println(arr.length);
    }

    public static void print (int... arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}