数组

数组

容器的概念

  容器：就是将多个数据存储在一起，每个数据称为该容器的元素。
  生活中的容器：水杯、excel、教室

数组概念

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

数组的定义

数组的特点

格式：

		//方式一
		数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[长度(正整数)];

解析：

• 数组存储的数据类型：决定了该数组容器能够存储什么样的数据
• []:表示数组
• 数组名称：给定义数组起一个变量的名字，满足标识符的命名规范
• new：关键字，创建数组使用的关键字。
• 数组存储的数据类型：决定了该数组容器能够存储什么样的数组 [长度]：数组的长度

备注：数组一旦创建，长度不能发生改变，数组具备一个定长特性

		//方式二
		数组的数据类型[] 数组名称 = new 数组的数据类型[]{元素1,元素2,元素3,……};

		//方式三
		数组的数据类型[] 数组名称 = {元素1,元素2,元素3,……};

1. 数组的长度在程序运行期间不可改变
2. 数组本身就是一种引用数据类型
3. 数组定义时是引用数据类型，但是数组容器里面存储的元素可以是基本数据类型也可以是引用类型。
4. 数组当中存储多个数据，类型保持一致。

数组初始化：在内存当中创建了一个数组，并且向数组容器中赋予一些默认值。

默认值：

• 对于int整数类型来说，默认值是0
• 对于浮点数类型来说，默认值是0.0
• 对于字符类型来说，默认值是‘\u0000’
• 对于布尔类型来说，默认值是false
• 对于引用类型来说，默认值是null

两种常见的初始化动作：

1. 静态初始化（指定内容）：在创建数组的时候，不指定数组的长度（存储元素的个数），而是直接指定具体的[内容]
2. 动态初始化（指定长度）:在创建数组的时候，直接指定数组的长度（存储元素的个数）

备注：
  静态初始化虽然没有直接指定长度，但是程序会推算得到该数组的长度。
建议：
  如果不确定数组中存储的内容时，用动态初始化，反之内容已经确定了，使用静态初始化。
  大多数情况下，建议使用动态初始化

数组的访问

索引

索引：角标、下标
  每一个存储到数组当中的元素，都会自动的分配一个编号，从0开始，这个系统自动分配的编号称为数组的索引(intdex),可以通过索引访问数组当中的元素。
  格式：

		数组名称[索引]

  数组的最大索引是[数组名称.length -1]

数组的长度属性

  每个数组都有长度，而且是固定的，java会自动赋给数组一个属性，可以获取到数组的长度属性。
  格式：

		数组名称.length

  属性length代表的就是数组的长度，int类型

索引访问数组当中的元素操作

  修改数组当中索引对应位置上的值
  变量=数组名称[索引]，从数组当中取一个值赋值给一个变量

数组原理内存图解

内存：
  内存是计算机中一个很重要的原件，临时存储区域。
  作用是，当程序运行过程中，我们编写的代码文件存放在硬盘当中，硬盘当中的程序文件不会运行，存放到内存当中，当程序运行完毕后程序会清空内存。
Java虚拟机当中的内存划分
   为了提高运行效率，就会对内存空间进行不同区域的划分，每一片区域都有特定的处理数据方式和内存管理方式

JVM内存划分

区域名称	作用
寄存器	给cpu使用，和我们开发没有关系
本地方法栈	JVM在使用操作系统功能时使用的，和我们开发没有关系
方法区	存储可以运行的class文件(常量池，静态域)
方法栈（stack）	方法运行时使用的内存，比如说main方法运行，进行方法栈当中运行
堆内存（heap）	存储对象或者数组，new出来的对象，都统统存储在堆内存中。

数组在内存当中的存储

一个数组的内存存储

public static void main(String[ ] args) {
  int[] arr = new int[ 3 ];
  System. out . println(arr);//内存地址哈希值
}

程序执行流程：
   1、main方法进入方法栈中执行
   2、创建数组，JVM会在堆内存中开辟空间，存储数组
   3、数组在内存当中会有自己的内存地址，以十六进制表示
   4、数组当中有三个元素，默认值为0
   5、JVM将数组的内存地址赋值给引用类型变量arr
   6、变量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) {
	int[] arr = new int[ 3 ];
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	System.out.ptintln(arr[1]);
	int[] arr2 = arr;
	arr2[1] = 50;
	System.out.ptintln(arr2[1]);
	System.out.ptintln(arr[1]);
}

数组的常见异常操作

数组的越界操作

public static void main(String[] args) { 
	//动态初始化一个数组
	int[] arr = new int[5];
	//访问索引值为5的数组元素
	System. out. println(arr[5]);
}

  数组索引是从0开始，最大索引值是arr.length-1
  如果访问数组元素时，索引值不在该区间中，程序就会抛出数组索引越界异常。
  在开发中，不要出现索引越界异常现象，因为它会导致程序异常终止。

数组的空指针异常操作

public static void main(String[] args){
	//动态初始化一个数组
	int[] arr = new int[3];
	arr = null;
}

  数组空指针异常，就是在程序运行中，有一个在内存中不存在的一个变量被引用到了

数组遍历

  数组遍历：就是将数组中的每一个元素分别获取出来。遍历是我们操作数组的核心和重点内容。

public static void main(String[] args) {
  //静态初始化一个数组
  int[] arr = {1,2,3,4};
  System.out.println(arr[0]);
  System.out.println(arr[1]);
  System.out.println(arr[2]);
  System.out.println(arr[3]);
}

  数组的索引依次递增，递增到arr.length-1为止，引入循环结构

public static void main(String[] args) {
   //静态初始化一个数组
   int[] arr = {1,2,3,4};
   //数组遍历
   for(int i = 0;i < arr.length; i++ ){
   	System.out.println(arr[i]);
   }
}

获取数组当中的最大值元素

最大值：从数组的所有元素中找出最大值
思路：
   1.定义一个最大值变量，保存数组当中的第一个元素(数组当中索引值为0的)
   2.遍历数组，获取数组当中的每一个元素
   3.将遍历到的元素和保存的最大值变量进行比较
   4.如果数组元素的值大于最大值变量，就把数组元素赋值给最大值变量
   5.数组遍历结束，最大值变量保存的就是数组当中的最大值。

public static void main(String[] args) {
	int[] arr = {3000, 200 ,1000,10000,5000};
	//定义一个最大值变量，保存数组当中的第一个元素
	int max = arr[0];
	for (int i = 1;i < arr.length;i++){
		if(arr[i] > max){
			max = arr[i];
		}
	}
	System.out.println("数组的最大值是：" + max);
}

数组的反转

数组的反转：数组中的元素颠倒顺序，例如:原始数组为1，2，3，4，5，数组反转之后为5，4，3，2，1
思路：本质是考察交换两个变量的值

• 实现反转，就需要将数组最远端的元素和最近端位置互换
• 定义两个变量，保存数组的最小索引和数组的最大索引
• 让两个索引上的元素交换位置
• 最先的索引变量++，最大的索引变量–，再次交换位置
• 最小的索引超过的最大的索引

准备一个需要反转的数组 int[] arr = {1,2,3,4,5,6,7};
定义两个索引变量,一个索引变量指向最小索引，一个指向最大索引
int min = 0;
int max = arr.length-1;
遍历数组，让两个索隐变量产生变化
min++;
max--;
条件 min < max 
交换最小索引元素和最大元索引元素，需要定义第三方变量
int temp = 0;
temp = arr[min];//把最小的索引元素赋值给第三方变量temp
arr[min] = arr[max];//把最大的索引元素赋值给最小的索引元素
arr[max] = temp;//把四三方变量的值赋值给最大索引的元素

public static void main(String[] args) {
	int[] arr = {1,2,3,4,5};
	//遍历数组 for
	for (int min = 0,int max = arr.length - 1;min < max;min++,max--) {
		int temp = 0;
		temp = arr[min];
		arr[min] = arr[max];
		arr[max] = temp;
	}
	//第二种思路:
	int[] arr = {1,2,3,4,5};
	//遍历数组
	for(inti=0;i<arr.length/2;i++) {
		//交换变量
		int temp=e;
		temp = arr[i] ;
		arr[i] = arr[arr . length-1-i];
		arr[arr .1ength-1-i] = temp;
	}
}