day07_数组初识

数组的概述

数组就是用于存储数据的长度固定的容器，保证多个数据的数据类型要一致。
数组适合做一批同种类型数据的存储
数组是属于引用数据类型，数组变量名中存储的数组在内存中的地址信息。
数组中的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用数据类型是，我们称为对象数组。

容器：是将多个数据存储到一起，每个数据称为该容器的元素。 生活中的容器：水杯，衣柜，教室..

百度百科中对数组的定义：

所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名
统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。
组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。

数组的特点：

数组一旦定义出来，程序执行的过程中，长度、类型就固定了
创建数组时会在内存中开辟一整块连续的空间
存取元素的速度快，因为可以通过[下标]，直接定位到任意一个元素
“数据类型[ ] 数组名” 也可以写成 “数据类型数组名[ ] ”。

一维数组的声明与初始化

代码示例

       //  定义一个存储int类型数组的变量arrayAint[] arrayA;//System.out.println(arrayA);错误的: arrayA只是一个用来存储数组的变量,但是目前没有向arrayA中存储数组//  定义一个存储double类型数组的变量arrayBdouble arrayB[];//System.out.println(arrayB);错误的: arrayB只是一个用来存储数组的变量,但是目前没有向arrayA中存储数组

当我们声明一个变量，而没有给其初始化的时候，是无法使用的。数组同样如此，下面我们就来学习一下数组的初始化方式

方式一：数组动态初始化

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

格式：

数组定义格式详解：

数组存储的元素的数据类型： 创建的数组容器可以存储什么数据类型的数据。元素的类型可以是任意的Java的数据类型。例如：int, String, Student等
[ ] : 表示数组。
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
=：表示赋值，把具体的=右边new出来的数组容器，存储到=左边的数组变量中，但是存储的是数组在内存空间的地址值
new：关键字，创建数组使用的关键字。因为数组本身是引用数据类型，所以要用new创建数组对象。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。

定义可以存储5个整数的数组容器，代码如下：

//方式一
int[] arr = new int[5];
//方式二
int[] arr;
arr = new int[5]

方式二： 数组静态初始化

静态初始化就是在创建数组时，直接确定数组元素

标准格式：

定义存储1，2，3，4，5整数的数组容器，代码如下

//方式一
int[] arr = new int[]{1,2,3,4,5};//正确//方式二
int[] arr;
arr = new int[]{1,2,3,4,5};//正确//int[] arr = new int[5]{1,2,3,4,5};错误的，后面有{}指定元素列表，就不需要在[长度]指定长度。

简化格式：

定义存储1，2，3，4，5整数的数组容器,代码如下

int[] arr = {1,2,3,4,5};//正确int[] arr;
//arr = {1,2,3,4,5};错误

两种初始化的的使用场景总结、注意事项说明：

动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。

数组的几个注意事项：

数据类型[ ] 数组名也可以写成数据类型数组名[ ]
什么类型的数组存放什么类型的数据，否则报错
数组一旦定义出来，程序执行的过程中，长度、类型就固定了。和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。
动态初始化和静态初始化两种格式的写法是独立的，不可以混用

   public static void main(String[] args) {// 1、数据类型[] 数组名称 也可以写成 数据类型 数组名称[]int[] ages1 = {11, 23, 45};int ages2[] = {11, 23, 45};// 2、什么类型的数组只能存放什么类型的元素// String[] names = {"西门吹雪", "独孤求败", 23}; // 错误的// 3、数组一旦定义出来之后，类型和长度就固定了int[] ages2 = {11, 23, 45};System.out.println(ages2[3]); // 报错！ 长度固定是3了不能访问第4个元素！！// 两种格式的写法是独立的，不可以混用// int[] arrs = new int[3]{30，40,50}; 错误}

一维数组

直接打印数组名称，输出的是一个十六进制的整数数字，代表数组在内存空间的地址值。我们要访问数组中的元素就必须用到index

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

数组的最大索引：数组名. length – 1，前提：元素个数大于0
索引范围：[0, 数组的长度-1]。
格式：数组名[索引]

索引访问数组中的元素：

数组名[索引] = 数值：为数组中的元素赋值
变量 = 数组名[索引]：获取出数组中的元素

代码示例

public class Demo04Array {public static void main(String[] args) {//定义存储int类型数组，赋值元素1，2，3，4，5int[] arr = {1, 2, 3, 4, 5};//为0索引元素赋值为6arr[0] = 6;//获取数组0索引上的元素int i = arr[0];System.out.println(i);//6//直接输出数组0索引元素System.out.println(arr[0]);//6}
}

数组的遍历

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

数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。简而言之：遍历就是就是对数组中元素的一个一个数据的访问。

public class Demo05Array {public static void main(String[] args) {int[] arr = new int[]{1, 2, 3, 4, 5};//打印数组的属性，输出结果是5System.out.println("数组的长度：" + arr.length);//遍历输出数组中的元素System.out.println("数组的元素有：");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}

数组元素的默认值

当我们使用动态初始化创建数组时，此时只确定了数组的长度，那么数组的元素是什么值呢？数组的元素有默认值，如下图所示

总结：

byte、short、int 、char、long类型数组元素的默认值都是0
float、double类型数组元素的默认值都是0.0
boolean类型数组元素的默认值是false、String类型数组元素的默认值是null

一维数组内存图

内存概述

内存是计算机中重要的部件之一，它是与CPU进行沟通的桥梁。其作用是用于暂时存放CPU中的运算数据，以及与硬盘等外部存储器交换的数据。只要计算机在运行中，CPU就会把需要运算的数据调到内存中进行运算，当运算完成后CPU再将结果传送出来。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

Java虚拟机的内存划分

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

详解

一个数组内存图

结论：

数组名称保存数组在堆内存中的地址值
通过数组名称找到堆内存中的具体数组,然后通过索引编号找到对应的具体的某个元素

二个数组内存图

结论：

数组名称保存数组在堆内存中的地址值
通过数组名称找到堆内存中的具体数组,然后通过索引编号找到对应的具体的某个元素
每个数组都有自己独立的内存空间,互不影响,互不干扰

两个变量指向一个数组

结论：

数组名称保存数组在堆内存中的地址值
通过数组名称找到堆内存中的具体数组,然后通过索引编号找到对应的具体的某个元素
使用数组名进行赋值时,传递的是数组的内存地址值。

一维数组操作的两个常见问题

索引越界异常

观察一下代码，运行后会出现什么结果

public class Demo01ArrayTest {public static void main(String[] args) {int[] arr = new int[3];System.out.println(arr[3]);}
}

数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。解决方案：将错误的索引修改为正确的索引范围即可！

空指针异常

观察一下代码，运行后会出现什么结果。

public class Demo02ArrayTest {public static void main(String[] args) {int[] arr = new int[3];//把null赋值给数组arr = null;System.out.println(arr[0]);}
}

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。解决方案：给数组一个真正的堆内存空间引用即可

一维数组经典习题

数组获取最大值

/*需求: 从数组 int[] arr = {12,45,98,73,60}中查找最大值
*/
public class Demo03ArrayTest {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);}
}

数组基本查找

package demo02;import java.util.Scanner;
/*需求：已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。*/
public class Demo04ArrayTest {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);}
}

评委打分

import java.util.Scanner;
/*需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
*/
public class Demo05ArrayTest {public static void main(String[] args) {// 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6int[] 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);}
}

二维数组

概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器。本质上就是元素为一维数组的一个数组。 二维数组存储一维数组的时候，存储的是一维数组的内存地址。二维数组中存储的是一维数组, 能存入提前创建好的一维数组。

二维数组的声明与初始化

代码示例

//推荐
int[][] arrA;
//不推荐
int[] arrB[];
//不推荐
int arrC[][];

注意：

静态初始化

代码示例

package sgg.demo01;
/*静态初始化方式一： 数据类型[][] 标识符 = {{一维数组的元素},{一维数组的的元素},{一维数组的元素}};方式二： 数据类型[][] 标识符 = new 数据类型[][]{{一维数组的元素},{一维数组的元素}};
注意：1.二维数组的长度 指的是 数组内一维数组的个数2.三维数组的元素 就是二维数组 。。。。。 n维数组 存储的元素 是 n-1 维数组
*/public class Demo02 {public static void main(String[] args) {// 方式一： 数据类型[][] 标识符 = {{一维数组的元素},{一维数组的的元素},{一维数组的元素}};int[][] arrA = {{1, 2, 3}, {3, 4, 5}, {5, 6, 7}}; //要求声明与静态初始化必须一起完成//方式二： 数据类型[][] 标识符 = new 数据类型[][]{{一维数组的元素},{一维数组的元素}};int[][] arrB = new int[][]{{1, 2, 3}, {3, 4, 5}, {5, 6, 7}};//或者int[][] arrC;arrC = new int[][]{{1, 2, 3}, {3, 4, 5}, {5, 6, 7}};}
}

动态初始化

每一行的列数是相同的

代码示例

public static void main(String[] args) {//定义一个二维数组int[][] arr = new int[3][2];//定义了一个二维数组arr//这个二维数组有3个一维数组的元素//每一个一维数组有2个元素//输出二维数组名称System.out.println(arr); //地址值    [[I@175078b//输出二维数组的第一个元素一维数组的名称System.out.println(arr[0]); //地址值    [I@42552cSystem.out.println(arr[1]); //地址值    [I@e5bbd6System.out.println(arr[2]); //地址值    [I@8ee016//输出二维数组的元素System.out.println(arr[0][0]); //0System.out.println(arr[0][1]); //0}

每一行的列数是不相同的

代码示例

public static void main(String[] args) {//定义数组int[][] arr = new int[3][];System.out.println(arr);    //[[I@175078bSystem.out.println(arr[1][0]);//NullPointerExceptionSystem.out.println(arr[0]); //nullSystem.out.println(arr[1]); //nullSystem.out.println(arr[2]); //null//动态的为每一个一维数组分配空间arr[0] = new int[2];arr[1] = new int[3];arr[2] = new int[1];System.out.println(arr[0]); //[I@42552cSystem.out.println(arr[1]); //[I@e5bbd6System.out.println(arr[2]); //[I@8ee016System.out.println(arr[0][0]); //0System.out.println(arr[0][1]); //0//ArrayIndexOutOfBoundsException//System.out.println(arr[0][2]); //错误arr[1][0] = 100;arr[1][2] = 200;}

二维数组中的相关操作

获取二维数组中一维数组的个数：二维数组名.length
获取二维数组中指定的一维数组：二维数组名[行下标]，行下标的范围：[0, 二维数组名.length-1]
获取二维数组中指定一维数组中元素的个数：二维数组名[行下标].length
获取具体的某一个元素：二维数组名[一维数组下标][一维数组中元素的下标]

二维数组遍历

方式一：

public class Test1 {/*需求:已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};遍历该数组，取出所有元素并打印步骤:1. 遍历二维数组，取出里面每一个一维数组2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素*/public static void main(String[] args) {int[][] arr = {{11, 22, 33}, {33, 44, 55}};// 1. 遍历二维数组，取出里面每一个一维数组for (int i = 0; i < arr.length; i++) {//System.out.println(arr[i]);// 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素for (int j = 0; j < arr[i].length; j++) {System.out.println(arr[i][j]);}}}
}

方式二：

    public static void main(String[] args) {String[][] strArr = {{"蔡旭坤","特朗普"},{"杨幂","高圆圆","尼古拉斯*赵四"},{"胡歌","彭于晏","成龙","吴彦祖"}};//增强forfor (String[] strings : strArr) {for (String s : strings) {System.out.print(s+"\t");}System.out.println();}}

元素打乱

import java.util.Random;/*需求：已知二维数组 arr = {{1,2,3},{4,5,6},{7,8,9}};用程序实现把数组中的元素打乱,并在控制台输出打乱后的数组元素*/
public class ArrayTest02 {public static void main(String[] args) {//定义二维数组，并进行静态初始化int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};//创建随机数对象Random r = new Random();//遍历二维数组，进行元素打乱for (int i = 0; i < arr.length; i++) {for (int j = 0; j < arr[i].length; j++) {//arr[i][j]int x = r.nextInt(arr.length);int y = r.nextInt(arr[x].length);//元素交换int temp = arr[i][j];arr[i][j] = arr[x][y];arr[x][y] = temp;}}for (int i = 0; i < arr.length; i++) {for (int j = 0; j < arr[i].length; j++) {System.out.print(arr[i][j] + " ");}System.out.println();}}
}

二维数组的内存图分析

查看下面代码，分析在内存中的存储方式

 int[][] arr = {{1},{2,2},{3,3,3},{4,4,4,4},{5,5,5,5,5}};

代码内存图，如下所示

结论:

二维数组存储的是一维数组的内存地址值