JavaSE学习-数组

目录

Java数组

数组的概述

一维数组的使用

多维数组的使用

数组中涉及到的常见算法

数组元素的排序算法

参考文献

---

Java数组

数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。

一 数组的概述
1.数组的理解:数组(Array)，是多个相同类型数据按一定顺序排列的集合，
并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.数组相关的概念
	数组名
	元素
	角标,下标,索引,
	数组的长度:元素的个数
	
3.数组的特点:
3.1数组是有序排列的.
3.2数组属于引用数据类型变量,数组的元素可以是基本数据类型,也可以是引用数据类型
3.3创建数组对象会在内存中开辟一整块连续的空间
3.4数组的长度一旦确定,就不能修改。

4.数组的分类
4.1 按照维数:一维数组,二维数组,...
4.2 按照数组元素的类型:基本数据类型元素的数组、引用数据类型元素的数组(
 */

一维数组的使用

主要注意以下过程：

• 一维数组的使用和初始化
• 如何调用数组指定位置的元素
•  如何获取数组的长度
• 如何遍历数组
• 数组元素的默认初始化值
  >整形元素  初始化都是0
  >浮点型元素   初始化是 0.0
  >Char类型     初始化是 ASCII(0)
  >boolean型元素  初始化是false
  >引用数据类型        初始化是 null
•  数组的内存解析

package com.atguigu.java;
/*
一维数组的使用
	一维数组的使用和初始化
	如何调用数组指定位置的元素
	如何获取数组的长度
	如何遍历数组
	数组元素的默认初始化值
		>整形元素  初始化都是0
		>浮点型元素   初始化是 0.0
		>Char类型     初始化是 ASCII(0)
		>boolean型元素  初始化是false
		>引用数据类型        初始化是 null
	数组的内存解析
 */
public class OneArrayUse {
	public static void main(String[] args) {
		int num;//声明
		num = 10;//初始化
		int id = 1001;//声明 + 初始化
		
		//1 一维数组的使用和初始化
		int[] ids;//声明 
		String[] names;
		//1.1 静态初始化  数组的初始化和数组元素的初始化的赋值操作同时进行
		ids = new int[] {1001,1002,1003,1004};
		
		//1.2动态初始化 数组的初始化和数组元素的初始化的赋值操作分开进行
		names = new String[5];
		
		//总结:数组一旦初始化完成,其长度就确定了
		
		//2.如何调用数组指定位置的元素：通过索引的方式调用
		//数组的索引是从0开始,到length(array)-1 结束
		names[0] = "十一";
		names[1] = "十二";
		names[2] = "十三";
		names[3] = "十四";
		names[4] = "十五";
		
		//3.如何获取数组的长度,
		//属性:length
		System.out.println("names数组的长度是"+ names.length);
		System.out.println("ids数组的长度是"+ ids.length);
		
		//4.如何遍历数组;
		for(int i = 0;i < names.length;i++) {
			System.out.println(names[i]);
		}
		
		//5.数组元素的默认初始化值
		int[] arr = new int[4];
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}
		
	}
}

关于  数组的内存解析

内存的简化结构：大致分为三部分：栈,堆,方法区   

int[] ages = new int[4];

目前学习的数组都是在main（）方法中，其中定义的变量都是局部变量，存储在栈中，new 出来的结构在堆中。

内存中连续存储的空间会有首地址值 0x3213，我们把这个首地址值赋给ages，通过栈空间中的0x3213就可以指向堆空间中的实体值。

随后，堆空间中的连续空间开始初始化赋值、

ages[0] = 12;ages[1] = 23;ages[2] = 33;

替换掉堆空间中的初始化数值

String[] names = new String[]{"赵宇","张凯","江运","曹林"}；

现在堆中开辟一段连续空间，空间首地址为0x8899，并将其赋给栈空间中的names，堆空间初始化数值为"赵宇","张凯","江运","曹林"

names[1] = "刘昭";

将堆空间中索引值为1位置的值替换为 刘昭，

names = new String[]{"Tom","Jerry"};

在堆空间中重新开辟一段连续空间，首地址为0x9999,并将其赋给栈空间中的names，堆空间初始化数值为"Tom","Jerry"，在这个过程中,栈空间中names的数值被修改，

说明栈空间中names现在执行堆空间的0x9999区域，原来的0x8899现在没有可以指向它的对象，会被java的垃圾回收机制在某个时间段被回收。

一维数组的练习1

package com.atguigu.java;
/*
升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。
屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。
 */
public class OneArrayExer1 {
	public static void main(String[] args) {
		int[] arr = new int[]{8,2,1,0,3};
		int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3};
		String tel = "";
		for(int i = 0;i < index.length;i++){
		tel += arr[index[i]];
		}
		System.out.println("联系方式：" + tel);//18013820100
		//     index[i]  2  0   3	 2
		//arr[index[i]]  1  8   0    1
		//       tel	 1  18  180  1801 
	}
}

一维数组的练习2

package com.atguigu.java;
/*
从键盘读入学生成绩，找出最高分，
并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，
存放学生成绩。
 */
import java.util.Scanner;//导包
public class OneArrayExer2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);//实例化
		
		System.out.print("请输入学生人数 : ");
		int studentsNumber = scan.nextInt();//调包
		System.out.println("请输入" + studentsNumber + "个成绩");
		
		int[] score = new int[studentsNumber];
		int max = 0;
				
		for(int i = 0; i<  studentsNumber;i++) {
			int input = scan.nextInt();//调包
			score[i] = input;
			max = (max > input)?max:input;
		}
		System.out.println("最高分是" + max);
		
		for(int i = 0;i < studentsNumber;i++) {
			int temp = max - score[i];
			String rank;
			if(temp <= 10) {
				rank = "A";
			}else if(temp <= 20) {
				rank = "B";
			}else if(temp <= 30) {
				rank = "C";
			}else {
				rank = "D";
			}
			
			System.out.println("student" + i + "score is " + score[i] +" grade is " + rank);
		}
	}
}
//结果
请输入学生人数 : 5
请输入5个成绩
89
75
46
23
89
最高分是89
student0score is 89 grade is A
student1score is 75 grade is B
student2score is 46 grade is D
student3score is 23 grade is D
student4score is 89 grade is A

多维数组的使用

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。

其实，从数组底层的运行机制来看，其实没有多维数组。

package com.atguigu.java;
/*
 二维数组的使用
规定：二维数组分为外层数据的元素,内层数据的元素
	int[][] arr = new int[4][3];
	外层元素：arr[0],arr[1]等
	内层元素：arr[0][1],arr[1][2]等
1.理解
看成是一维数组array1又作为另一个一维数组array2的元素而存在。
从数组底层的运行机制来看，其实没有多维数组。

2.使用
	二维数组的声明和初始化
	如何调用数组指定位置的元素
	如何获取数组的长度
	如何遍历数组
	数组元素的默认初始化值
		针对于初始化方式一：比如 int[][] arr = new int[4][3];
			外层元素的初始化值:地址值
			内层元素的初始化值:与一维数组初始化情况相同
		针对于初始化方式二：     int[][] arr = new int[4][];
			外层元素的初始化值:null
			内层元素的初始化值:无从谈起
	数组的内存解析
 */
public class TwoArrayTest {
	public static void main(String[] args) {
		//1.二维数组的使用和初始化
		int[] arr = new int[]{1,2,3};//一维静态初始化
		//静态初始化
		int[][] arr1 = new int[][] {{1,2,3},{4,5},{6,7,8}};
		//动态初始化 1
		String[][] arr2 = new String[3][2];
		//动态初始化 2
		String[][] arr3 = new String[3][];
		arr3[1] = new String[4];
		
		//2.如何调用数组指定位置的元素
		System.out.println(arr1[0][1]);// 2 
		System.out.println(arr2[2][1]);// null
		
		//3.如何获取数组的长度
		System.out.println("arr1 数组的长度是" + arr1.length);//3 数组的内存解析
		
		//4.如何遍历数组 二重循环
		for(int i = 0;i < arr1.length;i++) {
			for(int j = 0;j < arr1[i].length;j++) {
				System.out.print(arr1[i][j]);
			}
			System.out.println();
		}
		
		//5.数组元素的默认初始化值
		int[][] array = new int[4][3];
		System.out.println(array[0]);//外层元素 [I@15db9742 地址值
		System.out.println(array[0][0]);//内层元素  0
		System.out.println(array);//[[I@6d06d69c
		
		String[][] arrayString = new String[4][3];
		System.out.println(arrayString[1]);//外层元素  地址值 [Ljava.lang.String;@7852e922
		System.out.println(arrayString[2][1]);//内层元素  null
		
		double[][] arrayDouble = new double[4][];
		System.out.println(arrayDouble[1]);// null
	}
}
//结果
2
null
arr1 数组的长度是3
123
45
678
[I@15db9742
0
[[I@6d06d69c
[Ljava.lang.String;@7852e922
null

关于  二维数组的内存解析

int[][] arr1 = new int[4][];

在堆中开辟一段连续空间1，空间首地址为0x1234，并将其赋给栈空间中的arr1，堆空间初始化数值为"null","null","null","null",

arr1[1] = new int[]{1,2,3}

在堆中开辟一段连续空间2，空间首地址为0x7788，并将其赋给堆空间中的连续空间1的索引为1的地址，堆空间2初始化数值为"1","2","3",

arr1[2] = new int[4]

在堆中开辟一段连续空间3，空间首地址为0x6677，并将其赋给堆空间中的连续空间1的索引为2的地址，堆空间2初始化数值为"0","0","0","0"”

arr[2][1] = 30

将堆空间中的连续空间3的索引为1的值替换为 30

二维数组练习1

package com.atguigu.java;
/*
获取arr数组中所有元素的和。
提示：使用for的嵌套循环即可。
 */
public class TwoArrayExer1 {
	public static void main(String[] args) {
		int[][] array = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
		int sumArray = 0;
		
		for(int i = 0;i < array.length;i++) {
			for(int j = 0;j < array[i].length;j++) {
				sumArray += array[i][j];
			}
		}
		
		System.out.println("总和为" + sumArray);//总和为54
	}
}

二维数组练习2

package com.atguigu.java;

/*
声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是
 */
public class TwoArrayExer2 {
	public static void main(String[] args) {
		int[] x,y[];
		// x 为一维数组  y为二维数组
		//                右边		左边
		x[0] = y;// no 	  地址值		int数值
		y[0] = x;//yes	  地址值		地址值
		y[0][0] = x;//no int数值		int数值
		x[0][0] = y;//no 地址值		编译不通过
		y[0][0] = x[0];//yes   int数值             int数值
		x = y;//no       二维地址值                     一维地址值
	}
}

二维数组练习3

package com.atguigu.java;
/*
使用二维数组打印一个 10行杨辉三角。
【提示】
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元的元素
 */
public class TwoArrayExer3 {
	public static void main(String[] args) {
		//1.声明并初始化二维数组
		int[][] Yanghui = new int[10][];
		//2.赋值
		for(int i = 0;i < Yanghui.length;i++) {
			Yanghui[i] = new int[i + 1];
			//2.1给首末元素赋值
			Yanghui[i][0] = 1;
			Yanghui[i][i] = 1;
			//2.2给每行的非首末元素赋值
			for(int j = 1 ;j < Yanghui[i].length - 1;j++) {
				Yanghui[i][j] = Yanghui[i-1][j-1] + Yanghui[i-1][j];
			}
			
		}
		//3.遍历输出
		for(int i = 0;i < Yanghui.length;i++) {
			for(int j = 0;j < Yanghui[i].length;j++) {
				System.out.print(Yanghui[i][j] + " ");
			}
			System.out.println();
		}
	}
}
//结果
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 
1 9 36 84 126 126 84 36 9 1 

数组中涉及到的常见算法

1. 数组元素的赋值(杨辉三角、回形数等)
2. 求数值型数组中元素的最大值、最小值、平均数、总和等
3. 数组的复制、反转、查找(线性查找、二分法查找)
4. 数组元素的排序算法

package com.atguigu.java;
/*
算法考察：求数值型数组中元素的最大值、最小值、平均数、总和等
定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。10-99

Math.random()  输出0-1之间的小数
(int)(90*Math.random()) + 10;  10-99 
 */
public class ArrayExer1 {
	public static void main(String[] args) {
		//定义变量及数组
		int[] array = new int[10];
		int x;
		int max ,min ,sum =0;
		double average;
		//数组元素赋值
		for(int i = 0; i < array.length; i++) {
			x = (int)(90*Math.random()) + 10;
			array[i] = x;
		}
		//遍历数组
		for(int i = 0;i < array.length;i++) {
			System.out.print(array[i] + " ");
		}
		//换行
		System.out.println();
		//求max,min,sum,average
		max = min = array[0];
		for(int j = 0;j < array.length;j++) {
			sum += array[j];
			
			if(max < array[j]) {
				max = array[j];
			}
			if(min > array[j]) {
				min = array[j];
			}
		}
		System.out.println("数组的最大值为" + max);
		System.out.println("数组的最小值为" + min);
		System.out.println("数组的总和为" + sum);
		
		average = (double)(sum) / array.length;
		System.out.println("数组的平均值为" + average);
	}
}
//结果
26 32 96 33 92 25 94 80 76 23 
数组的最大值为96
数组的最小值为23
数组的总和为577
数组的平均值为57.7

package com.atguigu.java;
/*
使用简单数组
(1)创建一个名为ArrayExer2的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
(如array[0]=0,array[2]=2)。打印出array1。

思考：array1和array2是什么关系？
array1和array2地址值相同,都指向了堆空间中惟一的地址实体
拓展：修改题目，实现array3对array1数组的复制
 */
public class ArrayExer2 {
	public static void main(String[] args) {
		int[] array1,array2;
		array1 = new int[] {2,3,5,7,11,13,17,19};
		//显示array1的内容
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + " ");
		}
		System.out.println();
		
		//赋值array2变量等于array1
		//不能称作数字的复制
		array2 = array1;
		//修改题目，实现array3对array1数组的复制
		int[] array3 = new int[array1.length];
		for(int i = 0;i < array3.length;i++) {
			array3[i] = array1[i];
		}
		
		//修改array2中的偶索引元素，使其等于索引值
		for(int j = 0;j < array2.length;j++) {
			if(j % 2 == 0) {
				array2[j] = j;
			}
		}
		
		//显示array1的内容
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + " ");
		}
		System.out.println();
		
	}
}

array1和array2地址值相同,都指向了堆空间中惟一的地址实体

package com.atguigu.java;
/*
数组的反转
 */
public class ArrayExer3 {
	public static void main(String[] args) {
		
		String[] arr = new String[] {"JJ","DD","MM","BB","GG","AA"};
		
//		//数组翻转  方式1
//		for(int i = 0; i < arr.length/2;i++) {
//			String temp = arr[i];
//			arr[i] = arr[arr.length - 1 - i];
//			arr[arr.length - 1 - i] = temp;
//		}
		
		//方式2
		for(int i = 0,j = arr.length-1; i < j;i++,j--) {
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		//结果
		for(int i = 0; i < arr.length;i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
}

package com.atguigu.java;
/*
数组的搜索
 */
public class ArrayExer3 {
	public static void main(String[] args) {
		
		String[] arr = new String[] {"JJ","DD","MM","BB","GG","AA"};
		
		for(int i = 0; i < arr.length;i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
		//查找(搜索)
		//线性查找:
		String dest = "CC";
		boolean isFlag = true;
		for(int i = 0;i < arr.length;i++) {
			if(dest.equals(arr[i])) {
				System.out.println("找到了指定的元素" + dest + ",位置在 " + "i");
				isFlag = false;
				break;
			}
		}
		
		if(isFlag) {
			System.out.println("很遗憾,没有找到！");
		}
		
		//二分法查找
		// 前提：所要查找的数组必须有序
		int[] arr2 = new int[] {-98,-23,-5,3,5,10,88,160};
		
		int dest1 = -23;
		int head = 0;// 初始的首索引
		int end  = arr2.length;//初始的末索引
		boolean isFlag1 = true;
		while(head < end) {
			int mid = (head + end)/2;
			if(dest1 == arr2[mid]) {
				System.out.println("找到了指定的元素" + dest1 + ",位置在 " + mid);
				isFlag1 = false;
				break;
			}else if(dest1 > arr2[mid]) {
				head = mid + 1;
			}else {
				end = mid -1;
			}
		}
		if(isFlag1) {
			System.out.println("很遗憾,没有找到！");
		}
		
	}
}
//结果
JJ DD MM BB GG AA 
很遗憾,没有找到！
找到了指定的元素-23,位置在 1

数组元素的排序算法

基础概念：(不全讲)

排序：假设含有n个记录的序列为{R1，R2，...,Rn},其相应的关键字序列为 {K1，K2，...,Kn}。将这些记录重新排序为{Ri1,Ri2,...,Rin},使得相应的关键字值满足条Ki1<=Ki2<=...<=Kin,这样的一种操作称为排序。
通常来说，排序的目的是快速查找。

衡量排序算法的优劣：

• 时间复杂度：分析关键字的比较次数和记录的移动次数
• 空间复杂度：分析排序算法中需要多少辅助内存
• 稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

排序算法分类

• 内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成
• 外部排序：参与排序的数据非常多，数据量非常大，必须借助于外部存储器（如磁盘）。
  外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成

十大内部排序算法

• 选择排序： 直接选择排序、堆排序
• 交换排序 ：冒泡排序、快速排序(这两个作为重点讲)
• 插入排序 ：直接插入排序、折半插入排序、Shell排序
• 归并排序 
• 桶式排序 
• 基数排序

算法的5大特征：输入有界，输出有界，算法在有限步内结束，算法的每一步都是明确地，算法的每一步都是可行的

冒泡排序需要熟悉算法思想和代码

算法思想：

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

package com.atguigu.java;
/*
数组冒泡排序的实现
 */
public class BubbleSort {
	public static void main(String[] args) {
		
		int[] array = new int[] {23,1,3,45,-23,-98,348,65};
		
		//冒泡排序
		for(int i = 0;i < array.length - 1 ;i++) {
			for(int j = 0;j < array.length - 1 - i;j++) {
				if(array[j] > array[j+1]) {
					int temp;
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		//遍历输出
		for(int i = 0;i < array.length;i++) {
			System.out.print(array[i] + " ");
			
		}
		System.out.println();//换行
	}
}
//结果
-98 -23 1 3 23 45 65 348 

快速排序需要熟悉算法思想：

算法排序：

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后， 该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好 了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代 （iteration）中，它至少会把一个元素摆到它最后的位置去。

Arrays工具类的使用

package com.atguigu.java;
/*
java.util.Arrays : 操作数组的工具类,里边定义了很多操作数组的方法
 */
import java.util.Arrays;
public class ArraysMethodTest {
	public static void main(String[] args) {
		//1.boolean equals(int[] a,int[] b) 判断两个数组是否相等
		int[] arr1 = new int[] {1,2,3,4};
		int[] arr2 = new int[] {1,3,2,4};
		boolean isEquals = Arrays.equals(arr1,arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a) 输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
		//3.void fill(int[] a,int val) 将指定值填充到数组之中。
		Arrays.fill(arr2,5);
		System.out.println(Arrays.toString(arr2));
		
		//4.void sort(int[] a) 对数组进行排序。
		int[] arr3 = new int[] {1,4,6,7,8,2,5,-2,-34};
		Arrays.sort(arr3);
		System.out.println(Arrays.toString(arr3));
		
		//5.int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。
		int[] arr4 = new int[] {-34, -2, 1, 2, 4, 5, 6, 7, 8};
		int index = Arrays.binarySearch(arr4, -2);
		System.out.println(index);
	}
}
//结果
false
[1, 2, 3, 4]
[5, 5, 5, 5]
[-34, -2, 1, 2, 4, 5, 6, 7, 8]
1

数组使用中的常见异常

1. 数组脚标越界异常(ArrayIndexOutOfBoundsException)
2. 空指针异常(NullPointerException)

参考文献

B站尚硅谷Java零基础教程-java入门必备_宋红康

https://www.bilibili.com/video/BV1Kb411W75N?