15、Java中的数组

Java中的数组

作者：韩茹

公司：程序咖（北京）科技有限公司

程序咖：IT职业技能评测平台

网址：www.chengxuka.com

s12thD3BbaNUkocUAEQegbkvXrPCEZMbPZLxa21c

任务

1.数组的声明和初始化
2.数组的元素访问以及遍历
3.数组的应用(https://img.chengxuka.com/ruby0015/冒泡排序、选择排序、顺序查找和二分法查找)
4.Arrays工具类的使用
5.可变参数的应用

一、数组的使用

1.1 为什么使用数组

如果说程序中，需要存储大量的相同类型的一组数据，如果直接使用变量来进行存储，每个变量只能存储一个值，就需要大量的变量。
1、代码过于臃肿
2、程序的可读性差
3、数据维护较差

1.2 数组的概念

数组的概念：
就是一组相同数据类型的数据。内存上是开辟的连续的内存空间。

1.3 数组的特点？

1、定长。容量固定。数组一旦创建后，那么长度不能更改。(容量，长度，都是指存储的数量)
2、存储的数据类型必须都一致。
3、在内存中空间连续挨个。
4、数组是引用类型的数据，存在栈和堆的地址引用关系。

Java中：两大数据类型
	基本：4类8种
	引用：数组，对象，集合。。。。

Kt0WiuADWQg4wzG3V1ipG5XoLDxx0NWzDr6g2meM

1.4 数组的使用

step1：先创建数组
step2：使用数组：存储数据，访问数据。

1.5 数组的声明

方式一：数据类型[] 数组名		

方式二：数据类型 数组名[] 

	推荐使用方式一，c#等越来越多的语言已经不支持方式二定义数组

1.6 数组中的默认值

创建好数组后，里面存储了默认的数值。到底存储哪个数值，要看创建的数组是何种类型。

数组的默认值，就是数组创建后，里面存储的默认的数据。
数组的引用存在栈内存中，数组本身存在堆内存中。
数组创建完，就有默认的数据了。
数组中存储的默认值：
			数组中是有默认值的
			整数：0
			小数：0.0
			字符：\u0000
			布尔：false
			其他：null

示例代码：

//1.int类型的数组
int[] arr1 = new int[3];//此时arr1数组中存储了3个0
//2.boolean类型的数组
boolean arr2 = new boolean[4];//此时arr2数组中存储了4个false
//3.String类型的数组
String[] arr3 = new String[3];//此时arr3数组中存储了3个null

1.7 数组的初始化

Java中的数组必须先初始化，然后才可以使用，所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋初始值。否则数组中存储的就是默认数值。

静态初始化

初始化时由程序员指定每个数组元素的初始值，由系统计算数组长度

	语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素0，元素1,....};

	可简写为：数组元素类型[] 数组名 = {元素0，元素1,....};

	说明：任何一个变量都得有自己的数据类型，这里的arr表示数组变量名称，int表示数组中元素的类型，int[]才是数组类型

代码实现：

		/*
		静态初始化:由我们指定元素的初始值，由系统计算长度或者元素的个数
		*/
		int[] arr1 = new int[]{1,56,76,87};
		int[] arr2 = {1,56,76,87};

		String[] arr3 = new String[]{"hello","程序咖","Ruby"};
		String[] arr4 = {"hello","程序咖","Ruby"};

		char[] arr5 = new char[]{'2','g','*'};
		char[] arr6 ={'2','g','*'};

动态初始化

初始化时程序员只指定数组长度，由系统为数组元素分配初始值

	语法：元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]；

	系统对初始值分配规则如下：a.整数型为0

							    b.浮点型为0.0
							    c.字符型为‘\u0000’(不同的系统平台显示结果不同)
							    d.布尔类型为false
							    e.引用类型为null

代码实现：

		/*
		动态初始化：初始化时由程序员指定数组的长度，系统负责分配元素的初始值
		*/
		int[] arr7 = new int[5];//0

		String[] arr8 = new String[3];//null

		char[] arr9 = new char[10];//\u0000

		/*
		int x = 4;
		x在栈空间中开辟空间
		4为常量，存储在常量池中

		char[] arr = new char[10];
		方法压栈：
		arr是一个变量名称
		arr也是在栈空间中开辟空间的
		通过new关键字创建出来的数组存储在堆空间中
		arr其实就是一个引用，指向了一个真正的数组
		*/

注意：
	a.在初始化数组时，不要静态初始化和动态初始化同时使用，也就是说，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值
	b.既然数组也是一种数据类型，则在初始化的时候也可以先声明，再初始化
		例如：
				int[] scores;
			 	scores = new int[3];

创建数组的其他语法

/*
动态创建数组：先创建数组，然后再根据下标一个一个存储数据。
A：先声明，再创建(分配内存空间)
数据类型 [] 数组名;
数组名 = new 数据类型[长度];

B：声明并创建
数据类型 [] 数组名 = new 数据类型[长度];
数据类型  数组名[] = new 数据类型[长度];


//静态创建数组：声明，创建，赋值一起写完。
C：声明，创建，并赋值
数据类型[] 数组名 = {数值1,数值2,数值3,数值4.。。。};
//=左边声明数组，=右边，会先根据{}中数据的个数，然后再将{}中数据，按照顺序存储进去。
完成了几件事：
			1.先声明：int[] c
			2.根据{}中数组值的个数，开辟堆内存
			3.将{}中的数组值，依次按照顺序存入数组中
D：声明，创建，并赋值
数据类型[] 数组名 = new 数据类型[]{数值1,数值2,数值3,数值4.。。。}
*/

二、数组的访问

2.1 数组的访问

通过下标访问指定元素，数组中的每个下标，都有编号，顺序，也叫索引，index。从0开始，到个数减1。

比如说一个数组中元素的个数是3个。

int[] arr = new int[1,2,3];
那么1这个元素，存储在数组中的第一个位置上，下标为0。
2这个元素，存储在数组中的第二个位置上，下标为1。
3这个元素，则存储在第三个位置上，下标为2。

它们的对应位置：

元素	1	2	3
下标	0	1	2

我们就可以通过数组的名字，结合下标来进行访问数组中的元素：

数组名[index];

代码实现：

public class Demo53Array 
{
	public static void main(String[] args) 
	{
		//使用静态初始化的方式定义一个数组
		//数组中可以存放重复数据
		int[] arr1 = new int[]{2,65,76,83,32,5,5};

		//1.访问数组中的元素
		//格式：数组名称[下标]    表示获取指定下标所对应的值
		//需求：获取下标3对应的元素
		int num1 = arr1[3];
		System.out.println(num1);//83
		System.out.println(arr1[3]);//83
	}
}

运行结果：

shuzu1

修改数组元素的值

代码实现：

		//2.修改数组元素的值
		int num2 = arr1[6];
		System.out.println(num2);//5
		num2 = 100;
		System.out.println(num2);//100
		System.out.println(arr1[6]);//5
		
		//格式：数组名称[下标] = 被修改之后的值
		//注意：不管是静态初始化还是动态初始化，都可以采用这种方式修改元素的值
		arr1[6] = 100;
		System.out.println(arr1[6]);//100

运行结果： shuzu2

下标越界：

		//3.如果下标超出数组的长度，会下标越界异常
		System.out.println(arr1[10]);

运行结果：

shuzu3

小结：

/*
创建数组的语法：
	数据类型[] 数组名 = new 数据类型[长度、容量、个数];
	数据类型 数组名[] = new 数据类型[长度];//也可以
	
使用的语法：
	数组名[index]，操作数组
	index：因为一个数组存储了多个数据(也叫元素)，每个元素都有一个下标，也叫索引，index。理解起来就是给每个数据排个编号，固定从0开始，0,1,2,3,4.。。。到长度减1。
	数组的下标不能超出这个范围。否则就会下标越界：java.lang.ArrayIndexOutOfBoundsException
*/

2.2 数组的长度

获取数组元素的个数：之前我们知道在访问数组的时候，可以通过下标进行访问，但是如果下标越界就会产生异常。在Java中，所有数组都提供了一个length属性，通过这个属性可以访问到数组的长度或者数组中元素的个数。

代码实现：

		//4.获取数组中的元素个数或者数组的长度
		//格式:数组名称.length;
		int len = arr1.length;
		System.out.println("数组arr1的长度为：" + len);

运行结果：

shuzu4

2.3 遍历数组

既然可以通过数组的下标进行访问数组，而下标又是从0开始，逐渐递增1的有规律的一组数值。那么我们是否可以通过循环来进行访问数组？

依次访问数组中的每一个元素，获取每个下标对应的元素值
方式一：简单for循环
方式二：增强for循环

普通循环

1、遍历：依次访问数组中每个元素。可以赋值，可以取值。
2、因为操作数组，就是数组名字配合下标，而下标固定都是从0开始，到长度减1。
for(int i = 0;i < arr2.length;i++){
	System.out.println(arr2[i]);
}

for-each循环

for-each循环：【扩展】
增强for循环：JDK1.5的版本出现的。
特定的用法：专门用于获取数组中的每一个元素的值。
语法结构：
for(数据类型 变量名 : 数组名){
    System.out.println(变量名);
}
工作原理：
for(int e :arr){
    System.out.println(e);
}
int e，定义变量e，
	依次获取数组的元素，赋值给e
注意点：
    A：for-each只能获取数组的数据，但是不能给数组进行赋值
    B：for-each，在代码这个层面，不能操作下标。

代码实现：

public class Demo54Array 
{
	public static void main(String[] args) 
	{
		//1.定义数组
		int [] arr = {1,3,5,7,9};

		//2.遍历数组
		int n0 = arr[0];
		int n1 = arr[1];
		int n2 = arr[2];
		int n3 = arr[3];
		int n4 = arr[4];


		//3.简单for循环
		//i表示下标，0~arr.length
		for(int i = 0;i < arr.length;i++) {
			int n = arr[i];
			System.out.println(n);
		}

		/*
		4.增强for循环【foreach】
		JDK1.5之后新增的
		优点：用于遍历数组和集合，无需通过数组下标，就可以直接访问数组或者集合中的元素
		语法：
		for(元素数据类型 变量名：数组名称) {
			System.out.println(变量名);
		}
		*/
		//底层工作原理：根据下标获取数组元素
		for(int num : arr) {
			System.out.println("增强for循环的结果：" + num);
		}

		/*
		两种遍历方式的选择：不需要知道下标，只需要获取元素值，则采用增强for循环
		*/

		//需求：打印下标为偶数的元素值【只能采用简单for循环】
		for(int i = 0;i < arr.length; i++) {
			arr[i] = i*2;
		}
		for(int i =0;i < arr.length; i++){
			System.out.print(arr[i]+"\t");
		}
		System.out.println();
	}
}

运行结果：

shuzu5

三、数组的内存分析

3.1 内存

内存：存储数据
A：栈，存放的是基本数据类型的变量，以及引用类型变量的引用。
	特点：函数中的变量所占用的空间，执行之后就会销毁。
B：堆，存放的是new出来的东西。
	特点：执行之后，堆里存储的内容(对象等)，会被标记为垃圾，但是不会立即被销毁，而是等待系统的垃圾回收机制来回收(GC)。
	JVM,GC(Grabage Collection)

数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存空间，只有当这个引用指向有效的空间时，才可以通过引用去操作真正数组中的元素

结论：数组的引用变量存储在栈空间中，而真正的数组存储在堆空间在中。

数组的内存： shuzu11

内存分析：

7数组的内存图

代码实现：

class Demo55Array 
{
	public static void main(String[] args) 
	{
		//使用静态初始化的方式初始化一个数组a
		int[] a = {5,7,20};
		System.out.println("a的长度为：" + a.length);//3

		//使用动态初始化的方式初始化一个数组b
		int[] b = new int[4];
		System.out.println("b的长度为：" + b.length);//4

		b = a;
		System.out.println("a的长度为：" + a.length);//3
		System.out.println("b的长度为：" + b.length);//3 

		String[] arr = new String[3];
	}
}

运行结果：

shzu6

画图分析：

内存中的数组一

扩展：基本数据类型和引用数据类型在内存中的区别
思考问题：
	int a = 10;
	int b = a;
	b = 20;
	a = ? -------->10,而且a和b都存储在栈空间中

	int[] x = {22,33};
	int[] y = x;
	y[0] = 55;
	x[0] = ?--------->55,x和y都存储在栈空间中，但是真正的数组存储在堆空间中

扩展：内存的分类
	a.寄存器：最快的存储区域，由编译器根据需求进行自动的分配，我们在程序中无法控制
	b.栈：存放的是基本数据类型的变量以及引用数据类型变量的引用
		特点：被执行之后，该函数或者变量所占用的空间会被销毁【方法压栈】
	c.堆：存放所有使用new关键字创建出来的实体
		特点:执行完不会立即被释放，当使用完成之后，会被标记上垃圾的标识，等待系统的垃圾回收机制来回收它
	d.方法区：
		常量池：存放基本数据类型的常量和字符串常量
		静态域：static，静态全局变量

3.2 数组的地址转移：了解

Java中的数据分为两大类：
基本类型：4类8种
	操作的都是数值本身
引用类型：数组
	操作的是地址

基本类型进行赋值：数值
引用类型进行赋值：地址

示例代码：

public class Demo56Array
{
	public static void main(String[] args) 
	{
		/*
		数组：引用类型的数据
			数组名，存储是引用地址。
		*/

		int[] a = new int[3];
		System.out.println(a.length);//3
		System.out.println(a);//a数组的地址
		System.out.println(a[0]);//0

		a[0] = 1;
		a[1] = 2;
		a[2] = 3;

		int[] b = {4,5,6,7};
		System.out.println(b.length);//4
		System.out.println(b);//b的地址
		System.out.println(b[0]);//4

		int[] c = a;//将a的值赋值给c，就是将a存储的数组的地址赋值给c。a和c存储的地址相同，那么就指向了同一个数组
		System.out.println(c.length);//3
		System.out.println(c);//a的地址
		System.out.println(c[0]);//1

		c[0] = 100;
		System.out.println(a[0]);
		System.out.println(b[0]);
		System.out.println(c[0]);


		b = c;

		b[1] = 200;
		System.out.println(a[1]);//200
		System.out.println(b[1]);//200
		System.out.println(c[1]);//200

		System.out.println("Hello World!");
	}
}

运行结果：

shzu6

内存分析：

3内存分析

3.3 数组作为参数

数组是引用类型：参数传递的时候，传递的是数组的地址。就是参数也会指向这块内存。当方法结束的时候，参数就销毁了。

public class Demo57ArrayMethod
{

	//设计一个方法，用于打印数组
	public static void printArray(int[] arr){//int[] arr = a;a的地址给了arr，那么arr和 a指向同一块内存的数组
		for(int e : arr){
			System.out.print(e +"\t");
		}
		System.out.println();
	}

	public static void main(String[] args) 
	{

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

		//设计一个方法，用于打印数组
		printArray(a);//将a的地址，传递给arr
		System.out.println("Hello World!");
	}
}

运行结果：

shuzu8

内存分析：

3.4 数组作为返回值

一个数组可以作为参数，也可以作为返回值。那么返回的实际上是数组的内存地址。

示例代码：

public class Demo57ArrayMethod
{

	//设计一个方法，用于打印数组
	public static void printArray(int[] arr){//int[] arr = a;a的地址给了arr，那么arr和 a指向同一块内存的数组
		for(int e : arr){
			System.out.print(e +"\t");
		}
		System.out.println();
	}

	//设计一个方法，用于创建一个数组， 并赋值。数组要返回给调用处
	public static int[] createArray(int len){
		int[] arr = new int[len];
		for(int i = 0;i <arr.length;i++){
			arr[i] = i * 2;
		}
		return arr;
	}
	public static void main(String[] args) 
	{

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

		//设计一个方法，用于打印数组
		printArray(a);//将a的地址，传递给arr
		System.out.println("Hello World!");

		int [] b = createArray(10);

		for(int i =0;i<b.length;i++){
			System.out.println(b[i]);
		}
	}
}

运行结果：

shuzu10

内存分析：

fanhuizhi

3.5 可变参数【扩展】

概念：一个方法可以接收的参数的数量不定(0-多个)，但是类型固定。

语法：数据类型 ... 参数名，可变参数在方法中当数组使用。
	例如：int... num
	
注意事项：
	1、如果参数列表中，除了可变参数还有其他的参数，可变参数要写在整个参数列表的最后。
  2、一个方法最多只能有一个可变参数。

代码实现：

//演示不定长参数的使用
public class Demo58
{
	public static void main(String[] args) 
	{
		int result = add(2,5,65,76,87,98,9);
		System.out.println(result);

		//2.对于一个方法的参数是不定长参数时，实参可以直接传一个数组
		int[] arr = {2,5,65,76,87,98,9};
		System.out.println(add(arr));//num = arr;

		test(10,"hello",1,545,656);
		//test(1,545,656,"hello");
	}

	//需求：计算不确定个整数的和
	public static int add(int... num) {
		//1.不定长的参数在进行使用的时候被当做数组来进行处理
		//num其实就相当于一个数组的引用变量
		int sum = 0;
		for(int n :num) {
			sum += n;
		}

		return sum;
	}

	//3.不定长参数在使用的时候，必须出现在参数列表的最后一个
	//4.在同一个参数列表中，不定长参数只能出现一次
	public static void test(int num1,String s,int... num) {
	}
}

注意：

a.不定长的参数在进行使用的时候被当做数组来进行处理
b.不定长参数在使用的时候，必须出现在参数列表的最后一个
c.对于一个方法的参数是不定长参数时，实参可以直接传一个数组

四、数组的排序

排序：数组是存储一组数据，而且这些数据是有顺序的。但是数值本身可能是无序的。通过算法来实现给数组进行排序，升序(数值从小到大)，降序(数值从大到小)。

4.1 冒泡排序

冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下：

比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡排序的分析：

交换过程图示(第一次)：

maopaopaixu

那么我们需要进行n-1次冒泡过程。

示例代码：

public class Demo59ArrayBubbleSort
{
	public static void main(String[] args) 
	{
		int[] arr = {54,26,93,17,77,31,44,55,20};
		//以升序为例
		//外层循环：控制比较的轮数
		for(int i = 0;i < arr.length - 1;i++) {
			//内层循环：控制每一轮比较的次数和参与比较的下标
			for(int j = 0;j < arr.length - 1 - i;j++) {
				if(arr[j] > arr[j + 1]) {
					//交换位置
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}

		for(int num:arr) {
			System.out.print(num + "\t");
		}
		System.out.println();
	}
}

运行结果：

shuzu12

效果：

maopao2

4.2 选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

排序过程：

xuanze1

那么我们需要进行n-1次冒泡过程。

示例代码：

class Demo60ArraySelectionSort
{
	public static void main(String[] args) 
	{
		int[] arr = {54,26,93,17,77,31,44,55,20};

		for (int i= 0;i < arr.length - 1;i++){
			//用于标记最小值的下标
			int minIndex = i;

			for(int j = i + 1; j < arr.length; j++){
				//记录最小值的下标
				if(arr[minIndex] > arr[j]){
					minIndex = j;
				}
			}
			if (minIndex != i){
				//交换
				int temp = arr[minIndex];
				arr[minIndex] = arr[i];
				arr[i] = temp;
			}

		}

		for(int num:arr) {
			System.out.print(num + "\t");
		}
		System.out.println();
	}
}

运行结果：

shuzu13

效果：

xuanze2

五、数组的查找

数组的查找，就是指在给定的一个数组中，查找指定的数值，返回该数值在数组中的下标位置。但如果数组中包含重复的元素，不保证找到的是哪一个，如果数组中没有指定的元素，一般返回-1。

5.1 顺序查找

查找思路：遍历这个数组，依次把每一位元素和要查找的数据进行比较

代码实现：

class Demo61Search
{
	/*
	*顺序查找，在数组arr中，查找key的位置，如果存在返回下标，否则返回-1
	*/
	public static int orderSearch(int[] arr,int key){
		for(int i = 0;i < arr.length;i++) {
			if(key == arr[i]) {
				return i;
			}
		}
		return -1;
	}
	public static void main(String[] args) 
	{
		int[] arr = {23,54,65,3,5,2,87};

		//需求：查找65在数组中的位置
		int key = 65;

		int result = orderSearch(arr,key);

		System.out.println(result);
		
	}
}

运行结果：

shuzu14

5.2 二分法查找

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查数组为有序的数组，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列数组。首先，假设数组中元素是按升序排列，将数组中间位置记录的元素与要查找的数值比较，如果两者相等，则查找成功；否则利用中间位置记录将数组分成前、后两个部分，如果中间位置记录的元素值大于查找的数值，则进一步查找前一部分数组，否则进一步查找后一八月份数组。重复以上过程，直到找到满足条件的记录，使查找成功，或直到部分数组不存在为止，此时查找不成功。

优点：通过折半来缩小查找范围，提高查找效率

缺点：要求数组是有序的。

画图分析：

search2

代码实现：

import java.util.Arrays;
public class Demo62Search 
{
	/*
	* 二分查找
	*/
	public static int binarySearch(int[] arr,int key){
		//相应的下标
		int left = 0;
		int right = arr.length - 1;

		while(left <= right) {
			//中间下标
			int middle = (left + right) / 2;//取整
			if(arr[middle] > key) {
				//下次在左半部分查找
				right = middle - 1;
			} else if(arr[middle] < key) {
				//下次在右半部分查找
				left = middle + 1;
			} else {
				return middle;
			}
		}
		return -1;
	}

	public static void main(String[] args) 
	{
		int[] arr = {1,3,4,6,7,8,10,13,14};

		//待查找的元素
		int key = 13;

		int result = binarySearch2(arr,key);

		System.out.println(result);
		
	}
}

运行结果：

shuzu15

六、Arrays工具类

Arrays类是jdk提供的操作数组的一个工具类，位于java.util包下。

作用：主要用于对数组进行排序，查找，填充，比较等的操作
Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays;

注意1：如果在同一个Java文件中同时使用Scanner和Arrays，则可以向如下方式导包：
	  import java.util.Scanner;
    import java.util.Arrays;

	  或者简写为：
      import java.util.*;

注意2：但凡是工具类，类中的方法全部是静态的，方便调用
	  调用语法：类名.方法名（实参列表）

JDK提供好的类：
    A：Scanner，读取键盘
    B：String，字符串
    C：Math，数学的
    D：Arrays，提供数组的常规操作的
    E：System，

代码实现：

//演示Arrays工具类的使用
import java.util.*;
class Demo63Arrays 
{
	public static void main(String[] args) 
	{
		//使用动态初始化的方式初始化一个数组
		int[] arr = new int[10];
		
		//1.填充
		/*
		static void fill(int[] a, int val) 
          将指定的 int 值分配给指定 int 型数组的每个元素。 
		static void fill(int[] a, int fromIndex, int toIndex, int val) 
          将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。 

		*/
		/*
		for(int n:arr) {
			System.out.print(n);
		}
		*/
		//Arrays.fill(arr,10);

		//Java但凡涉及到区间问题，一般规律：包头不包尾   前闭后开区间
		Arrays.fill(arr,2,6,56);//0~arr.length - 1


		//2.排序
		/*
		static void sort(int[] a) 
          对指定的 int 型数组按数字升序进行排序。 
		static void sort(int[] a, int fromIndex, int toIndex) 
          对指定 int 型数组的指定范围按数字升序进行排序。 
		*/
		//注意：默认情况下只能进行升序排序
		int[] arr1 = {43,2,65,1,45,9898,989};
		Arrays.sort(arr1);
		//Arrays.sort(arr1,2,5);//[2,5)

		//3.二分法查找
		//前提：必须是排好序的数组
		/*
		static int binarySearch(int[] a, int key) 
          使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。 
		static int binarySearch(int[] a, int fromIndex, int toIndex, int key) 
          使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。 
		*/
		/*
		1
		2
		43
		45
		65
		989
		9898
		*/
		int key = 45;
		int result1 = Arrays.binarySearch(arr1,key);
		System.out.println(result1);//3

		int result2 = Arrays.binarySearch(arr1,20);
		//规律：按照原来的顺序将待查找的元素插入到原数组中的下标，对下标加1然后求相反数
		System.out.println(result2);


		//4.拷贝
		/*
		static int[] copyOf(int[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。 
		static int[] copyOfRange(int[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。 
		*/
		int[] newArr1 = Arrays.copyOf(arr1,3);

		int[] newArr2 = Arrays.copyOfRange(arr1,2,6);

		//5.将数组转换为字符串
		System.out.println(arr1);//[I@15db9742

		/*
		static String toString(int[] a) 
          返回指定数组内容的字符串表示形式。 
		*/
		System.out.println(Arrays.toString(arr1));//[1, 2, 43, 45, 65, 989, 9898]

		//6.比较数组
		/*
		static boolean equals(int[] a, int[] a2) 
          如果两个指定的 int 型数组彼此相等，则返回 true。 
		*/
		/*
		如果两个指定的 int 型数组彼此相等，则返回 true。
		如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。
		换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。
		此外，如果两个数组引用都为 null，则认为它们是相等的
		*/
		int[] array1 = {1,54,76};
		int[] array2 = {1,54,76};
		System.out.println(Arrays.equals(array1,array2));//true
		System.out.println(array1 == array2);//false

		/*
		总结：
		==和equals
		==：是一个运算符，可以比较基本数据类型和引用数据类型【当比较引用数据类型的时候，比较的地址值】
			比较String类型的变量，采用equals   
			String str1 = "";
			String str2 = "";
			比较方式：str1.equals(str2);
		equals：是一个方法，只能比较引用数据类型
		【补充：如果equals方法在一个类中没有没重新实现，则equals方法的作用和==一样，都比较的是地址值
		如果equals方法在一个类中被重新实现，则比较的是内容
		】
		*/

		for(int n:newArr1) {
			System.out.println(n);
		}
	}
}

运行结果：

shuzu16

**数组的拷贝：**就是将一个数组的数据，复制到另一个数值中。

方法一：通过循环，依次复制，将原数组的数据，一个一个，复制到目标数组中
方法二：Arrays类里方法：copyOf(原数组，新数组的长度)-->返回值是新数组
方法三：System类里的方法：arraycopy(原数组，原数组位置，新数组，新数组位置，拷贝的个数)

示例代码：

import java.util.Arrays;

public class Demo64ArrayCopy {

	public static void main(String[] args) {
		int[] a = {1,2,3};
		
		int[] b = new int[10];
		//数组的拷贝：
		//方法一：自己通过循环依次复制，吭哧吭哧
		for(int i=0;i<a.length;i++){
			b[i] =a[i];
		}
		
		for(int e :b){
			System.out.println(e);
		}
		System.out.println("---------");
		
		//方法二：借助于Arrays类
		/*
		 * copyOf(int[] 原始数组，int 新数组的长度)
		 * 返回值就是新的数组
		 * 
		 */
		int[] c = Arrays.copyOf(a, 5);//int[] c = {1,2,3,0,0}
		for(int e:c){
			System.out.println(e);
		}
		
		
		System.out.println("--------");
		//方法三：借助于System类
		/*
		 * arraycopy(src, srcPos, dest, destPos, length)
		 * 第一个参数：原始数组
		 * 第二个参数：从原始数组的哪个下标开始复制
		 * 第三个参数：目标数组
		 * 第四个参数：目标数组从哪个下标开始贴
		 * 第五个参数：拷贝几个数据
		 */
		//int[] a = {1,2,3};
		int [] d = new int[10];
		System.arraycopy(a, 1, d, 5, 2);
		for(int e:d){
			System.out.print(e+"\t");
		}
		
	}

}

运行结果：

shuzu17

七、使用数组时常见的问题

1>数组越界异常：ArrayIndexOutofBoundsException

		出现的时机：当使用了不存在的下标时，则会出现这个错误
		0~length - 1

2>空指针异常：NullPointerException
		出现的时机：当数组的引用变量赋值为null，还在后面的代码中使用这个引用

3>基本数据类型和引用数据类型打印的区别

代码实现：

public class  Demo65Array
{
	public static void main(String[] args) 
	{
		//1.数组越界
		int[] arr1 = new int[]{2,65,76,83,32,5,5};
		/*
		Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 8
        at Demo65Array.main(Demo65Array.java:6)
		*/
		//System.out.println(arr1[8]);

		//2.空指针异常
		System.out.println(arr1[3]);
		//arr1 = null;
		/*
		Exception in thread "main" java.lang.NullPointerException
        at Demo65Array.main(Demo65Array.java:20)
		*/
		//System.out.println(arr1[3]);

		//3.基本数据类型和引用数据类型打印的区别
		int x = 4;
		System.out.println(x);//4
		System.out.println(arr1);//[I@15db9742

		/*
		打印引用数据类型的引用变量时，拿到的是地址

		[I@15db9742

		[ ----- 数组
		I ----- int【Integer】
		@ ------ 地址
		15db9742 ----- 十六进制，地址值的哈希编码【哈希算法】

		打印：
		基本数据类型：数值
		引用数据类型：地址值
		*/

		float[] arr2 = new float[10];
		System.out.println(arr2);//[F@6d06d69c

		String[] arr3 = new String[10];
		System.out.println(arr3);//[Ljava.lang.String;@7852e922
	}
}

八、二维数组

Java并没有真正的多维数组，二维数组可以看成以数组为元素的数组。如：

int  a = { {1}, {4,5,6}, {7,8}};

erwei

动态初始化

动态初始化：

	语法：元素类型[][] 数组名称 = new 元素类型[二维数组的长度][一维数组的长度]
	举例：int[][] arr = new int[3][4];
	说明：定义一个数组arr，二维数组中一维数组的个数为3个，每个一维数组中元素的个数为4个

    
    int[][]  a = new int[4][5];

		int[][]  b = new int[3][];
		b[0] = new int[2];
		b[1] = new int[3];
		b[2] = new int[5];

静态初始化：

	静态初始化：

	语法：元素类型[][] 数组名称 = new 元素类型[][]{{一维数组1,一维数组2,一维数组3....};
	简化：元素类型[][] 数组名称 =m{{一维数组1,一维数组2,一维数组3....};

	举例：
    int[][] arr = new int[][]{{2,3},{5,2,1},{10,45,22,54}};
	      
		int[][]  c = {{1,2},{2,3},{3,4,5}};

		int[3][2] d = {{1,2},{2,3},{4,5}}; //非法的

示例代码：

class Demo67Array 
{
	public static void main(String[] args) 
	{
		int[][] arr = new int[3][4];
		
		System.out.println(arr);//二维数组的地址：[[I@15db9742
		System.out.println(arr.length);//二维数组的长度：3
		System.out.println(arr[0]);//二维数组中第一个一维数组：[I@6d06d69c
		System.out.println(arr[0].length);//第一个一维数组的长度：4
		System.out.println(Arrays.toString(arr));//[[I@6d06d69c, [I@7852e922, [I@4e25154f]
		System.out.println(Arrays.toString(arr[0]));//[0, 0, 0, 0]

		/*
		[[I@15db9742
		3
		[I@6d06d69c
		4
		[[I@6d06d69c, [I@7852e922, [I@4e25154f]
		[0, 0, 0, 0]
		*/
	}
}

示例代码：

class Demo66Array 
{
	public static void main(String[] args) 
	{
		//1.定义二维数组
        int [][] a = { {1,2}, {2,3,4,5}, {5,6,7}};
		for(int i = 0; i < a.length; i++) {   
            for(int j = 0; j < a[i].length; j++) {
                System.out.println("a["+ j + "][" + j + "]=" + a[i][j] + ", ");
            }
            System.out.println();
        }
    }
}

运行结果：

erweishuzu