数组

数组的定义

存储同一种数据类型多个元素的容器

数组的定义格式

第一种格式（推荐）

int[] array
double[] array
char[] array
boolean[] array

第二种格式

int array[]
double array[]
char arra[]
boolean array[]

数组的动态初始化

初始化格式

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

int[] arr = new int[5];//数组长度arr.length

初始化特点

我们给定数组的长度, 初始化值由系统决定

初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

数组的静态初始化

初始化格式

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7} //完整版格式

int[] arr = {1, 2, 3, 4, 5, 6, 7}          //简化版格式

数组的两种初始化格式的区别

动态初始化：只给定数组长度，由系统分配默认初始化值

静态初始化：创建数组时，直接将元素确定

数组操作的两个常见问题

数组索引越界异常

public class ArrayException {
    public static void main(String[] args) {
        int[] arr = new int[3]; //索引 0 1 2
        System.out.println(arr[10]);
    }
}

出现原因：访问了不存在的数组索引

解决方案：改成正确的索引范围即可

数组空指针异常

public class ArrayException {
    public static void main(String[] args) {
        int[] arr = new int[3]; // 索引0 1 2
        System.out.println(arr[2]);
        // 空指针异常
        arr = null; // 空值
        System.out.println(arr[0]);
    }
}

出现原因：数组引用为null时，再去操作数组

解决方案：给数组一个真正的堆内存空间引用即可

数组元素访问

访问数组元素的格式

arr[0]  第1个元素
arr[1]  第2个元素
arr[2]  第3个元素
arr[3]  第4个元素
arr[4]  第5个元素
...     ...

索引


//索引是给每个元素起一个编号，通过编号可以获取指定元素

//索引从0开始,索引是连续的,索引逐一增加，每次加1,最大索引是数组长度（arr.length）-1

内存分配

栈内存：方法运行时，进入的内存，局部变量都存放于这块内存

堆内存： new出来的内容都会进入堆内存，并且会存在地址值

方法区：字节码文件(.class文件)加载时进入的内存

本地方法栈：调用操作系统相关资源

寄存器：交给CPU去使用

注意：每new一次，在堆内存中，都是一块新的空间，堆内存中的空间地址不会出现重复的现象

数组的实际应用

数组的遍历

遍历数组通用格式

int[] arr = {……};
for(int i=0; i<arr.length; i++) {
	arr[i]	 //对arr[i]进行操作
}

数组获取最大值和最小值

public class MaxArray {
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        // 1. 假设数组中的第一个元素为最大值
        int max = arr[0];
        // 2. 遍历数组, 获取每一个元素, 进行比较
        for(int i = 1; i < arr.length; i++){
        // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //  4. 循环结束后, 打印最大值.
        System.out.println("max:" + max);
    }
}       //获取最小值只需要把if判断中的>改为<即可

数组元素求和

public class SumArray {
    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] = sc.nextInt();
        }
        // 5.遍历数组，取出每一个元素，并求和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        // 6.输出总和
        System.out.println("sum:" + sum);
    }
}

数组基本查找

public class SearchArray {
    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);
    }
}

反转数组

public class ReversalArray {
    public static void main(String[] args) {
        //1. 定义数组
        int[] arr = {11, 33, 22, 55, 44};
        //2. 反转数组
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        //3. 打印数组.
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);;
        }
    }
}