java数组，数组作为方法入参，二维数组

数组

数组的定义

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问

数组的声明和创建

• 首先必须声明数组变量，语法：

dataType[] arrayRefVar;//声明一个数组，首选的方法
int[] ids;

• Java语言使用new操作符来创建一个数组，语法：

dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = new dataType[]{数组元素1，数组元素2，...};
dataType[] arrayRefVar = {数组元素1，数组元素2，...};
数组类型[] 数组名 = new 数组类型[数组长度];
数组类型[] 数组名 = new 数组类型[]{数组元素0，数组元素1，...};
数组类型[] 数组名 = {数组元素0，数组元素1，...};

• 数组的元素都是通过索引访问的，数组索引从0开始
• 获取数组的长度

arrays.length

初始化

• 静态初始化

int[] a = {1,2,3};

• 动态初始化

int[] a = new int[2];
a[0] = 1;
a[2] = 2;

数组的四个基本特点

• 长度是确定的。数组一旦被创建，它的大小是不可以改变的
• 元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
• 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组边界

• 下标合法区间：[0~length-1],如果越界就会报错

public static void main(String[] args){
    int[] a = new int[2]
        System.out.println(a[2]);//下标越界
}

• ArrayIndexOutOfBoundsException：数组下标越界异常

数组的常见操作

• 数组遍历
• 数组最值
• 数组求和

package com.sgl;

public class Demo06 {
    public static void main(String[] args) {

        int[] arrays = {45,23,98,52,4,56,21};

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

        //数组最值
        int max = arrays[0];
        for (int i =0; i < arrays.length; i++){
            if (arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println("max="+ max);
        System.out.println("===========================");

        //数组元素求和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++){
            sum = sum + arrays[i];
        }
        System.out.println("sum="+ sum);
        System.out.println("===========================");
        
        //没有下标
        for (int array: arrays){
            System.out.println("array:"+array);
        }
        
        
    }
}

数组作为方法入参

package com.sgl;

import java.util.DoubleSummaryStatistics;

public class Demo06 {
    public static void main(String[] args) {
        int[] arrays = {45,23,98,52,4,56,21};
        System.out.println(arrays.length);//arrays.length为7

        printArray(arrays);//调用printArray方法
        
        int[] reverse = reverse(arrays);//调用reverse方法
        printArray(reverse);

    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];//定义一个数组，长度等于arrat.length

        //反转操作
        for (int i = 0,j = result.length-1; i < arrays.length; i++,j--){
            result[j] = arrays[i];
        }
        return result;
    }

    //打印数组元素
    public static void printArray (int[] arrays){
        for (int i = 0; i < arrays.length; i++){
            System.out.print(arrays[i]+" ");
        }
    }
}

二维数组

• 数组的定义

数据类型[][] 数组名 =  new 数据类型[][];
int[][] arrays = nwe int[4][2];//四行两列
/*[4][2]
1,2  arrays[0]
2,3  arrays[1]
3,4  arrays[2]
4,5  arrays[3]
*/

例子：

package com.sgl;

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

        System.out.println(array.length);  //4
        System.out.println(array[0].length);   //2
        System.out.println("=================================");

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

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");

            }
        }

    }

        public static void printArray (int[][] array) {
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[i].length; j++) {
                    System.out.print(array[i][j] + " ");
                }
            }
        }

    }