JavaSE系列(七)、数组

七、数组

7.1 数组的定义和访问

• 数组的概念

  数组的概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

• 数组的定义（三种）

• #### 格式一：

```
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]；
int[] arr = new int[3];
```

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

• #### 格式二：

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

• #### 格式三：

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

• 数组的访问

  • 索引：每一个存储到数组的元素，都会自动的拥有一个编号，从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]);
  }
  

7.2 数组原理内存图

• 内存概述

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

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

• java虚拟机的内存划分

  JVM的内存划分：

• 数组在内存中的存储

• 一个数组内存图

public static void main(String[]args){
	int[] arr = new int[3];
	System.out.println(arr);//[I@5f150435是数组在内存中的地址。
	//new出来的内容，都是在堆内存中存储的，而方法中的变量arr保存的是数组的地址。
}

• 两个数组内存图

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]);//5
	System.out.println(arr[1]);//6
	System.out.println(arr[2]);//7
	//定义数组变量arr2，将arr的地址赋值给arr2，此时arr和arr2操作的是同一个数组
	int[] arr2 = arr;
	arr2[1] = 9;
	System.out.println(arr[1]);//9
}

7.3 数组的常见操作

• 数组越界异常

  public static void main(String[]args){
  	int[] arr = {1,2,3};
  	System.out.println(arr[3]);//数组索引只有0-2,3>2数组下标越界异常
  }
  

    在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
  

• 数组空指针异常

  public static void main(String[]args){
  	int[] arr = {1,2,3};
  	arr = null;
  	System.out.println(arr[0]);//数组置空，内存中已不存在数组arr，所以报空指针异常
  }
  

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

• 数组遍历【重点】

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

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

• 数组获取最大值元素

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

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

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

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

7.4数组作为方法参数和返回值

• 数组作为方法参数

  数组作为方法参数传递，传递的参数是数组内存的地址。

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

• 数组作为方法返回值

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

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

• 方法的参数类型区别

  public static void main(String[]args){
      int a = 1;
      int b = 2;
      System.out.println(a);//1
      System.out.println(b);//2
      //基本数据类型相当于复制一个副本，副本中的值改变但是原来的不变
      change(a,b);
      System.out.println(a);//1
      System.out.println(b);//2
  }
  public static void change(int a,int b){
      a = a + b;
      b = b + a;
  }
  

  public static void main(String[]args){
  	int[] arr = {1,3,5};
  	System.out.println(arr[0]);//1
  	//引用数据类型传递的是地址，都发生改变
  	change(arr);
  	System.out.println(arr[0]);//200
  }
  public static void change(int[]arr){
  	arr[0] = 200;
  }
  

总结（重难点）:
①方法的参数为基本数据类型时,传递的是数据值，只传数据值，相当于复制一个副本，改变数值时只可以改变现在的数据而原来的数据不变.
②方法的参数为引用数据类型时,传递的是地址值，改变数值时原来和现在的值都改变.
这与全局变量还是局部变量无关，只与数据类型相关！

方法栈：存放方法的定义和结构，通过main方法进入方法栈。

堆内存：存储的是实际变量的地址及数据值，new的对象数据都存储在堆内存中。

引用数据类型：赋值是直接将a地址赋值给b，当修改b中数据值时，a中的数据值也会变，实际上此时a和b操作的是同一个变量。

基本数据类型：是直接将a拷贝一个副本赋值给b，修改b，a不变。