Java基础学习第六讲：数组

数组

一、数组概述

1、什么是数组？

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。

2、数组的特点

• 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
• 其元素必须是相同类型，不允许出现混合类型。元素的类型可以是java 支持的任意类型。
• 数组类型可以是任何数据类型，包括基本类型和引用类型。
• 数组的元素在堆内存中被分配空间，并且是连续分配的
• 使用new 关键字对数组进行 内存的分配。每个元素都会被jvm 赋予默认值。默认规则：整数：0 浮点数：0.0 字符：\u0000 布尔：false 引用数据类型：null。
• 数组的元素都是有序号的，序号从0开始，0序的。称作数组的下标、索引、角标。

3、数组的声明

• 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
• 声明一个数组的时候并没有数组真正被创建。
• 构造一个数组，必须指定长度。

4、数组的格式
元素类型[ ] 数组名 = new 元素类型 [元素个数或数组长度]
元素类型 数组名[ ] = new 元素类型 [元素个数或数组长度]

int[] intArray=new int[4];

int intArrays[]=new int[4];

• 元素类型：是指数组存储的数据的数据类型
• []：代表这是数组类型。
• 数组名：一个合法的标识符，命名规范 和 局部变量 规范一致。
• new：是java 的关键字。用来向JVM申请内存的。
• 元素类型[元素个数] ：决定了向JVM申请的内存空间的大小（大小：元素类型字节数 * 元素个数）
• 元素的个数：只要是一个合法的java 表达式就可以。 返回一个int 类型的值即可
  
  5、数组的创建
• 声明数组时，给出了数组的初始值，这种创建方法叫做创建静态数组

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

String[] strArray= {"Java","C","C++",".NET"};

• 声明数组时，没有给出数组的初始值，但是指定了数组的长度，这种创建方法叫做创建动态数组。可以通过数组下标找到数组元素，给指定的元素赋值

		int intArrays[]=new int[4];
		intArrays[0]=1;
		intArrays[1]=2;
		intArrays[2]=3;
		intArrays[3]=4;

6、二维数组
二维数组其实是一位数组的嵌套（每一行看做一个内层的一维数组）
示例：

int[][] arr = {{1, 2}, {3, 4}, {5, 6}};//创建静态二维数组

int[][] arr1 = new int[3][2];//创建动态二维数组
arr1[0] = new int[]{1, 2};
arr1[1] = new int[]{3, 4};
arr1[2] = new int[]{5, 6};

7、数组的注意事项

• 数组下标必须是int、short、byte，或是char
• 数组下标从0开始计数
• 元素的个数就是数组的长度，可以通过arrayName.length引用
• 数组下标最大值为arrayName.length -1如果超过最大值，程序将会抛出数组下标越界异常（ArrayIndexOutOfBoundsException）

8、数组的优缺点

优点：

• 可以保存若干个数据。
• 随机访问的效率很高。根据下标访问元素效率高（元素连续分配空间）。

缺点：

• 数组的元素的类型必须一致。元素类型必须一致。
• 连续分配空间在堆中，如果数组的元素很多，对内存的要求更加的严格。
• 根据内容查找元素效率比较低，需要逐个比较。
• 删除元素、插入元素效率比较低，需要移动大量的元素。
• 数组定长，不能自动扩容。
• 数组没有封装，数组对象只提供了一个数组长度的属性，但是没有提供方法用来操作元素。

二、数组的应用

1、求数组中最大值

int arr[] = {1, 8, 7, 4, 5, 9};
int k = arr[0];
for(int i=0; i<arr.length; i++){
	if(arr[i]>k){
		k = arr[i];
	}
}
System.out.println(k);

2、求数组中的最小值

int arr[] = {1, 2, 7, 4, 0, 9};
int k = arr[0];
for(int i=0; i<arr.length; i++){
	if(arr[i]<k){
		k = arr[i];
	}
}
System.out.println(k);

3、数组排序

		 int[] a={1,4,-1,5,0};
         Arrays.sort(a);//数组a[]的内容变为{-1,0,1,4,5}
         for(int i=0;i<a.length;i++){
            System.out.print(a[i]+"  ");
         }

4、数组成员10个,找出数组中最大数连同位置一起输出

		    int[] n = new int[]{1, 2, 3, 4, 5, 6, 0};
		    int max = n[0];
		    int index=0;
		    for (int i = 0; i < n.length;i++){
		      if(max<n[i]){
		        max=n[i];
		        index=i;
		      }
		    }
		    System.out.println("最大值是："+max);
		    System.out.println("最大值位置是："+index);

5、冒泡排序
冒泡排序就是重复的遍历要排序的数列，每次比较相邻的两个元素，如果他们的顺序不满足排序条件就把他们交换过来。遍历数列的工作是重复地进行直到不再需要交换（排序已完成）。
算法原理：（比如从小到大排）

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

//冒泡排序法
int arr[] = {1, 9, 7, 4, 0};
for(int i=0; i<arr.length-1;i++){
	for(int j=0; j<arr.length-i-1;j++){
		if(arr[j]>arr[j+1]){
			int temp = arr[j+1];
			arr[j+1] = arr[j];
			arr[j] = temp;
		}
	}
}
//以下代码是将数组中的所有元素输出到控制台
for(int i=0; i<arr.length; i++){
	System.out.println(arr[i]);
}

三、数组扩容

方法一：定义一个新数组，将原数组内容放到新数组中，然后将新数组赋值给原数组，从而实现数组扩容。

		//定义原数组
		int[] a={1,2,3,4,5};
		
		//定义新数组
		int[] b=new int[a.length*2];
		
		//循环获取原数组内容并赋值给新数组
		for (int i = 0; i < a.length; i++) {
			b[i]=a[i];
		}
		
		//将新数组赋值给原数组
		a=b;
		
		//展示原数组
		System.out.println(Arrays.toString(a));

输出结果为：

		[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

方法二：使用Arrays类中的copyof()方法进行扩容

		//定义原数组
		int[] a={1,2,3,4,5};
		
		//使用Arrays类中的copyof()方法进行扩容
		a=Arrays.copyOf(a, a.length*2);
		
		//展示原数组
		System.out.println(Arrays.toString(a));

输出结果为：

		[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

方法三：使用System类中arraycopy()方法进行扩容

		//定义原数组
		int[] a={1,2,3,4,5};
		
		//定义新数组
		int[] b=new int[a.length*2];
		
		/*
		 * arraycopy()方法本质是循环遍历a数组，并将a数组中的内容放到b数组中
		 * src:旧数组(在本例中为数组对象a)
		 * srcPos：从旧数组的哪个下标开始(在本例中为数组对象a的起始位置)
		 * dest:新的数组(在本例中为数组对象b)
		 * destPos: 从新的数组哪个下标开始接收数据(在本例中为数组对象b的起始位置)
		 * length: 要复制的长度为多少(在本例中为数组对象a的长度)
		 * */
		System.arraycopy(a, 0, b, 0, a.length);;
		
		//将新数组赋值给原数组
		a=b;
		
		//展示原数组
		System.out.println(Arrays.toString(a));

输出结果为：

		[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

注：三个方法中，最简单的为第一个方法，将数组进行替换和增加容量，并且使用循环来完成，个人推荐第二种方法，使用数组工具类Arrays中的copyof()方法来完成数据的扩容。不推荐第一种和第三种方法，因为这两种方法需要一个新的数组，且将新的数组的地址重新再赋给旧数组，这样一来不仅麻烦，而且繁琐。