大数据进阶07、08-一维二维数组、Java中的内存分配

本文主要是介绍大数据进阶07、08-一维二维数组、Java中的内存分配，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

	这一部分讲到了Java中的数组以及内存分配

1. 数组：
   1、数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
   2、数组既可以存储基本数据类型，也可以存储引用数据类型。

   语句定义格式：
       1、数据类型[] 数组名
           举例：int[] arr1  推荐使用第一种定义方式
       2、数据类型 数组名[]
           举例：long arr2[]
       注意事项：
          针对数组定义两种格式，推荐使用第一种格式。因为第一种的可读性更强。
          第二种可以早期的时候确实有很多人这样用。不过，现在这样用的人越来越少了。
   
   如果只是单纯地定义了数组是没有任何意义的，因为里面没有值，想要使用它，必须先初始化。
   那么如何初始化呢？
   Java中的数组必须先初始化,然后才能使用。
   初始化：
           所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
   数组初始化：
       1、动态初始化：初始化时只指定数组长度，由系统自动为数组分配初始值。
           先不赋值
       2、静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
           先赋值
   

   动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
   动态初始化的格式：数据类型[] 数组名 = new 数据类型[数组长度];
   举例：int[] arr = new int[3];
   解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

2. Java中内存地址的分配
   
   举例：
   定义一个数组，并为其赋初值

public static void main(String[] args) {
            //定义一个数组
        int []arr = new int[3];
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        //为数组赋初值
        arr[0] = 100;
        arr[1] = 200;
        //输出数组名
        System.out.println(arr);
        //输出元素值
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}
//[I@28d93b30
//0
//0
//[I@28d93b30
//100
//200
//0

举例：
定义两个数组，分别动态初始化后，手动赋值，并打印数组名和个元素值

public static void main(String[] args) {
        //定义第一个数组
        int []arr = new int [3];
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //定义第二个数组
        int []arr1 = new int [2];
        arr1[0] = 44;
        arr1[1] = 55;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
    }
}
//[I@28d93b30
//11
//22
//33
//44
//55

图解：

举例
定义第一个数组，动态初始化，并手动赋值，并打印数组名词以及各元素值
定义第二个数组，动态初始化，并手动赋值，并打印数组名词以及各元素值
定义第三个数组，将第一个数组的地址值赋给第三个数组。（注意：数组的数据类型要一致）
并手动赋值，并打印数组名词以及各元素值

    public static void main(String[] args) {
        //定义第一个数组
        int[] arr1 = new int[3];
        arr1[0] = 11;
        arr1[1] = 22;
        arr1[2] = 33;
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        //定义第二个数组
        int[] arr2 = new int[3];
        arr2[0] = 44;
        arr2[1] = 55;
        arr2[2] = 66;
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        //这是第三个数组
        int[] arr3 = arr1;
        arr3[0] = 77;
        arr3[1] = 88;
        System.out.println(arr3); //打印的是arr1的地址值
        System.out.println(arr1[0]); //77
        System.out.println(arr1[1]); //88
        System.out.println(arr1[2]); //33
    }
}
//[I@28d93b30
//11
//22
//33
//[I@1b6d3586
//44
//55
//66
//[I@28d93b30
//77
//88
//33

3. 数组的静态初始化
   数组的静态初始化：
   格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
   简化格式：数据类型[] 数组名 = {元素1,元素2,…}

   举例：
       int[] arr = new int[]{1,2,3,4,5};
   
       简化格式的举例：
               int[] arr1 = {6,7,8,9,10};
   
   注意事项：
       1、不能同时使用动态初始化和静态初始化
           举例：
               int[] arr2 = new int[3]{1,2,3}; //错误
   

4. 数组使用常见的异常
   （1）数组索引越界
   ArrayIndexOutOfBoundsException
   访问到了数组中的不存在的索引时发生。
   （2）空指针异常
   NullPointerException
   数组引用没有指向实体，却在操作实体中的元素时。

   遇到Java程序报错，首先看第一个报错
   

举例：

    public static void main(String[] args) {
        int[] arr = {1,2,3,40};

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

        arr = null;
        System.out.println(arr);
//        System.out.println(arr[0]);
    }
}
//1
//2
//3
//40
//null

5.二维数组
二维数组：
就是元素是一维数组的数组
1、格式1：
数据类型[][] 变量名 = new 数据类型[m][n];

        m:表示这个二维数组有多少个元素，其中这个元素是一维数组
        n:表示每个一维数组的元素有多少个
    注意：
        一下格式也可以表示一个二维数组
        a:数据类型 数组名称[][] = new 数据类型[m][n];
        b:数据类型[] 数组名称[] = new 数据类型[m][n];

    举例：
        int x;
        int y;
        int x,y;

        int[] x;

        int[][] x;
        int[] x[];
        int x[][];

举例：

        //定义一个二维数组
        int[][] arr = new int[3][2];
        //定义了一个二维数组arr
        //这里的3代表是有3个一维数组
        //这里的2代表每个一维数组有2个元素
        //输出二维数组的名称
        System.out.println(arr);    //输出的是二维数组在堆内存对应的地址值
        System.out.println(arr[0]); //输出的是第一个一维数组在堆内存对应的地址值
        System.out.println(arr[1]); //输出的是第二个一维数组在堆内存对应的地址值
        System.out.println(arr[2]); //输出的是第三个一维数组在堆内存对应的地址值
        //输出二维数组对应的某几个元素
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
//        System.out.println(arr[0][3]);
        }
        }

[[I@28d93b30
[I@1b6d3586
[I@4554617c
[I@74a14482
0
0

2、格式二：
数据类型[][] 变量名 = new 数据类型[m][]
举例：
int [][] arr = new int[3][];
举例：

int[][] arr = new int[3][];
        System.out.println(arr);  //二维数组的地址值 [[I@4554617c
        System.out.println(arr[0]); //第一个元素的一维数组的地址值  null
        System.out.println(arr[1]); //第二个元素的一维数组的地址值  null
        System.out.println(arr[2]); //第三个元素的一维数组的地址值  null

        //动态地为每一个一维数组分配空间
        arr[0] = new int[2];
        arr[1] = new int[3];
        arr[2] = new int[1];

        System.out.println(arr[0]); //第一个元素的一维数组的地址值 //[I@74a14482
        System.out.println(arr[1]); //第二个元素的一维数组的地址值 //[I@1540e19d
        System.out.println(arr[2]); //第三个元素的一维数组的地址值 //[I@677327b6

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

[[I@28d93b30
null
null
null
[I@1b6d3586
[I@4554617c
[I@74a14482
0
0

二维数组内存图-图解：（注意null是在堆中开辟了空间之后没有存入数据，所以是null的，注意这即可。）

3、二维数组定义格式三：
手动赋值（类似于一维数组静态初始化）
格式：数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
举例：
int[][] arr = new int[][]{{1,2},{3,4,5},{6,7,8}}
注意：
不能和格式1，2混合使用
错误格式：
int[][] arr = new int[3][2]{{1,2},{3,4},{6,7}} //错误

举例：

public static void main(String[] args) {
        int[][] arr = new int[][]{{1,2},{3,4,5},{6,7,8}};

        System.out.println(arr); //二维数组的地址值
        System.out.println(arr[0]); //二维数组的第一个元素，一维数组的地址值
        System.out.println(arr[1]); //二维数组的第二个元素，一维数组的地址值
        System.out.println(arr[2]); //二维数组的第三个元素，一维数组的地址值

        System.out.println(arr[0][0]); //打印的是第1个一维数组的第1个元素值
        System.out.println(arr[0][1]); //打印的是第1个一维数组的第2个元素值

        System.out.println(arr[1][0]); //打印的是第2个一维数组的第1个元素值
        System.out.println(arr[1][1]); //打印的是第2个一维数组的第2个元素值
        System.out.println(arr[1][2]); //打印的是第2个一维数组的第3个元素值

        System.out.println(arr[2][0]); //打印的是第3个一维数组的第1个元素值
        System.out.println(arr[2][1]); //打印的是第3个一维数组的第2个元素值
        System.out.println(arr[2][2]); //打印的是第3个一维数组的第3个元素值
    }
}
//[[I@28d93b30
//[I@1b6d3586
//[I@4554617c
//[I@74a14482
//1
//2
//3
//4
//5
//6
//7
//8

举例：

public class Array2Demo14 {
    public static void main(String[] args) {
        int [][] arr = new int [][]{{1,2},{3,4,5},{6,7,8}};
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.println("当前是二维数组的第"+(i+1)+"个一" +
                        "维数组中的第"+(j+1)+"个元素值，元素值是："+arr[i][j]);
            }
        }
    }
}
//当前是二维数组的第1个一维数组中的第1个元素值，元素值是：1
//当前是二维数组的第1个一维数组中的第2个元素值，元素值是：2
//当前是二维数组的第2个一维数组中的第1个元素值，元素值是：3
//当前是二维数组的第2个一维数组中的第2个元素值，元素值是：4
//当前是二维数组的第2个一维数组中的第3个元素值，元素值是：5
//当前是二维数组的第3个一维数组中的第1个元素值，元素值是：6
//当前是二维数组的第3个一维数组中的第2个元素值，元素值是：7
//当前是二维数组的第3个一维数组中的第3个元素值，元素值是：8

感谢阅读，我是啊帅和和，一位大数据专业即将大四学生，祝你快乐。

这篇关于大数据进阶07、08-一维二维数组、Java中的内存分配的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！