博客

数组的用法示例如下：

package com.rgf.shuzu;

public class C {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5};
        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("=========================");
        //计算所有元素的和
        int sum=0;
        for (int i = 0; i < arrays.length; i++) {
            sum=sum+arrays[i];
        }
        System.out.println("和为"+sum);
        System.out.println("==========================");
        //查找最大元素
        int max=arrays[0];
        for (int i=1; i<arrays.length; i++){
            if (arrays[i]>max){
            max=arrays[i];
        }
       
    }
        System.out.println("最大值为"+max);
}
}

运行界面如下：

 2.增强for循环，for(数据类型 每个元素：数组名字)
 for (int array : arrays) {

代码示例如下：

package com.rgf.shuzu;

public class D {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5};
        //增强型for循环。JDK1.5，没有下标，适合打印输出，如果操作里面的元素的话，
        // 这种方法就没有那么适合了。
        //增强型for循环，for(数据类型 每个元素：数组名字)
        for (int array : arrays) {
            System.out.println(array);
        }
        }

}

运行界面如下: 

3.数组作方法入参：

打印数组元素代码示例如下：

package com.rgf.shuzu;

public class E {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        printArray(arrays);
    }

   // 打印数组元素,数组可以封装成这个函数的一个参数
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

运行界面如下：

 反转数组：

package com.rgf.shuzu;

public class E {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    // 打印数组元素,数组可以封装成这个函数的一个参数
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }

   // 数组作为返回值，即反转数组。
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];//为了达到反转的效果，
            // 需要传进来的数组从头开始将数据传给输出结果的从末尾开始接收。
        }
        return result;
    }
}

运行界面如下：

 多维数组：

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组：

定义方式：（1）数据类型[ ][ ] 数组名=new 数据类型[行的个数][列的个数];

                     (2)数据类型[ ][ ] 数组名=new 数据类型[行的个数][  ];

                    (3)数据类型[ ][ ] 数组名={第0行初始值}，{第1行初始值}，{第2行初始值}；

 int a[] [] =new int[2][5];

解析：二维数组a可以看成一个两行五列的数组。

二维数组初始化存储的是地址值，因为在栈里面存储的时候，而堆里面的为数组的存储，是把每个一维数组的首地址传递给二维数组，所以存储的是地址。

数组元素的默认初始化值：

针对于初始化方式一：比如： int[ ][ ] arr=new int[4][3];

外层元素的初始化值为：地址值

内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如： int[ ][ ] arr=new int[4][ ];

外层元素的初始化值为：null

内层元素的初始化值为：不能调用，否则报错

内存解析：

当我们在main方法里面调用结束之后，我们会进行出栈，这个时候堆里面的二维数组因为栈里面没有这个时候堆指向栈的指针就没有了，栈里面就没有指针指向二维数组了，这个时候二维数组的外层就要被回收了，同理，外层回收后，就没有指针执行内层了，二位数组的内层也要被回收了。

多维数组的代码如下所示：

package com.rgf.shuzu;

public class F {
    public static void main(String[] args) {
        int []array={1,2,3,4,5};
        int [][]array1=new int[3][5];
        int [][]array2={{1,2},{1,5,6},{4,5,6}};
        printArray(array2[1]);
        System.out.println(array2[1][0]);
        System.out.println(array2[1][1]);
        System.out.println(array2.length);//获取数组外面的长度
        System.out.println(array2[1].length);//获取数组每个里面的长度
        
        //for循环进行遍历输出二维数组。
        for (int i = 0; i < array2.length; i++) {//循环每行的数组
            for (int j = 0; j <array2[i].length; j++) {//循环每行的每列的数组
                System.out.println(array2[i][j]);
                
            }
            
        }

    }
    // 打印数组元素,数组可以封装成这个函数的一个参数
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }

}

运行界面如下所示：