初识数组。

数组的概述

1、数组：就是用于存储相同数据类型的数据的容器

2、使用数组的原因：

没有数组：存在多个变量，需要声明多个变量的名称，这些名称之间没有什么关系和规律。想访问所有的变量，就比较困难。

有了数组：只需要有一个数组容器的名称，容器里面有通过数字表示的位置。位置的数字又有规律的。可以通过容器名称结合位置数字的方式，访问到某个变量。

3、数组的定义：

元素的数据类型[] 数组名称 = new 元素的数据类型[数组容器的大小];

4、详细解释：

元素：数组中的数据、数组中的变量

元素的数据类型：数组中的数据的数据类型，用于决定每个空间的大小

[]：表示是一个一维数组

数组名称：数组本身也是一个变量，用于存储数组的地址的变量。

=：赋值符号，将数组的地址，赋值给数组的名称

new：用于在堆内存中开辟空间

元素的数据类型：和前面的元素的数据类型保持一致

数组容器的大小：可以存储数据的个数

5、打印的数组的结果解释：[I@15db9742

[：表示这是一个一维数组

I：表示数组中存储的是int类型的数据

@：普通的分隔符，没有具体的含义

15db9742：数组有一个内存地址，通过hashCode方法，将这个内存地址计算成了一个数字，用于表示这个内存地址，将这个数字转成十六进制的表示形式

说明：以后将打印结果，简称为数组的地址

数组的初始化

1、为数组分配内存空间，并且赋值

2、分类：动态初始化、静态初始化

3、动态初始化：程序运行过程中，才能知道究竟给元素赋什么值

格式：

元素的数据类型[] 数组名称 = new 元素的数据类型[数组元素的个数];

元素赋值的方式：

数组名称[元素的索引] = 元素值;

索引：

元素在数组中的位置的数字，别名：下标、角标、脚标；从0开始、数组的长度-1 结束

注意事项：

1、所有的元素，都需要逐个赋值

2、如果数组中的元素，没有赋值，元素也有一个默认的初始化值，整数为0

4、静态初始化：在程序书写的时候，就知道了数组中的元素是什么值

元素的数据类型[] 数组名称 = new 元素的数据类型[] {元素值的罗列};

注意事项：

1、在第二个方括号中，不要写数组元素的个数

2、元素值的罗列，元素和元素之间，使用逗号分隔。写了几个元素，就分配多大空间

3、罗列出来的元素值，数据类型必须和声明的数组元素的数据类型一致

4、静态初始化有一个简写格式：

元素的数据类型[] 数组名称 = {元素值的罗列};

数组名称的声明，数组名称的赋值，不能分成两行写。

数组的内存理解

1、jvm是执行java程序的容器，空间很大，需要划分不同的区域：不同的功能，需要使用不同特点的区域来

完成。

分为：栈内存、堆内存、方法区、

2、栈内存【常用】：用于执行方法，每个方法单独的分配一段空间，称为栈帧，把给方法分配内存空间，形 象的称为“进栈”。特点：先进后出

3、堆内存【常用】：用于存储数组、对象等数据量较大的数据。一般都是引用数据类型。

4、方法区【常用】：用于存储类的字节码对象，存储常量、存储静态变量

数组的异常

异常

1、在程序运行过程中，出现了和正常情况不符的条件，就没有必要让程序继续执行下去。将这个情况的错误信息封装成一个对象，就是异常对象。一旦有了异常对象，程序就会做一些跳转甚至结束。

2、数组操作的过程中，可能会发生的两个异常：

数组索引越界异常

空指针异常

数组索引越界异常

1、Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

异常 在 线程 主线程 数组 索引 超过 边界 异常

2、数组索引越界异常

原因：访问了数组中，不存在的索引。数组索引的范围是0~长度-1，超过了这个范围都是越界

避免：不要访问不存在的索引

代码：

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

空指针异常

1、Exception in thread "main" java.lang.NullPointerException

异常 在 线程 主 空 指针 异常

2、空指针异常：

空：null，在栈内存的引用中，不记录任何堆内存的地址

指针：C语言中的概念，表示的就是堆数据的内存地址。在java中，不能直接操作内存地址，将内存地址进行封装，形成了引用。“空指针异常”是其他语言继承过来的说法，是一个舶来品(进口过来的)。

原因：当引用不再指向任何的堆内存中的数据时，仍然要通过这个引用访问堆内存中的数据，只能抛出异常。

避免：在使用引用之前，可以先判断是否为null，不为null的时候再去访问

代码：

 public static void main(String[] args) {
        int[] arr = {7, 8, 9};
        System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
        arr = null;
        if (arr != null) {
            System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
        }
    }

数组的操作

数组的遍历

1、遍历：一个一个经历元素，所有元素都访问一遍

2、方式：

通过循环，访问到数组中所有元素的索引

通过索引，访问到对应元素

3、索引：

角标、下标、脚标，表示某个元素在数组中的位置

范围：0~数组长度-1

数组长度：数组名称.length，获取到数组元素的个数

数组练习

1. 求数组中最大值和最小值

   代码：

2. 数组的查找，给定一个数组，找到指定值的索引

   思路：

   遍历数组，判断每个元素是否与要找的元素值相等，如果相等，那么就返回当前元素的索引；如果没有找到，返回一个-1.

   代码：

public static void main(String[] args) {
        int[] arr = {23, 55, 12, 66, 11, 88};
     int index = -1;
        for (int i = 0; i < arr.length; i++) {
         if (arr[i] == 11) {
                index = i;
             break;
            }
     }
        System.out.println(index);
 }

Arrays类

Arrays：针对数组进行操作的工具类，比如说排序和查找

包名：import java.util.Arrays;

// equals(array1,array2) 的作用是：比较两个数组是否相等 类型相等 长度相等 元素相等
System.out.println("----equals(array1,array2)方法：----");
int[] arr1 = { 10, 50, 40, 30 };
int[] arr2 = { 10, 50, 40, 30 };
int[] arr3 = { 60, 50, 85 };
System.out.println(arr1 == arr2);// false 比较的是内存地址
System.out.println(arr1.equals(arr2));// false 比较的是内存地址 和 ==是一样的
System.out.println(Arrays.equals(arr1, arr2)); // 判断arr1与arr2的长度及元素是否相等
System.out.println(Arrays.equals(arr1, arr3)); // 判断arr1与arr3的长度及元素是否相等

// sort(array) 的作用是：对数组array的元素进行升序排列
System.out.println("----sort(array)方法：----");
int[] array = new int[] { 80, 66, 70, 54, 98 };
// String[] array = { "as", "df", "bt" };//字符串按照首字母 数字 排列
Arrays.sort(array);
System.out.println("成绩排序后：");
for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + "\t");
}

// toString(array) 的作用是：将一个数组array转换成一个字符串
System.out.println("----toString(array)方法：----");
int[] arr = { 10, 50, 40, 30 };
Arrays.sort(arr); // 将数组按升序排列
System.out.println(Arrays.toString(arr)); // 将数组arr转换为字符串并输出

// fill(array,val) 的作用是：把数组array的所有元素都赋值为val值
System.out.println("----fill(array,val)方法：----");
int[] arrs = { 10, 50, 40, 30 }; // 初始化整型数组
Arrays.fill(arrs, 40); // 替换数组元素
System.out.println(Arrays.toString(arrs)); // 将数组arr转换为字符串并输出

// copyOf(array,length) 的作用是：把数组array复制成一个长度为length的新数组
System.out.println("----copyOf(array,length)方法：----");
int[] arr11 = { 10, 50, 40, 30 };
int[] arr22 = Arrays.copyOf(arr11, 3); // 将arr11复制成长度为3的新数组arr22
System.out.println(Arrays.toString(arr22));

int[] arr33 = Arrays.copyOf(arr1, 4); // 将arr11复制成长度为4的新数组arr33
System.out.println(Arrays.toString(arr33));

int[] arr44 = Arrays.copyOf(arr1, 6); // 将arr11复制成长度为6的新数组arr44
System.out.println(Arrays.toString(arr44));

// binarySearch(array, val) 的作用是：查询元素值val在数组array中的下标
System.out.println("----binarySearch(array, val)方法：----");
int[] arrss = { 10, 50, 40, 30 };
Arrays.sort(arrss); // 先按升序排列
int index = Arrays.binarySearch(arrss, 30); // 查找30的下标
System.out.println(index);
index = Arrays.binarySearch(arrss, 50); // 查找50的下标
System.out.println(index);