第六天

数组

1. 什么是数组？

顾名思义，即为数据的组合或集合，数组就是用来表示一组数据的。

2. 数组的特点：

（1）数组是用来存储一组相同数据类型的数据结构。

（2）数组中的元素可以是任何数据类型(基本类型和引用类型)。

（3）数组有一个对应的索引，可以通过索引访问数组中的每个元素。（0 –-- n-1）

（4）数组被创建好之后，它的大小（数组长度）是不能改变的，但是数组中的各个元素是可以被改变的。

（5）数组变量属于引用数据类型。//所有的任何数组都是继承了Object

int[]  a ;  a是引用数据类型（关于引用数据类型的细节，面向对象部分再来补充说明） 

3. 掌握数组的基本用法（声明+空间申请+初始化的细节）

3.1. 一维数组的声明

一维数组声明有两种方式：

   数据类型 变量名= 变量值

数据类型[]  数组变量名;（推荐）

数据类型 数组变量名[]; 

注意：声明数组时不能指定数组长度。例如下面写法是错误的。

int[5]  array;//语法错误，编译不通过。

int[] array;//正确写法

3.2. 一维数组的创建

一维数组的创建，采用new来申请内存空间

Java中使用关键字new创建数组对象，指定数组的大小，给数组元素的存储分配空间

格式：数组变量名 = new 数组元素的类型 [数组元素的个数];

    array = new int[5];

例如：

int[] a;  //声明一个int类型的数组

a = new int[5];  //创建一个int类型的数组，长度为5（存储5个int整数的数组）,并让变量a指向该数组;

3.3. 一维数组的赋值

静态初始化是指，在创建数组对象的同时对数组进行初始化。

静态初始化有两种方式：

1、int[] a = new int[]{1, 2, 3};  //定义并创建数组，并初始化数组的元素为1、2、3，同时数组的长度也被限定为为3。

2、int[] a = {1, 2, 3};   //效果同上

注意：不能这么写 int[] a = new int[3]{1,2,3};

以上两种方式均不需要定义数组的长度，数组的长度由初始化时元素的个数来决定。

 

动态初始化是指把数组的创建和数组的初始化分开完成。

例如：

int[] a = new int[3];  

a[0] = 3;  //通过元素索引(下标)来给数组元素赋值

a[1]=4;

a[2]=5;

问题：动态赋值和静态赋值怎么选择？

3.4. 访问数组的元素

通过下标访问数组元素，上述案例已经有了，注意一点：数组的下标从0开始以及数组的边界问题

3.5. 一维数组的遍历

需掌握两种方式，并知道他们的区别

1，采用最初学习for循环方式，这种方式可以打印出数组的元素

2，采用一种新的循环遍历方式，增强for循环，这种方式只能输出数组元素，但访问不到下标

3.6. 练习1

声明一个数组，并向其存储“5,8,1,7,6,19,10,3”这几个数字，

l 分别采用静态和动态的方式进行数据的初始化

l 最后采用两种循环方式打印出数组的数据。

l 创建方法，用于打印数组的元素，方便后续调用

3.7. 练习2

开发一个随机抽取学员回答问题的程序

3.8. 总结

要求掌握的技能如下：

l 数组的声明及初始化

l 数组的遍历

l 数组的下标特点 

4. 算法阶段（查找+排序） 

4.1. 难点一：数组的查找

4.1.1. 顺序查找（简单）
应用场景：数组的元素是没有顺序的，挨个找
4.1.2. 二分法查找

应用场景：二分法查找的前提是数组已经排好序了

4.2. 求数组的最大数和最小数 

 求最大值

l 求最小值

public class Test5MaxMin{

public static void main(String[] args){

int[] nums = {1,5,6,11,88,33,99,10,2,-1,-9};

int max = nums[0];

for(int i=1;i<nums.length;i++){

if(max < nums[i]){

max = nums[i];

}

}

System.out.println(max);

//min

int min = nums[0];

for(int i=1;i<nums.length;i++){

if(min > nums[i]){

min = nums[i];

}

}

System.out.println(min);

}

}

 

4.3. 难点二：数组的排序

4.3.1. 冒泡排序（最重要） 5,8,1,7,6 ,3 ？？？？？8 ？？？？7，8 1,3,5,6,7,8 冒泡排序，就是每次比较，大的元素往后挪，比较完第一遍后，最大的元素排到了数组的最后一位 第二次比较，还是从第一个元素开始和后面的比较，把剩余的最大的元素拍到数组的倒数第二位，第一轮比较的最大元素不参与比较 依次类推。   总结：相邻两个元素两两比较，大的往后挪，第一次比较结束后，最大的元素在数组的最大索引处。   第一步： int[] source = {5,8,1,7,6 ,3 }; if(source[0]>source[1]){ int temp = source[0]; source[0]=source[1]; source[1]=temp; } if(source[1]>source[2]){ int temp = source[1]; source[1]=source[2]; source[2]=temp; } 第二步： 将上述代码变成一个循环结构          for(int i=0;i<=nums.length-2;i++){ if(nums[i] > nums[i+1]){ int temp = nums[i]; nums[i] = nums[i+1]; nums[i+1] = temp; } } 第三步：每一次都是在改变临界条件 for(int i=0;i<=source.length-2-0;i++){//-0是为了总结出后面的外层循环规律 if(source[i]>source[i+1]){ int temp = source[i]; source[i]=source[i+1]; source[i+1]=temp; } } 第四步：    再嵌套一层循环来改变这个值    for(int j=0;j<=source.length-2;j++){ for (int i = 0; i <= source.length - 2 - j; i++) { if (source[i] > source[i + 1]) { int temp = source[i]; source[i] = source[i + 1]; source[i + 1] = temp; } } }   4.3.2. 选择排序（选择一个位置来存放最小的元素） 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。   第一轮：        int k = 0; for(int i=1;i<=ints.length-1;i++){ if(ints[k]>ints[i]){ k = i; } } int temp = ints[0]; ints[0] = ints[k]; ints[k] = temp; 第二轮：      就是将k新增1，即从1开始        k = 1; for(int i=2;i<=ints.length-1;i++){ if(ints[k]>ints[i]){ k = i; } } temp = ints[1]; ints[1] = ints[k]; ints[k] = temp; 以此类推，所以通过外层循环来控制即可       for(int j=0;j<=ints.length-2;j++){ int k = j; for(int i=j+1;i<=ints.length-1;i++){ if(ints[k]>ints[i]){ k = i; } } if(k != j){        int temp = ints[j];        ints[j] = ints[k];        ints[k] = temp; } }

 

5. 扩展

l 可变参数 l 继续认识main方法--args l 数组专家Arrays

多维数组创建与遍历：

public class Test1Array{
	public static void main(String[] args){
		//预计要放3个一维数组
		int[][] aa = new int[3][];
		int[][] bb = new int[][]{{1,2,3},{4,5,6,7}};
		
		int[][] cc = {{11,12,13,14},{22,33,44,55},{66,77,88}};
		System.out.println(cc[0][2]);
		System.out.println(cc[2][2]);
		
		/*
			cc[0][0]=11
			cc[0][1]=12
			cc[0][2]=13
			cc[0][3]=14
		*/
		
		//外层遍历，遍历二维数组，得到每个一维数组
		for(int i=0;i<cc.length;i++){
			//cc[i]代表每个一维数组
			//遍历里面的每个一维数组
			for(int j=0;j<cc[i].length;j++){
				System.out.println("cc["+i+"]["+j+"]="+cc[i][j]);
			}
		}
		
		//增强for循环
		//int[] 二维数组里面放的是一维数组
		for(int[] ints : cc){
			for(int ii : ints){
				System.out.println(ii);
			}
		}
	}
}

 

6. 作业：

（1），数组的两种遍历方式，顺序查找，二分查找，求最大最小数，冒泡排序，选择排序，请独立敲两遍(加注释)。

（2），定义一个方法，用于得到数组的最大值和最小值，并将这两个结果进行返回

提示：返回的类型 int[]

ints[0] = max;

ints[1] = min;

return ints;

代码如下：

import java.util.Scanner; public class MaxMin{ public static int[] maxMin(int[] arr){ int max = arr[0]; int min = arr[0]; int[] ints = new int[2]; for(int i = 0;i<=arr.length-1;i++){ if(max < arr[i]){ max = arr[i]; } if(min > arr[i]){ min = arr[i]; } } ints[0] = max; ints[1] = min; return ints; } public static void main(String[] args){ int[] arr = new int[]{3,5,1,5,7,2,8,4,6}; System.out.println("最大值为："+maxMin(arr)[0]+"，最小值为："+maxMin(arr)[1]); } }