JAVA 数组|二维数组

变量 : 存储单个数据

数组 ：存储多个数据

一，数组

1.定义：

在内存中是一段连续的内存空间,线性序列

相同数据类型数据的有序集合

2. 特点 :

1. 1.引用数据类型 []

基本数据类型的数据为对应类型数据值 100 false 'a'

引用数据类型的数据为对象数据 new

2. 定长,长度一旦确定不可改变

3. 存储的多个数据要求类型相同

4. 有序的,索引,根据根据索引区分数组中的每一个空间

3.索引 :

是数组连续内存空间中每一个空间得到唯一标识

根据索引操作数组中的数据 数组名[索引]

索引从0开始每次+1

最后一个空间的索引为 : 数组名.length-1

4.长度 : 数组名.length

5.数组的定义 :

5.1数组的声明 :

数据类型 变量名; -->变量的声明

数组的声明 :

数据类型[] 数组名; --> 推荐

数据类型 数组名[];

数据类型 []数组名;

//声明
        int[] arr1;
        char arr2[];
        boolean []arr3;

5.2 初始化 :

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

数据类型[] 数组名 = new 数据类型[长度];

数据类型 : 可以为任意数据类型(基本|引用)

长度 : 整数 0~n

 //动态初始化
        arr1 = new int[3];

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

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

数据类型[] 数组名 = {数据1,数据2,数据3....};

 //静态初始化
        arr2 = new char[]{'a','b','c','d'};
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);

5.3 默认值 : 数组创建没有赋值,存在默认值

整数 : 0

小数 : 0.0

布尔 : false

字符 : 空字符

6.数组的遍历

for --> 在任意位置迭代

通过for的条件i控制数组的索引变化,在循环体中根据索引操作数组中的数据

foreach ---> 只能正向迭代

for(数据类型 变量名:数组名|集合名){

根据变量名是使用数组中的每一个数据

}

二，二维数组 :

数组中存放数组

1.声明 :

数据类型[][] 数组名; -->推荐

2.初始化 :

2.1 动态初始化 :

创建数组同时不确定不确定数据

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

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

数组名[二维数组的索引] = new 一维数组[长度];

数组名[二维数组的索引] = new 一维数组[]{数据值....};

 //动态初始化
        double[][] arr1 = new double[2][3];
        String[][] arr2 = new String[2][];
        arr2[0] = new String[]{"aaa","bbb","ccc"};
        arr2[1] = new String[2];
        arr2[1][0] = "中国";
        arr2[1][1] = "北京";

2.2静态初始化 :

创建数组的同时赋值,根据数据的个数决定数组的长度

数据类型[][] 数组名 = new 数据类型[][]{{值列表},{值列表},....};

数据类型[][] 数组名 = {{值列表},{值列表},....};

     //静态初始化
        //char[][] arr3 = new char[][]{{'a','b','c'},{'d','e'}, {'f'}};
        char[][] arr3 = {{'a','b','c'},{'d','e'}, {'f'}};
        System.out.println(arr3[0][0]);
        System.out.println(arr3[0][1]);
        System.out.println(arr3[0][2]);
        System.out.println(arr3[1][0]);
        System.out.println(arr3[1][1]);
        System.out.println(arr3[2][0]);

3.操作数组中的数据 :

数组名[外层二维数组索引][内层一维数组索引]

//获取数据
        System.out.println(arr1[0][0]);
        System.out.println(arr1[0][1]);
        System.out.println(arr1[0][2]);
        System.out.println(arr1[1][0]);
        System.out.println(arr1[1][1]);
        System.out.println(arr1[1][2]);

4.遍历 :

双重循环嵌套

for-->foreach

for-->for

foreach-->foreach

foreach-->for

    //数组的遍历
        System.out.println();
        System.out.println("===========for for==========");
        //for  for
        for (int i = 0; i < arrs4.length; i++) {
            for (int j = 0; j < arrs4[i].length; j++) {
                System.out.print(arrs4[i][j]);
            }
        }
        System.out.println();
        System.out.println("=========for foreach========");

        //for foreach
        for (int i = 0; i < arrs4.length; i++) {
            for (int num:arrs4[i]) {
                System.out.print(num);
            }
        }

        System.out.println();
        System.out.println("======foreach foreach=======");
        for(int[] nums:arrs4){
            for(int num:nums){
                System.out.print(num);
            }
        }

        System.out.println();
        System.out.println("========foreach for==========");
        for (int[] nums:arrs4){
            for (int i = 0; i < nums.length; i++) {
                System.out.print(nums[i]);
            }
        }

5.Arrays : 该类包含用于操作数组的各种方法（例如排序和搜索）。

静态工厂,所有的功能直接通过类名.调用

注意 :

==比较基本数据类型,比较的是数据值

==比较引用数据类型,比较的是对象的地址值