书名：java基础知识

课程目标

1.【掌握】IDEA基本使用

2.【理解】什么是数组？

3.【掌握】数组的定义与初始化

4.【理解】数组的内存映射

6.【理解】数组常见问题

7.【掌握】数组案例

8.【理解】二维数组

一.为何用数组

java考试结束后，老师给你布置了一个任务。请计算全班（30人）的平均分？

int Stu01，stu02，stu03，stu30。有必要定义30名学生的分数变量。

二.一维数组

2.1 数组概念

多个同类型数据按一定顺序排列、以名称命名、通过编号统一管理的集合。

定义：相同数据类型固定长度的容器。

总结：存储数据时，长度和类型是固定的；

四步：声明数组、分配空间、赋值、处理数据

2.2数组定义格式

2.2.1格式一

数据类型[]数组名；例子：

int[] arr；

双[] arr；

字符[] arr；

2.2.2格式二

数据类型数组名[]；例子：

int arr[];

双arr[]；

字符数组[]；

2.3数组初始化

2.3.1数组静态初始化

什么是静态初始化

创建数组时，直接确定元素，系统会计算数组的长度。

静态初始化格式

完整版格式

数据类型[]数组名称=新数据类型[]{元素1,元素2,};

简化版格式

数据类型[]数组名={元素1,元素2,}; };

示例代码

公共类ArrayDemo {

公共静态无效主（字符串[] args）{

//定义数组

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

//输出数组名

System.out.println(arr);

//输出数组中的元素

System.out.println(arr[0]);//1

System.out.println(arr[1]);//2

System.out.println(arr[2]);//3

}

}

2.3.2数组动态初始化

什么是动态初始化

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

动态初始化格式

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

System.out.println(arr);//[I@1540e19d

//访问数组元素格式

System.out.println(arr[0]);//0

System.out.println(arr[1]);//0

System.out.println(arr[2]);//0

动态初始化格式详解

等号左边

int: 数组数据类型[] : 代表这是一个数组arr: 代表数组的名称

等号右边

new: 为array int: array 数据类型[] : 代表这是一个数组3: 代表数组的长度

2.4访问数组元素

2.4.1什么是下标

数组中存储的每个元素都会自动有一个编号，从0开始。

这种自动编号称为数组下标（索引），通过数组的索引可以访问数组中的元素。

2.4.2语法格式

数组名称[索引]；

示例代码

公共类ArrayDemo {

公共静态无效主（字符串[] args）{

int[] arr=新int[3];

//输出数组名

System.out.println(arr); //[我@880ec60

//输出数组中的元素

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

//数组赋值；单一赋值或使用循环赋值

//使用循环读取数组元素

}

}

2.5内存分配

2.5.1内存概述

内存是计算机中的重要组件。它是一个临时存储区域，用于运行程序。

我们编写的程序都存储在硬盘中，硬盘上的程序不会运行。

必须放入内存中才能运行，运行完成后内存会被清空。

为了运行程序，Java虚拟机必须分配和管理内存空间。

2.5.2java中的内存分配

目前我们只需要记住两种内存，即：栈内存和堆内存

地区名称

影响

登记

它是CPU使用的，与我们开发无关。

本地方法栈

JVM是在使用操作系统功能时使用的，与我们的开发无关。

方法区

存放可以运行的类文件。

堆内存

用new创建的存储对象或数组存储在堆内存中。

方法栈

方法运行时使用的内存，例如main方法运行时，进入方法栈执行。

2.6数组内存图

2.6.1单个数组的内存图

2.6.2多个数组的内存图

2.6.3多个数组指向相同内存图

2.7注意事项

2.7.1索引越界异常

出现原因

公共类ArrayDemo {

公共静态无效主（字符串[] args）{

int[] arr=新int[3];

System.out.println(arr[3]);

}

}数组长度为3，索引范围为0~2，但我们访问的索引为3。

程序运行后，会抛出ArrayIndexOutOfBoundsException数组越界异常。开发中不会出现数组越界异常。一旦发生，我们编写的代码就必须修改。

解决方案

只需将错误的索引修改为正确的索引范围即可！

2.7.2空指针异常

出现原因

公共类ArrayDemo {

公共静态无效主（字符串[] args）{

int[] arr=新int[3];

//给数组赋null

arr=空；

System.out.println(arr[0]);

}

}arr=null 这行代码意味着变量arr不会保存数组的内存地址，并且不再允许对数组进行操作，因此运行时会抛出NullPointerException。开发中不会出现数组越界异常。一旦发生，我们编写的代码就必须修改。

解决方案

只要给数组一个真正的堆内存空间引用即可！

2.8数组案例

2.8.1数组遍历

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

公共类ArrayTest01 {

公共静态无效主（字符串[] args）{

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

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[3]);

System.out.println(arr[4]);

}

}上面的代码可以遍历数组中的每一个元素，但是如果数组元素非常多，这种写法肯定不行，所以需要改成循环写法。该数组的索引范围为0 到lenght-1，并且可以作为循环条件出现。

公共类ArrayTest01 {

公共静态无效主（字符串[] args）{

//定义数组

int[] arr={11, 22, 33, 44, 55};

//使用通用的遍历格式

for(int x=0; xarr.length; x++) {

System.out.println(arr[x]);

}

}

}//for(数据类型变量：数组或集合){}

//变量是数组中的元素，相当于执行了从数组中一一取值的操作；

for (int num :scores) {

System.out.println(num);

}

2.8.2 数组最值

数组的最大值是从数组的所有元素中找出最大值或最小值；

动态求几个数字的最大值和最小值；

实现思路

定义一个变量，假设为最大值max，保存数组索引0处的元素，遍历数组，获取数组中的每个元素。将遍历到的元素与保存数组索引0 处的值的变量进行比较。如果数组元素的值大于变量的值。变量记录新值。数组循环遍历结束，变量存储数组中的最大值。

代码实现

公共类ArrayTest02 {

公共静态无效主（字符串[] args）{

//1.使用静态初始化方法；

int[]yanzhis={5,15,400,800,89,100};

//遍历之前，定义一个变量max，记录出现次数最高的值；

int max=yanzhis[0]; //假设第一个数组元素出现次数最高，分配给max变量；

整数索引=0； //在for外面定义一个变量，记录最大值位置；

//2.遍历它； foreach

for (int i=1; i yanzhis.length; i++) {

//3.比较以下元素并一一比较max。如果max 之后的元素

//证明max不是最大值，然后将下面的值赋给max

if(maxyanzhis[i]) {

max=yanzhis[i];

索引=i；

}

}

//4.输出

System.out.println('选美比赛，颜值最好的是：'+max);

System.out.println('外观最好的是：'+(index)+'bit');

}

}

2.8.3 数组元素反转

数组中的元素顺序相反。例如原数组为1,2,3,4,5，反转后的数组为5,4,3,2,1，影响原数据；

实现思路

分析：

将0 索引与arr.length-1 交换

将1 索引与arr.length-2 交换

将2 索引与arr.length-3 交换

就做arr.length/2，只做一半，否则就调回来了；

代码实现

public static void main(String[] args) {

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

/*

//第一次交换

int temp=arr[0];

arr[0]=arr[arr.length - 1];//将0索引与length-1交换

arr[arr.length - 1]=temp;//交换前面和最后一个

//第二次交换

int temp2=arr[1];

arr[1]=arr[arr.length - 1 - 1];

arr[arr.length - 1 - 1]=temp2;

//第三次交换

int temp3=arr[2];

arr[2]=arr[arr.length - 1 - 2];

arr[arr.length - 1 - 2]=temp3;

//第N次交换。

*/

//用循环改进

for(int x=0;xarr.length/2;x++){

int temp=arr[x];

arr[x]=arr[arr.length - 1 - x];

arr[arr.length - 1 - x]=temp;

}

//反转后，遍历数组

System.out.print('[');

for(int x=0;xarr.length;x++){

if(x==arr.length-1){

System.out.println(arr[x]);

}别的{

System.out.print(arr[x]+',');

}

}

System.out.println(']');

}

三.二维数组

3.1什么是二维数组

一个二维数组，其实就是这个二维数组里有多少个一维数组。它是一维数组的一维数组。

3.2二维数组格式

格式一

数据类型[][] 变量名称=new 数据类型[m][n]；

格式解释

m表示这个二维数组有多少个一维数组

n表示每一个一维数组的元素个数

举例

//格式1静态初始值

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

//这个二维数组中有3个一维数组，每个一维数组有2个长度

//获取第一个一维数组

System.out.println(arr[0][0]);

System.out.println(arr[0][1]);

System.out.println('==========第一个一维数组==========');

arr[0][0]=10;

System.out.println(arr[0][0]);

System.out.println(arr[0][1]);

System.out.println('================');

//获取第二个一维数组

System.out.println(arr[1][0]);

System.out.println(arr[1][1]);

//获取第三个一维数组

System.out.println(arr[2][0]);

System.out.println(arr[2][1]);

格式二

数据类型[][] 变量名称=new 数据类型[m][];

格式解释

m表示这个二维数组有多少个一维数组

这一次没有直接给出一维数组的元素个数，可以动态的给出

举例

//二维数组中有3个一维数组，但是这次没有给出第一个一维数组的长度

int[][] arr=新int[3][];

//第一个数组的元素个数为2

arr[0]=新int[2];

//第二个数组的元素个数为3

arr[1]=新int[3]

//第三个数组的元素个数为1

arr[2]=新int[1];

格式三

标准版：

数据类型[][]变量名=新数据类型[][]{{元素…},{元素…},{元素…}};

简化版：

数据类型[][]变量名={{元素…},{元素…},{元素…}};

举例

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

3.3二维数组遍历

案例代码

公共类ArrayCase {

公共静态无效主（字符串[] args）{

//定义一个二维数组

int[][] arr={{22, 66, 44}, {77, 33, 88}, {25, 45, 65}};

//遍历第一个一维数组

for(int x=0; xarr[0].length; x++){

System.out.println(arr[0][x]);

}

System.out.println('======================');

//遍历第二个一维数组

for(int x=0; xarr[1].length; x++){

System.out.println(arr[1][x]);

}

System.out.println('======================');

//遍历第三个一维数组

for(int x=0; xarr[2].length; x++){

System.out.println(arr[2][x]);

}

System.out.println('======================');

//用户循环改善y

for (int y=0; y arr.length; y++) {

for(int x=0; xarr[y].length; x++){

System.out.println(arr[y][x]);

}

System.out.println();

}

}

}

四.返璞归真

main(String[]args)公共类ArrayMain {

//回到HelloWorld的第一个源代码程序；字符串[]参数；类似于门卫；

公共静态无效主（字符串[] args）{

for(int i=0;iargs.length;i++) {

System.out.println(i+'='+args[i]);

}

}

}