Java基础笔记——数组

本文主要是介绍Java基础笔记——数组，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

三、数组

1、数组的概念

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

数组的常见概念：

数组名
下标（索引）
元素
数组的长度

数组的特点：

1.数组是有序排列的。

2.数组属于引用类型变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。

3.创建数组对象会在内存中开辟一整块连续的内存空间。

4.数组的长度一旦确定，就不能修改

数组的分类：

① 按照维度：一维数组、二维数组、三维数组、…

② 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

2、一维数组的使用

① 一维数组的声明和初始化
② 如何调用数组指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值
⑥ 数组的内存分析

（1）一维数组的声明和初始化

声明：

type[] var 或 type var[]

例如：int a[] String[] str

Java语言中声明数组时不能指定其长度(数组中元素的数)，例如： int a[5]; //非法

初始化：

① 静态初始化：数组的初始化和数组的赋值操作同时进行

a = new int[] {1001,1002,1003};

String[] b = new String[]{"aa","bb","cc"};

② 动态初始化：数组的初始化和数组的赋值操作分别进行

String[] names = new String[5];

（2）元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；

数组元素的引用方式：数组名[数组元素下标]

数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i]
数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]

（3）获取数组长度

每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)

数组一旦初始化，其长度是不可变的

（4）一维数组遍历

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

（5）一维数组的默认初始化值

数组元素是整型：0 (byte、short、int、long)
数组元素是浮点型：0.0
数组元素是字符char型：0 或 'u0000'，而非'0'
数组元素是布尔boolean型：false 0 1
数组元素是引用类型：null

（6）数组的内存解析

练习题：

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

成绩>=最高分-10 等级为’A’

成绩>=最高分-20 等级为’B’

成绩>=最高分-30 等级为’C’

其余等级为’D’

提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

import java.util.Scanner;

public class ArrayExer1 {

	public static void main(String[] args) {
		
		//1.使用Scanner，接收数据
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入学生人数：");
		int num = scan.nextInt();
		
		
		//2.使用数组，存储学生成绩：动态初始化
		int[] scores = new int[num];
		//3.给数组中元素赋值
		System.out.println("请输入" + num + "个学生成绩");
		for(int i = 0;i < scores.length;i++) {
			scores[i] = scan.nextInt();
		}
		//4.获取数组中的最大值
		int maxScore = 0;
		for(int i = 0;i < scores.length;i++) {
			if(maxScore < scores[i]) {
				maxScore = scores[i];
			}
		}
		System.out.println("最高分为：" + maxScore);
		//5.根据每个学生与最高分的差值，得到每个学生的等级，并输出成绩和等级
		char level;
		for(int i = 0;i < scores.length;i++) {
			if(maxScore - scores[i] <= 10) {
				level = 'A';
			}else if(maxScore - scores[i] <= 20) {
				level = 'B';
			}else if(maxScore - scores[i] <= 30) {
				level = 'C';
			}else {
				level = 'D';
			}
			System.out.println("student " + i + " score is " + scores[i] + " grade is " + level);
			
		}
		
	}
}

3、二维数组

对于二维数组的理解，我们可以看成是一维数组 array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

二维数组的使用：
① 二维数组的声明和初始化
② 如何调用数组的指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值
⑥ 数组的内存解析

（1）声明和初始化

//静态初始化
int[][] arr1 = new int[][] {{1,2,3},{4,5},{7,8,9}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];

（2）调用

System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null

arr3[1] = new String[4];
System.out.println(arr3[1][0]);
System.out.println(arr3[0]);//

（3）遍历和length属性

for(int i = 0;i < arr.length;i++){
           for(int j = 0;j < arr[i].length;j++) {
               System.out.print(arr[i][j] + " ");
           }
           System.out.println();
}

（4）二维数组的默认初始化值

  二维数组的使用：
   规定：二维数组分为外层数组的元素，内层数组的元素
   int[][] arr = new int[4][3];
   外层数组：arr[0],arr[1]
   内层数组：arr[0][0],arr[1][2]

数组元素的默认初始化值：
针对于初始化方式一：比如 int[][] arr = new arr[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组相同

针对于初始化方式二：比如：int[][] arr = new arr[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错

（5）数组的内存解析

练习题：

/*
 * 打印10行杨辉三角
 */
public class YangHuiTest {

	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] = yangHui[i][i] = 1;
			//2.2.给每行非首末元素赋值
			if(i > 1) {
				for(int j = 1;j < yangHui[i].length - 1;j++) {
					yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
				}
			}		
		}
		//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();
		}
	}
}

2.创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。

/*
 * 创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求
 *  元素的值各不相同。
 */
public class ArrayExer1 {

	public static void main(String[] args) {
		//方式一：
		
//		//1.创建一维数组
//		int[] arr = new int[6];
//		//2.给数组赋值
//		for(int i = 0;i < arr.length;i++) {
//			//2.1.获取1-30的随机数 [0,1)  [0,30)  [1,31)
//			//要记得加括号，不然先执行强制转换，一直是0
//			arr[i] = (int)(Math.random()*30) + 1;
//			//3.判断元素是否相同
//			boolean isFlag = false;
//			while(true) {
//				for(int j = 0;j < i;j++) {
//					
//					if(arr[i] == arr[j]) {
//						isFlag = true;
//						break;
//					}
//				}
//				//4.如果相同，重新赋值
//				if(isFlag) {
//					arr[i] = (int)(Math.random()*30) + 1;
//					//不要忘记重新初始化
//					isFlag = false;
//					continue;
//				}
//				//跳出while循环
//				break;
//			}
//			
//		}
//		//遍历数组
//		for(int i = 0;i < arr.length;i++) {
//			System.out.print(arr[i] + " ");
//		}
		
		//方式二：
		
		//1.创建一维数组
		int[] arr = new int[6];
		//2.给数组赋值
		for(int i = 0;i < arr.length;i++) {
			//2.1.获取1-30的随机数 [0,1)  [0,30)  [1,31)
			//要记得加括号，不然先执行强制转换，一直是0
			arr[i] = (int)(Math.random()*30) + 1;
			//3.判断元素是否相同
				for(int j = 0;j < i;j++) {
					
					if(arr[i] == arr[j]) {
						i--;
						continue;
					}
				}
			
		}
		//遍历数组
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + " ");
		}
		
	}
}

3.回形数格式方阵的实现

从键盘输入一个整数（1~20）

则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如：输入数字2，则程序输出： 1 2

4 3

输入数字3，则程序输出： 1 2 3

8 9 4

7 6 5

输入数字4，则程序输出：

1 2 3 4

12 13 14 5

11 16 15 6

10 9 8 7

方式一：
class RectangleTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个数字");
		int len = scanner.nextInt();
		int[][] arr = new int[len][len];

		int s = len * len;
		/*
		 * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
		 */
		int k = 1;
		int i = 0, j = 0;
		for (int m = 1; m <= s; m++) {
			if (k == 1) {
				if (j < len && arr[i][j] == 0) {
					arr[i][j++] = m;
				} else {
					k = 2;
					i++;
					j--;
					m--;
				}
			} else if (k == 2) {
				if (i < len && arr[i][j] == 0) {
					arr[i++][j] = m;
				} else {
					k = 3;
					i--;
					j--;
					m--;
				}
			} else if (k == 3) {
				if (j >= 0 && arr[i][j] == 0) {
					arr[i][j--] = m;
				} else {
					k = 4;
					i--;
					j++;
					m--;
				}
			} else if (k == 4) {
				if (i >= 0 && arr[i][j] == 0) {
					arr[i--][j] = m;
				} else {
					k = 1;
					i++;
					j++;
					m--;
				}
			}
		}

		// 遍历
		for (int m = 0; m < arr.length; m++) {
			for (int n = 0; n < arr[m].length; n++) {
				System.out.print(arr[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

方式二：
class RectangleTest1 {

	public static void main(String[] args) {
		int n = 7;
		int[][] arr = new int[n][n];

		int count = 0; // 要显示的数据
		int maxX = n - 1; // x轴的最大下标
		int maxY = n - 1; // Y轴的最大下标
		int minX = 0; // x轴的最小下标
		int minY = 0; // Y轴的最小下标
		while (minX <= maxX) {
			for (int x = minX; x <= maxX; x++) {
				arr[minY][x] = ++count;
			}
			minY++;
			for (int y = minY; y <= maxY; y++) {
				arr[y][maxX] = ++count;
			}
			maxX--;
			for (int x = maxX; x >= minX; x--) {
				arr[maxY][x] = ++count;
			}
			maxY--;
			for (int y = maxY; y >= minY; y--) {
				arr[y][minX] = ++count;
			}
			minX++;
		}

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				String space = (arr[i][j] + "").length() == 1 ? "0" : "";
				System.out.print(space + arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}

4、数组中涉及的常见算法

1. 数组元素的赋值(杨辉三角、回形数等)

2. 求数值型数组中元素的最大值、最小值、平均数、总和等

3. 数组的复制、反转、查找(线性查找、二分法查找)

4. 数组元素的排序算法

/*
 * 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 * 要求：所有随机数都是两位数。
 * 
 */
public class ArrayTest1 {

	public static void main(String[] args) {

		int[] arr = new int[10];
		
		for(int i = 0;i < arr.length;i++) {
			arr[i] = (int)(Math.random()*90 + 10);
		}
		
		//遍历输出
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + " ");
		}
		
		System.out.println();
		//数组中的最大值
		int maxValue = arr[0];
		for(int i = 0;i < arr.length;i++) {
			if(maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);
		
		//数组最小值
		int minValue = arr[0];
		for(int i = 0;i < arr.length;i++) {
			if(minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		System.out.println("最小值为：" + minValue);
		
		//和
		int sum = 0;
		for(int i = 0;i < arr.length;i++) {
			sum += arr[i];
		}
		System.out.println("和值为：" + sum);
		
		//平均值
		int averageValue = sum / 10;
		System.out.println(averageValue);
	}
}

/*
 * 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)
 * 
 */
public class ArrayTest2 {

	public static void main(String[] args) {
		
		String[] arr = new String[] {"JJ","DD","MM","BB","GG","AA"};
		
		//数组的复制
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++) {
			arr1[i] = arr[i];
		}
		
		//数组的反转
		//方法一：
//		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;
//		}
		
		//方法二：
		for(int i=0,j=arr.length-1;i<j;i++) {
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i] + " ");
		}
		
		//查找(或搜索)
		//线性查找
		String dest = "BB";
		boolean flag = true;
		for(int i = 0;i < arr.length;i++) {
			if(dest.equals(arr[i])) {
				System.out.println("找到了指定元素，索引为：" + i);
				flag = false;
				break;
			}
		}
		if(flag) {
			System.out.println("未找到指定元素");
		}
		
		//二分法查找：(熟悉)
		//前提：所要查找的数组必须是有序的
		int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
		
		int number = 2561;//要查找的元素
		boolean flag1 = false;
		int head = 0;//首索引位置
		int end = arr3.length - 1;//尾索引位置
		while(head <= end) {
			int middle = (head + end) / 2; 
			
			if(arr3[middle] == number) {
				System.out.println("找到指定的元素，索引为：" + middle);
				flag1 = true;
				break;
			}else if(arr3[middle] > number) {
				end = middle - 1;
			}else {//arr3[middle] < number
				head = middle + 1;
			}
		}
		
		if(flag1 == false) {
			System.out.println("未找到指定元素");
		}
		
	}
}

4.排序算法

十大内部排序算法：

选择排序：

直接选择排序、堆排序

交换排序：

冒泡排序、快速排序

插入排序：

直接插入排序、折半插入排序、Shell排序

归并排序

通式排序

基数排序

冒泡排序

介绍：

冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

/*
 * 数组冒泡排序的实现
 * 
 */
public class BubbleSortTest {

	public static void main(String[] args) {
		int[] arr = new int[] {43,32,76,-98,0,64,33,-21,32,99};
		
		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 i = 0;i < arr.length;i++) {
			System.out.println(arr[i] + " ");
		}
	}
}

快速排序

介绍：

快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见掌握快排的重要性。

快速排序（Quick Sort）由图灵奖获得者Tony Hoare发明，被列为20世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))。

排序思想：

1. 从数列中挑出一个元素，称为"基准"（pivot），

2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

5、Arrays工具类的使用

/*
 * 
 * java.util.Arrays：操作数组的工具类，里面定义了很多操作数组的方法
 */
public class ArraysTest {

	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,4,2};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a)  输出数组信息 任意类型数组
		System.out.println(Arrays.toString(arr1));
		String[] arr3 = new String[] {"Tom","LingLing","Jerry","DaMing"};
		System.out.println(Arrays.toString(arr3));
		
		//3.void fill(int[] a,int val)  将指定值填充到数组中
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		
		//4.void sort(int[] a)  对数组进行排序
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		 
		//5.int binarySearch(int[] a,int key)  对排序后的数组进行二分法检索指定的值
		int[] arr4 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr4, 105);
		if(index > 0) {
			System.out.println(index);
		}else {
			System.out.println("未找到指定元素");
		}
		
	}
}

6、数组使用中的常见异常

数组中的常见异常：

1.数组角标越界异常：ArrayIndexOutOfBoundsException

2.空指针异常：NullPointerException

public class ArrayExceptionTest {

	public static void main(String[] args) {
		
		//1.数组角标越界异常：ArrayIndexOutOfBoundsException
		int[] arr = new int[] {1,2,3,4,5};
		
//		for(int i = 0;i <= arr.length;i++) {
//			System.out.println(arr[i]);
//		}
		
//		System.out.println(arr[-2]);
		
		//空指针异常：NullPointerException
		//情况一：
		int[] arr1 = new int[] {1,2,3};
		arr1 = null;
//		System.out.println(arr1[1]);
		
		//情况二：
		int[][] arr2 = new int[4][];
//		System.out.println(arr2[2][0]);
		
		//情况三：
		String[] arr3 = new String[] {"aa","bb","dd"};
		arr3[1] = null;
//		System.out.println(arr3[1].toString());
		System.out.println(arr3[2].toString());
	}
}

这篇关于Java基础笔记——数组的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

Java基础笔记——数组

三、数组

1、数组的概念

2、一维数组的使用

（1）一维数组的声明和初始化

（2）元素的引用

（3）获取数组长度

（4）一维数组遍历

（5）一维数组的默认初始化值

（6）数组的内存解析

3、二维数组

（1）声明和初始化

（2）调用

（3）遍历和length属性

（4）二维数组的默认初始化值

（5）数组的内存解析

练习题：

4、数组中涉及的常见算法

5、Arrays工具类的使用

6、数组使用中的常见异常

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯