数组

1 一维数组
2 二维数组

1 一维数组

1.1 数组的定义

容器：是将多个数据存储到一起，每个数据称为该容器的元素
数组：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致

第一种格式：

数据类型[] 数组名;
int[] arr;        
double[] arr;      
char[] arr;

第二种格式：

数据类型 数组名[];
int arr[];
double arr[];
char arr[];

1.2 数组的初始化

（1）动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

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

（2）静态初始化

在创建数组时，直接将元素确定，系统还会自动计算出该数组的长度

完整版格式

数据类型[] 数组名 = new 数据类型[]{
    
    元素1,元素2,元素3...};
int[] arr = new int[]{
    
    1,2,3,4,5};

简化版格式

数据类型[] 数组名 = {
    
    元素1,元素2,元素3...};
int[] arr = {
    
    1,2,3,4,5};

注意：

数组有定长特性，长度一旦指定，不可更改
在初始化的时候, 手动指定数组的长度, 系统会为数组容器分配默认初始值

在这里插入图片描述

1.3 数组的访问

索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的元素。

数组的长度属性：每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为 数组名.length-1 。

数组名[索引]

注意：
直接打印数组的名称，会输出数组的内存地址

例如：[I@10f87f48

@ : 分隔符
[ : 当前的空间是一个数组类型
I : 当前数组容器中所存储的数据类型
10f87f48 : 十六进制内存地址

1.4 内存分配

内存是计算机中的重要原件，临时存储区域，作用是运行程序。
我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

Java中的内存分配

在这里插入图片描述

（1）Java内存分配一个数组内存图

在这里插入图片描述
（2）Java内存分配两个数组内存图

在这里插入图片描述
（3）多个数组指向相同内存图

在这里插入图片描述
注意：
每new一次就会在堆中开辟出一片新的空间

1.5 数组的操作

（1）数组的遍历

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

    public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5};
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println(arr[i]);
        }
    }

（2）数组元素求和

需求：键盘录入5个整数，存储到数组中，并对数组求和

import java.util.Scanner;
public class Test{
    
    
    public static void main(String[] args) {
    
    
        // 1.创建键盘录入对象，准备键盘录入
        Scanner sc = new Scanner(System.in);
        // 2.定义一个求和变量，准备记录累加后的结果
        int sum = 0;
        // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
        int[] arr = new int[5];
        // 4.将键盘录入的数值存储到数组中
        for(int i = 0; i < arr.length; i++){
    
    
            System.out.println("请输入第" + (i+1) + "个整数:");
            //arr[i] = 10;
            arr[i] = sc.nextInt();
        }

        // 5.遍历数组，取出每一个元素，并求和
        for (int i = 0; i < arr.length; i++) {
    
    
            sum += arr[i];
        }

        // 6.输出总和
        System.out.println("sum:" + sum);

    }
}

（3）数组获取最大值元素

最大值获取：从数组的所有元素中找出最大值

实现思路：

定义变量，保存数组0索引上的元素
遍历数组，获取出数组中的每个元素
将遍历到的元素和保存数组0索引上值的变量进行比较
如果数组元素的值大于了变量的值，变量记录住新的值
数组循环遍历结束，变量保存的就是数组中的最大值

public static void main(String[] args) {
    
    
        int[] arr = {
    
    5, 15, 2000, 10000, 100, 4000};
        //定义变量，保存数组中0索引的元素
        int max = arr[0];
        // 遍历数组，取出每个元素
        for (int i = 0; i < arr.length; i++) {
    
    
            //遍历到的元素和变量max比较
            // 如果数组元素大于max
            if (arr[i] > max) {
    
    
                //max记录住大值
                max = arr[i];
            }
        }
        System.out.println("数组最大值是： " + max);
    }

（4）数组反转

数组的反转：数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
实现思想：数组最远端的元素互换位置。

实现反转，就需要将数组最远端元素位置交换
定义两个变量，保存数组的最小索引和最大索引
两个索引上的元素交换位置
最小索引++，最大索引–，再次交换位置
最小索引超过了最大索引，数组反转操作结束

public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5};
        /*循环中定义变量min=0最小索引 max=arr.length‐1最大索引 min++,max‐‐ */
        for (int min = 0, max = arr.length-1; min <= max; min++, max--) {
    
    
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println(arr[i]);
        }
    }

（5）数组的基本查找

需求：已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。

public static void main(String[] args) {
    
    
        // 1.定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {
    
    19, 28, 37, 46, 50};
        // 2.键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的元素:");
        int num = sc.nextInt();
        // 3.定义一个索引变量，初始值为-1
        // 假设要查找的数据, 在数组中就是不存在的
        int index = -1;
        // 4.遍历数组，获取到数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
    
    
            // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
            if(num == arr[i]){
    
    
                // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
                index = i;
                break;
            }
        }
        //  6.输出索引变量
        System.out.println(index);
    }
}

（6）评委打分

需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。

import java.util.Scanner;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];
        // 2.键盘录入评委分数
        Scanner sc = new Scanner(System.in);
        //  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println("请输入第" + (i+1) + "个评委的打分:");
            int score = sc.nextInt();
            if(score >= 0 && score <= 100){
    
    
                // 合法的分值
                arr[i] = score;
            }else{
    
    
                // 非法的分值
                System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
                i--;
            }
        }

        // 4.求出数组最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
    
    
            if(max < arr[i]){
    
    
                max = arr[i];
            }
        }

        // 5.求出数组最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
    
    
            if(min > arr[i]){
    
    
                min = arr[i];
            }
        }

        // 6.求出数组总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
    
    
            sum += arr[i];
        }

        // 7.按照计算规则进行计算得到平均分
        int avg = (sum - max - min ) / 4;

        // 8.输出平均分
        System.out.println(avg);
    }
}

1.6 数组在方法的应用

（1）数组作为方法参数
数组作为方法参数传递，传递的参数是数组内存的地址

public static void main(String[] args) {
    
    
        int[] arr = {
    
     1, 3, 5, 7, 9 };
        printArray(arr);
    }

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

注意：
方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值

（2）数组作为方法返回值
数组作为方法的返回值，返回的是数组的内存地址

public static void main(String[] args) {
    
    
        int[] arr = getArray();
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println(arr[i]);
        }
    }
public static int[] getArray() {
    
    
        int[] arr = {
    
    1, 3, 5, 7, 9};
        //返回数组的地址，返回到调用者
        return arr;
    }

2 二维数组

2.1 数组的定义

二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

第一种格式

数据类型[][] 变量名;
int[][] arr;

第二种格式

数据类型 变量名[][];
int arr[][];

第三种格式

数据类型[] 变量名[];
int[] arr[];

2.2 数组的初始化

（1）动态初始化

数据类型[][] 变量名 = new 数据类型[m][n];
// m表示这个二维数据可以存放多少个一维数组
// n表示每一个一维数组可以存放多少个元素

int[][] arr = new int[2][3];

[[I@10f87f48

@ : 分隔符
10f87f48 : 十六进制内存地址
I : 数组中存储的数据类型
[[ : 几个中括号就代表的是几维数组

注意：
二维数组存储一维数组的时候, 存储的是一维数组的内存地址

问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
答 : 可以的

public static void main(String[] args) {
    
    
    int[] arr1 = {
    
    11,22,33};
    int[] arr2 = {
    
    44,55,66};
    int[] arr3 = {
    
    77,88,99,100};

    int[][] arr = new int[3][3];

    // arr[2][3] = 100; 索引越界，会报错！

    arr[0] = arr1;
    arr[1] = arr2;
    arr[2] = arr3;

    System.out.println(arr[1][2]); // 66
    System.out.println(arr[2][3]); // 100 索引好像是“越界”，不会报错！
}

在这里插入图片描述
这种动态初始化在创建时就会把这三个一维数组创建好，并且里面的索引也是固定的，用arr[0][0]去访问一个不存在的索引必然会报错。

提前创建一维数组再往里面赋值的方式，只是做了内存地址的替换，跟原来一维数组的长度已经没有关系了。