Java数组

更多精彩内容

内容

• 数组概念
• 数组的定义
• 数组的索引
• 数组内存
• 数组的遍历
• 数组的最大值获取
• 数组反转
• 数组作为方法参数和返回值

目标

• 理解容器的概念
• 掌握数组的第一种定义方式
• 掌握数组的第二种定义方式
• 掌握数组的第三种定义方式
• 使用索引访问数组的元素
• 了解数组的内存图解
• 了解空指针和越界异常
• 掌握数组的遍历
• 掌握数组最大值的获取
• 了解数组反转的原理
• 了解数组作为方法参数传递
• 了解数组作为方法的返回值

第一章 数组定义和访问

1.1 数组概念

在Java中有常量数据，而一般情况下，常量数据都需要保存在变量空间中。

假设有100 这个数据需要在程序中先存储起来：

int a = 100；

假设有100，200 这个数据需要在程序中先存储起来：

int a = 100;

int b = 200;

问题继续升级，有大量的整数需要保存，怎么解决？

第一种解决方案：有多少个数据，就开辟多少个空间，把每个值保存到空间中。

这种解决方案，最后肯定可以把所有的数据保存起来，但是程序书写十分麻烦。常量数据最后肯定需要保存在变量空间中，在前面学习的变量，每个变量空间中在特定的时候，只能保存一个值。无法一次性保存多个数据。

Java中给我们提供另外一种方案：

一次性可以开辟出一组空间，然后这些空间中可以保存多个数据。而我们把这一组空间统称为数组。

那么数组到底是什么呢?有什么特点呢?

数组：数组表示的一串连续的存储空间。每个空间中都可以保存一个数据。当我们需要操作的时候，不要去面对单个空间，而直接面对这个整体的连续的存储区域。

注意：数组既可以存储基本数据类型，也可以存储引用数据类型。

1.2 数组的定义

方式一

• 格式：

 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
举例：
int[] arr=new int[4];

• 数组定义格式详解：
  • 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
  • [] : 表示数组。
  • 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
  • new：关键字，创建数组使用的关键字。
  • 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
  • [长度]：数组的长度，表示数组容器中可以存储多少个元素。
  • 注意：数组有定长特性，长度一旦指定，不可更改。
    • 和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。
• 举例：

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

int[] arr = new int[4];

在内存中一次开辟4个连续的空间，每个空间都是int类型，并且这些空间中保存的数据也必须是int类型。

方式二

• 格式：

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

• 举例：

定义存储1，2，3，4，5整数的数组容器。

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

方式三

• 格式：

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

• 举例：

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

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

1.4 数组的访问

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

数组名[索引]

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

public static void main(String[] args) {
  	int[] arr = new int[]{1,2,3,4,5};
  	//打印数组的属性，输出结果是5
  	System.out.println(arr.length);
}

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

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

第二章 数组原理内存图

2.1 内存概述

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

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

2.2 Java虚拟机的内存划分

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

• JVM的内存划分：

  区域名称	作用
  寄存器	给CPU使用，和我们开发无关。
  本地方法区	JVM在使用操作系统功能的时候使用，例如native修饰的内容，和我们开发无关。
  方法区	存储可以运行的class文件。
  堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
  栈内存	方法运行时使用的内存，比如main方法运行，进入栈内存中执行。

补充：

栈内存：栈内存主要是用来运行函数的，在函数中定义的所有变量，都会在这个内存开辟空间。

在栈内存中定义的变量，不初始化，是不能直接使用的。

注意：所有的函数(方法)都必须在栈内存中运行。

而jvm只会运行处于栈内存顶部的函数。

函数被加载到栈内存的动作，称为函数的压栈（入栈）。

函数执行完之后就会从栈中消失（函数的弹栈，或者叫做出栈）

堆内存：在程序中使用new 关键字创建出来的所有东西，都会保存在堆内存中。

堆内存中开辟的空间，不赋值，都会有默认的初始化数据。

整数：默认是0

小数 默认0.0.

boolean 默认是false

char 默认是 ‘\u0000’

引用数据类型默认值是 null

方法区：JVM在加载class文件的时候，所有的class文件就要加载在这个内存中。(先了解，后面会详细讲解)

2.3 数组在内存中的存储

一个数组内存图

public static void main(String[] args) {
  	int[] arr = new int[3];
  	System.out.println(arr);//[I@5f150435
}

以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆内存中存储的，而方法中的变量arr保存的是数组的地址。

输出arr[0]，就会输出arr保存的内存地址中数组中0索引上的元素

两个数组内存图

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

两个变量指向一个数组

public static void main(String[] args) {
    // 定义数组，存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5;
    arr[1] = 6;
    arr[2] = 7;
    //输出3个索引上的元素值
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    //定义数组变量arr2，将arr的地址赋值给arr2
    int[] arr2 = arr;
    arr2[1] = 9;
    System.out.println(arr[1]);
}

第三章 数组的常见操作

3.1 数组越界异常

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

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

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

3.2 数组空指针异常

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

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

arr = null这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

空指针异常在内存图中的表现

3.3 数组遍历【重点】

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

public static void main(String[] 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 ，可以作为循环的条件出现。

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]);
    }
}

数组遍历升级：要求将数组中的每个数据之间用逗号隔开。例如：1,2,3,4,5

/*
	遍历数组
*/
class ArrayTest 
{
	public static void main(String[] args) 
	{
		//定义数组
		int[] arr={ 1, 2, 3, 4, 5 };
		//将数组arr中的数据打印到屏幕上
		//由于数组的下标有序的增加，使用循环提供数组的下标
		/*for (int i=0;i<arr.length ;i++)
		{
			System.out.println(arr[i]);
			
		}*/
		for (int i=0;i<arr.length ;i++ )
		{
			//这里需要加一个判断语句，如果数据是最后一位，就不需要打印逗号
			if (i==arr.length-1)
			{
				//说明数组的下标是整个数组中最后一个下标
				System.out.println(arr[i]);
			}else{
				//说明数组的下标不是最后一个下标
				System.out.print(arr[i]+",");
			}
		}
		
	}
}

3.4 数组获取最大值元素

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

  分析和步骤：

  数组的最值问题：

  在对数组求最值的时候，一般我们会假设一个值为最大值或者最小值，然后遍历数组中的所有空间，和假设的这个值进行大小比较，只要从数组中取出的值比假设的值大 或者 小， 就进行替换。

  ​ 最终把数组遍历完成，就能找到最大值 或者 最小值。

  注意：一般要求假设的这个值一定是数组中存在的值。

• 实现思路：

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

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

3.5 数组反转

• 数组的反转： 数组中的元素颠倒顺序，例如原始数组为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]);
    }
}

第四章 数组作为方法参数和返回值

4.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]);
    }
}

4.2 数组作为方法返回值

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

public static void main(String[] args) {
    //调用方法，接收数组的返回值
    //接收到的是数组的内存地址
    int[] arr = getArray();
    for (int i = 0; i < arr.length; i++) {
		System.out.println(arr[i]);
    }
}
/*
  创建方法，返回值是数组类型
  return返回数组的地址
*/
public static int[] getArray() {
    int[] arr = { 1, 3, 5, 7, 9 };
    //返回数组的地址，返回到调用者
    return arr;
}

4.3 方法的参数类型区别

代码分析

1. 分析下列程序代码，计算输出结果。

public static void main(String[] args) {
    int a = 3;
    int b = 5;
    change(a, b);
    System.out.println(a);
    System.out.println(b);
}

public static void change(int a, int b) {
    a = a + b;
    b = b + a;
}

2. 分析下列程序代码，计算输出结果。

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

public static void change(int[] arr) {
  	arr[0] = arr[0]+arr[0];
    arr[1] = arr[1]+arr[1];
}

总结：

​ 方法的参数为基本类型时,传递的是数据值.

​ 方法的参数为引用类型时,传递的是地址值.

断点查看

Idea的断点调试可以查看程序的执行流程和解决程序中的bug。

我们在运行程序的过程中，经常需要看程序运行过程中某些变量，容器等里面数据的具体的结果，或者是数据的变化情况。而我们之前都是通过输出语句System.out.println()来查看的，这样虽然可以实现结果，但是比较麻烦。我们可以使用更简单的方法来实现，就是可以使用编辑器Idea提供的程序调试工具。

1. 要想看程序流程，就必须设置断点。在需要查看的代码的前面即行号右边的空白区域单击左键设置断点。

   什么是断点：就是一个标记，程序从哪里开始debug调试开始。

     在哪里设置断点：
   

   ​ 哪里不会点哪里。

   ​ 目前：我们就在每个方法的第一条有效语句上都加。

   设置完断点之后，程序执行到断点处将停止，我们可以手动来运行程序。

2.如何运行设置断点后的程序：使用Debug运行模式运行程序：

​ 右键 – Debug

3.程序停止在断点上不再执行，而IDEA最下方打开了Debug调试窗口

1. Debug调试窗口介绍

2. 快捷键F8，代码向下执行一行

1. 快捷键F8执行输出语句，此时到达change方法，快捷键F7，进入方法change

2. 快捷键F8，程序继续向后执行，数组0索引值被修改成200

3. 切换到控制台面板，看看两个方法中是否输出了相同的数组地址

4. 程序继续执行，change方法结束，程序回到main中

5. 调试结束，点击Console切换到控制台，看输出的结果

6、调试完成之后，要将断点取消