《第一阶段 java基础 Day05笔记》————————第五讲 数组

课程大纲	课程内容	学习效果	掌握目标
	数组概念	了解	了解数组概念
	数组定义和初始化	掌握	熟练掌握数组定义和初始化方式
数组	访问数组元素	掌握	熟练掌握数组元素的访问方式
	数组内存图	重点掌握	会画数组内存图
	数组排序	掌握	熟练掌握冒泡选择排序
	二维数组	了解	了解二维数组的定义和使用方式

一、引入和概念

需求

          现在需要统计班上每一个同学的名字，假设班上有30名同学，用前面所学的知识，首先需要声明30个变量来分别记录每一个同学的名字，这样做显然很麻烦，为了解决这类问题，Java就提供了数组供我们使。

数组特点

           数组就是存储多个数据类型一致的变量（元素）的容器。

           数组既可以存储基本数据类型，也可以存储引用数据类型。

为什么要使用数组

      ①没有数组：存在多个变量，需要声明多个变量的名称，这些名称之间没有什么关联，想访问所有的变量，比较困难。

      ②有了数组：只需要有一个数组容器的名称，容器里面有通过数字表示位置，同时这些数字位置有规律，结合数组名称，非常容易的去访问所有的变量。数字的位置可以称为索引，数组在内存中开辟了一块连续的存储空间。

                                      

 

 

 

二、定义和初始化

1、数组的定义格式

     格式1：数据类型[] 数组名；（推荐使用）   如：int [] nums;

    格式2：数据类型 数组名[];（是为了兼容C语言）如int nums[];

    【示例代码】

public static void main(String[] args) {
//数组的定义：   数据类型[] 数组名
     int[] aa; //定义了一个int类型的数组——这个数组中只能存放int类型的数据
     String[] ss; //定义了一个String[]数组——只能存放String类型的数据
     double[] dd;
     //另一种定义方法（不常用） 为了兼容C语言的写法
     int aaa[];
     String sss[];

     /*
     int x;
     System.out.println(x);  //变量定义完，不赋值，是不能使用的！！！
     */
}

   2.数组初始化

        所谓的初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素分配内存空间。

         【注意】：java中的数组必须先初始化才能使用。

   （1）动态初始化

        【格式】：元素数据类型[] 数组名 = new 元素数据类型[数组长度]；如int[] nums = new int[30];//数组长度其实就是数组中元素的个数

           详细的解释

                   1.元素的数据类型：数组中数据的类型，用于决定每个空间的大小。

                   2.元素：数组中的数据，数组中的变量。

                  3.[]:表示一个一维数组 [][]:二维数组

                 4. = ：赋值号，将数组的地址，赋值给数组名称

                 5.new:开辟内存空间

                6.数组长度/数组容器的大小：可以存储数据的个数。

 

        【注意】：数组长度指定之后不可以改变

        【举例】： int[] arr = new [3];//解释：定义了一个int类型的数组，这个数组可以存放3个int类型的值。

 【示例代码】

public static void main(String[] args) {
	// 数组长度指定后，不能改变
	int[] aa = new int[5];  // 初始化数组，并制定数组的长度为5（这个数组中最多可以存放5个int类型数据）
   aa[0] = 5;
	String[] ss = new String[10];
      System.out.println(arr);//[I@15db9742
}

（2）静态初始化    

 

     【格式】：数组类型[] 数组名 = new 数组类型[]{元素1,元素2,...};

                            如int[] nums = new int[]{1,2,3,4,5};或者简化为int[] nums = {1,2,3,4,5};

    【举例】int[] arr = new int[]{1,2,3};//解释：定义了一个int类型的数组，这个类型可以存放三个int类型的值，并且值分别是1,2,3；

   【注意】

           1.不要在第二个[方括号中，不要写数组的个数。初始化时不允许动静结合。

            2.元素值列表，如果多个元素，中间使用逗号分隔，写了几个元素，就分配多大的空间

           3.元素值列表中的元素类型要和定义的类型保持一致。

 

 【简化格式】：数组类型[] 数组名 = {元素1,元素2,...};

  【举例】：int[] arr = {1,2,3};

  【示例代码】

public static void main(String[] args) {
	int[] aa = new int[]{4,1,3,8,8,9}; // 创建了一个6个长度的数组，并完成了赋值
	String[] ss = new String[]{"aaa","bbb","ccc"};
    //不要动静结合
	//int[] arr2 = new int[3]{10,20,30};

	//元素值列表中的元素类型要和定义的类型保持一致。
	//int[] arr3 = new int[]{1.0,2.0};


	//简化格式	
	int[] aaa = {1,2,4,5,8,9};  //创建了一个6个长度的数组，并完成了赋值
	String[] sss = {"aaa","bbb","ccc"};	
}

   3.访问数组元素    

       【索引】：每一个存储到数组的元素，都会自动拥有一个编号，从0开始，这个自动编号称为数组索引（index）（下标），可以通过数组的索引访问到数组中的元素。

        【格式】：数组名[索引]

        【数组的长度属性】：每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度。                           语句为：数组名.length，属性length的执行结果是数组的长度,int 类型结果。

        【索引访问数组中的元素】：数组名[索引值] = 数值; 为数组中的元素赋值。                                                                                                                                                 变量名 = 数组名[索引值]；获取数组中的元素

                                             

  【示例代码】

public class Demo04_访问数组元素 {
	
	public static void main(String[] args) {
		/*
          默认值：
           byte   ----0
		   short  -----0
		   long --------0
		   int ---------- 0
		   double ---- 0.0
           char------- 空字符
		   String ----- null(空值) 
		 */
int[] aa = new int[5];  // 动态初始化的数组，没有给数组中赋值过，
//数组中的元素会使用相应类型的默认值
		int x = aa[0];  // 数组的第一个元素
		System.out.println(x);
		System.out.println(aa[1]);
		System.out.println(aa[2]);
		
		
		double[] dd = new double[5];
		System.out.println(dd[0]);
		System.out.println(dd[1]);
		/*
		char[] cc = new char[5];
		System.out.println(cc[0]);
		System.out.println(cc[1]);
		*/
		String[] ss = new String[5];
		System.out.println(ss[0]);
		System.out.println(ss[1]);		
	}
}	System.out.println(ss[1]);		
	}
}

【示例代码】

public class Demo05_访问数组元素2 {
	public static void main(String[] args) {
	   /*	
		int[] aa = new int[5];
		aa[0] = 1;  // 给数组赋值
		aa[1] = 3;
		aa[2] = 5;
		aa[3] = 7;
		aa[4] = 9;
        //aa[5] = 10
		*/
		int[] aa = {2,4,6,8,9};
		
		System.out.println(aa[2]);
		System.out.println(aa[3]);
		System.out.println(aa[4]);
		//System.out.println(aa[5]);  数组索引越界
	}
}

三、数组内存图

   1、概念

         内存是计算机中的重要元件，可以用来给程序临时存储数据。我们编写的程序，必须放进内存中才能运行，运行完毕后会清空内存。

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

2、Java的内存划分

 【 JVM的划分】

           为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

         ①JVM是执行java程序的容器，空间很大，需要划分不同的空间，不同的功能，需要使用不同的区域来指定完成。分为：【栈内存，方法区，堆内存】，本地方法区，程序计数器。

      ②栈内存【常用】：也叫方法栈，方法运行时使用的内存，比如main方法运行，进入方法栈中执行，用于执行方法，每个方法单独分配一段空间，称为栈帧，把给方法分配内存空间，形象的称为“进栈”。特点：先进后出。

       ③堆内存【常用】：用于存放数组、对象等数据量较大的数据，一般都是引用数据类型，new来创建的，都存储在堆内存。

      ④方法区【常用】：用于存储类的字节码对象，存储可以运行的class文件，存储常量（final修饰），存储静态变量。

       ⑤本地方法区：用于执行本地方。C语言，C++语言方法就是本地方法。

        ⑥程序计数器：用于控制程序的执行、控制程序执行到哪一行代码。

                             

 

 

 

 

3、数组在内存中的存储

  （1）一个数组的内存图

public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[I@5f150435
}

         [I@15db9742     以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在堆内存中的地址。

         [;表示一个一维数组。

         I:表示数组中存放的数据类型为int类型。

        15db9742：表示一个16进制的地址,表示数组中起始的内存地址值。数组名称arr可以存数组

          【注意】：new出来的内容，都是在堆内存中存储的，而方法中的变量arr保存的是数组的地址。

【程序执行流程】：                                                                                                                                                                                                       1，main方法进入方法栈执行                                                                                                                                                                                2，创建数组，JVM会在堆内存中开辟空间，存储数组                                                                                                                                   3.数组在内存中会有自己的内存地址，以十六进制数表示，0X1AB                                                                                                              4.数组中有3个元素，默认值是0                                                                                                                                                                            5.JVM将数组的内存地址复制给引用数据类型变量arr                                                                                                                                     6.变量arr保存的是数组内存中的地址，而不是一个具体的数值，因此称为引用数据类型

 

   （2）两个数组的内存图

public static void main(String[] args){
    int[] arr1 = {1,2,3};
    int[] arr2 = {13.,23,43};
    
    arr1 = arr2;
}

                                      

（3）两个变量指向一个数组

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
		int[] arr2 = arr;
		arr2[1] = 9;
		System.out.println(arr2[1]);//9
		System.out.println(arr[1]);//?9
	}

                 

四、数组常见错误

1、数组索引越界异常

每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错，如下所示： 

public static void main(String[] args) {
int[] arr = new int[4]; // 定义一个长度为4的数组
System.out.println("arr[4]=" + arr[4]); // 通过角标4访问数组元素
}

上面运行结果中所提示的错误信息是数组越界异常ArrayIndexOutOfBoundsException，出现这个异常的原因是数组的长度为4，其索引范围为0~3，而上述代码中的第4行代码使用索引4来访问元素时超出了数组的索引范围。

所谓异常指程序中出现的错误，它会报告出错的异常类型、出错的行号以及出错的原因。

2、空指针异常（80%）

 

五、数组的操作

   1、遍历数组

            ①遍历：一个个元素进行访问

            ②方式：通过循环，访问到数组中的所有的索引，通过索引，访问到对应的元素。

           ③索引：范围0~数组长度-1 长度：数组名称.length

  【示例代码】

/*
	遍历数组
*/
class TraverseArr {
	public static void main(String[] args) {
		//定义数组并初始化
		int[] arr = {16,12,88,6,38,42,66};
		//调用遍历方法
		traverse(arr);
	}
	/*
		定义遍历的方法
	*/
	public static void traverse(int[] arr){
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+" ");//一行输出,空格分隔
		}
		System.out.println();//换行
	}
}

   2、获取数组最值

       ①给定一个数组，求出数组的最大值。

        ②思路：擂台思想

                          

   【示例代码】

/*
数组的最值
*/
class GetArrMaxAndMin {
	public static void main(String[] args) {
		//定义数组并初始化
		int[] arr = {16,12,88,6,38,42,66};
		//调用方法
		int max = getMax(arr);
		System.out.println("max="+max);
		System.out.println("min="+getMin(arr));
	}
	//定义求最大值的方法
	public static int getMax(int[] arr){
		int max = arr[0];
		for(int i=0; i<arr.length; i++){
			max = max > arr[i] ? max : arr[i];
		}
		return max;
	}
	//定义求最小值的方法
	public static int getMin(int[] arr){
		int min = arr[0];
		for(int i=0; i<arr.length; i++){
			if(min > arr[i]){
				min = arr[i];
			}
		}
		return min;
	}
}

3.数组反转

①数组反转的操作：第一个元素与最后一个元素进行交换，第二个元素与倒数第二个元素进行交换，以此类推。

 思路一：

                 

 

           思路二

                         

  【示例代码】

/*
数组的反转
*/
class ReverseArray {
	public static void main(String[] args) {
		//数组的定义 初始化
		int[] arr = {2,1,10,5,3};
		//反转前遍历数组
		traverseArr(arr);
		//反转数组
		reverseArr(arr);
		//反转后遍历数组
		traverseArr(arr);

		reverseArray(arr);
		//反转后遍历数组
		traverseArr(arr);
	}

	/*
		定义方法:反转数组
	*/
	public static void reverseArr(int[] arr){
		for(int i=0,j=arr.length-1;i<j; i++,j--){
			swapArr(arr,i,j);
		}
	}

	public static void reverseArray(int[] arr){
		for(int i=0;i<arr.length/2;i++){
			swapArr(arr,i,arr.length-1-i);
		}
	}
	/*
		定义遍历的方法
	*/
	public static void traverseArr(int[] arr){
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+" ");//一行输出,空格分隔
		}
		System.out.println();//换行
	}
	/*
		定义交换数组元素的方法
	*/
	public static void swapArr(int[] arr,int i,int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

          

4、数组的查找

       ①给定一个数组，找到指定值的索引。

        ②遍历数组，判断每个元素是否与要找的元素值相等，如果相等，那么就返回当前元素的索引，如果没有找到，返回-1

【示例代码】

 

/*
查找数组元素
*/
import java.util.Scanner;
class FindElement_Array {
	public static void main(String[] args) {
		//数组的定义 初始化
		int[] arr = {2,1,10,5,3};
		//创建Scanner对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入要查找的数字:");
		int num = sc.nextInt();
		int index = 0;
		for(int i=0; i<arr.length-1; i++){
			/*
				查找到就把角标返回给index,并且中断循环不再继续向下查找
			*/
			if(num == arr[i]){
				index =i;
				break;
			}
			/*
				如果角标到了最后一个,任然没有查找到,就把-1赋值给index,代表找不到
			*/
			if(i == arr.length-1){
				index = -1;
			}
		}
		if(index == -1){
			System.out.println("该数字在数组中查找不到");
		}else{
			System.out.println("该数字在数组中的角标为:"+index);
		}
	}
}

5，排序

       

  ①选择排序

      

【示例代码】

//数组的选择排序:从小到大
class SelectSort_Array {
	public static void main(String[] args) {
		int[] arr = {1,23,4,33,53,21,66,32,88,66};
		//排序前 遍历
		traverseArr(arr);
		//选择排序
		selectSort(arr);
		//排序后 遍历
		traverseArr(arr);
	}
	//定义选择排序
	public static void selectSort(int[] arr){
		for(int i=0; i<arr.length;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					swapArr(arr,i,j);
				}
			}
		}
	}
	//定义遍历的方法
	public static void traverseArr(int[] arr){
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+" ");//一行输出,空格分隔
		}
		System.out.println();//换行
	}
	
	//数组中交换两个元素的值
	public static void swapArr(int[] arr,int i,int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

 

②冒泡排序

           

        

【示例代码】

//数组的冒泡排序:从小到大
class BubbleSort_Array {
	public static void main(String[] args) {
		int[] arr = {1,23,4,33,53,21,66,32,88,66};
		//排序前 遍历
		traverseArr(arr);
		//选择排序
		BubbleSort(arr);
		//排序后 遍历
		traverseArr(arr);
	}
	//定义选择排序
	public static void BubbleSort(int[] arr){
		for(int i=0; i<arr.length;i++){
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					swapArr(arr,j,j+1);
				}
			}
		}
	}
	//定义遍历的方法
	public static void traverseArr(int[] arr){
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+" ");//一行输出,空格分隔
		}
		System.out.println();//换行
	}
	
	//数组中交换两个元素的值
	public static void swapArr(int[] arr,int i,int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

 

六、二维数组（了解）

1、概念和定义

二维数组就是关于数组的数组。

int[][] a = new int[4][]; 的含义？

目前的对象中只有4个指针，准备指向4个数组。

              

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

a[0] = new int[3];

a[1] = new int[3];

a[2] = new int[3];

a[3] = new int[3];

可以简写为：

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

         

 

    1.二维数组：一维数组的嵌套，数组的每个元素，又是一个数组。

    2.定义格式：

      数据类型[][] 数组名 = new 数据类型[行的大小][列的大小]；

                            

3.创建了一个一维数组，每行的内容就是一维数组的内容。每行的内容又是一个数组。

 

                        

 

 

 

4.静态初始化

int[][] arr = {{1，2},{30}，{1，2，3，4}，null,{}}

5.动态初始化int[][] arr = new int[行的长度][]；

class Demo02 {
	public static void main(String[] args) {
		int[][] arr = new int[3][4];
		//打印地址
		System.out.println(arr);//[[I@15db9742
		System.out.println(arr[0]);//[I@6d06d69c
		System.out.println(arr[1]);//[I@7852e922
		System.out.println(arr[2]);//[I@4e25154f
		//打印值
		System.out.println(arr[0][1]);//0
		arr[0][1] = 5;
		System.out.println(arr[0][1]);//5

		int[][] arr2 = new int[3][];
		System.out.println(arr2);//[[I@70dea4e
		System.out.println(arr2[0]);//null
		int[] arr3 = {1,2,4,5};
		arr2[0] = arr3;//传地址
		System.out.println(arr2[0][2]);//4
	}
}

2、二维数组的遍历

遍历：嵌套循环，外层循环控制行，内存循环控制列

/*
二维数组的遍历
*/
class Demo03 {
	public static void main(String[] args) {
		int[][] arr = {{1,2},{30},{1,2,3,4},null,{}};
		for(int i=0;i<arr.length;i++){
			if(arr[i]!=null){
				for(int j=0;j<arr[i].length;j++){
					System.out.print(arr[i][j]+" ");
				}
				System.out.println();
			}
		}
	}
}

作业

1 复习本周内容

2.分别定义方法，求一个整数数组的最大值、最小值、平均值和所有数组元素的和（4个方法）

//2.分别定义方法，求一个整数数组的最大值、最小值、平均值和所有数组元素的和（4个方法）
class Homework02 {
	public static void main(String[] args) {
		int[] arr = {3,6,5,2,6,10};
		System.out.println("max="+getMax(arr));
		System.out.println("min="+getMin(arr));
		System.out.println("sum="+getSum(arr));
		System.out.println("avg="+getAvg(arr));
		
		
		
	}
	//定义最大值的方法
	public static int getMax(int[] arr){
		int max = arr[0];
		for(int i=1; i<arr.length; i++){
			max = max>arr[i] ? max : arr[i];
		}
		return max;
	}
	//定义最小值的方法
	public static int getMin(int[] arr){
		int min = arr[0];
		for(int i=1; i<arr.length; i++){
			min = min<arr[i] ? min : arr[i];
		}
		return min;
	}//定义求和的方法
	public static int getSum(int[] arr){
		int sum = 0;
		for(int i=1; i<arr.length; i++){
			sum+=arr[i];
		}
		return sum;
	}
	//定义求平均的方法
	public static double getAvg(int[] arr){
		//先把和转换为double类型再除
		double avg = (double)(getSum(arr))/(arr.length-1);
		return avg;
	}
}

3.将一个已知数组  int[] a = {11,23,1,5,6,89} 中的元素，复制到一个新数组中

//3.将一个已知数组  int[] a = {11,23,1,5,6,89} 中的元素，复制到一个新数组中
class Homework03 {
	public static void main(String[] args) {
		int[] a = {11,23,1,5,6,89};
		int[] arr = new int[a.length];
		arr = a;
		traverse(arr);
	}
	//定义遍历的方法
	public static void traverse(int[] arr){
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
}

4. 产生1到10之间的随机数，把这些随机数装入一个10个长度的数据。要求，数组中数据不能重复

import java.util.Random;
class Homework06 {
	public static void main(String[] args) {
		Random random = new Random();
		int[] arr = new int[10];
		int r;
		for(int i=0;i<arr.length;i++){
			do{
				 r = random.nextInt(10)+1;
			}while(isRepeat(arr,r));
			arr[i] = r;
			System.out.println(arr[i]);
		}
	}
	//定义一个方法:去重
	public static boolean isRepeat(int[] arr,int num){
		for(int i=0;i<arr.length;i++){
			if(arr[i]==num){
				//遇到return整个程序就结束
				return true;
			}
		}
		return false;
	}
}