006-数组

杜军强

已于 2023-07-27 11:49:12 修改

阅读量203

点赞数

分类专栏： JavaSE 文章标签： java 开发语言

于 2023-07-26 14:45:26 首次发布

本文链接：https://blog.csdn.net/dushine2008/article/details/131939024

版权

JavaSE 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

006-数组

文章目录

006-数组

一、数组入门

1.1 概述

变量
- 变量是在内存中开辟了一片空间，用来存储对应类型的数据
- 存一个
数组
- 数组是在内存中开辟了一组连续的空间，用来存储对应类型的数据
- 0~N个
数组注意事项
- 数据类型
  - 数组中存储元素的类型
- 数组的长度
  - 数组中最多存储元素的数量
```
int[] arr = new int[8];
```

1.2 创建数组

动态创建

确定类型和长度
在数组创建之初没有向数组中存入数据
数组中的数据都是默认值
先声明后创建

int[] arr;
arr = new int[10];

声明的同时创建

int[] arrr = new int[20];

静态创建

确定类型，长度由JVM计算得到
在数组创建的同时就存入了数据
全写【通用】

int[] arr = new int[]{11,22,33,44,55};

简写【有些场景不适用】

int[] arr = {11,22,33,44,55};

1.3 访问数组

数组的长度

arr.length

数组的索引

数组中每一个数据都是数组的元素
每一个元素都有自己的标记–索引【下标】
索引从0开始，到数组长度-1结束

读取数据

数组名称[索引]

// 创建长度为·10的数组
int[] arr = new int[10];
// 读取数组中索引为0的数据存入i
int i = arr[0];

写入数据

数组名称[索引] = 数据;

// 创建长度为·10的数组
int[] arr = new int[10];
// 把100这个数字存入数组arr的索引为0的位置
arr[0] = 100;

package com.shine.array;

public class Demo04 {
	public static void main(String[] args) {
		// 创建长度为4的int类型数组
		int[] arr = new int[4];	
		// 读取数组索引为0位置的元素
		System.out.println(arr[0]);
		
		// 把111存入数组索引0的位置
		arr[0] = 111;
		System.out.println(arr[0]);
	}
}

1.4 遍历数组

package com.shine.array;

public class Demo05 {
	public static void main(String[] args) {
		// 创建数组
		int[] arr = new int[] {2,4365,3,5,235};
		// 读取数组中的数据
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);
		System.out.println(arr[4]);
		
		System.out.println("==============for==============");
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		System.out.println("==============while==============");
		int index = 0;
		while (index < arr.length) {
			System.out.println(arr[index]);
			index++;
		}
		
		System.out.println("==============do-while==============");
		index = 0;
		do {
			System.out.println(arr[index]);
			index++;
		} while (index < arr.length);
		
		System.out.println("==============foreach==============");
		/**
		 * 	foreach
		 * 		增强for
		 * 		高级for
		 *	for(数据类型 变量名 : 数组){
		 *		
		 *	}
		 */
		for (int i : arr) {
			System.out.println(i);
		}
	}
}

package com.shine.array;

public class Demo06 {
	public static void main(String[] args) {
		/**
		 * 	1、数组元素书写的位置
		 * 	2、数组的长度
		 * 	3、数据的类型
		 * 	4、通过索引访问
		 */
		// 创建数组存储司马八达,使用多种方式遍历
		String[] names = new String[] {"司马一","司马二","司马三","司马四","司马五","司马六","司马七","司马八"};
		System.out.println("=============for==============");
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
	}
}

1.5 数组元素默认值

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0
double	0.0
boolean	false
char	\u0000
引用类型	null

package com.shine.array;

import java.util.Scanner;

public class Demo07 {
	public static void main(String[] args) {
		/**
		 * 	各种类型数组的默认值
		 * 		整数		0
		 * 		小数		0.0
		 * 		布尔		false
		 * 		字符		\u0000
		 * 		引用类型	null
		 */
		// 整数
		int[] arrInt = new int[10];
		System.out.println(arrInt[6]);
		System.out.println(arrInt[8]);
		
		double[] arrDouble = new double[10];
		System.out.println(arrDouble[2]);
		System.out.println(arrDouble[8]);
		
		boolean[] arrBoolean = new boolean[10];	// 0000 0000==false,0000 0001==true
		System.out.println(arrBoolean[3]);
		System.out.println(arrBoolean[7]);
		
		char[] arrChar = new char[10];
		System.out.println(arrChar[0]);	// char类型数组中的默认值是空格,\u0000
		System.out.println(arrChar[5]);
		
		String[] arrStr = new String[10];
		System.out.println(arrStr[1]);
		System.out.println(arrStr[6]);
		
		Scanner[] arrScanner = new Scanner[10];
		System.out.println(arrScanner[2]);
		System.out.println(arrScanner[7]);
		
	}
}

1.6 练习题【掌握】

输出练习

package com.shine.array02;

public class Demo01 {
	public static void main(String[] args) {
		
		/**
		 *	输出练习：创建int数组
		 *	1、遍历输出数组中的每一个元素
		 *	2、遍历输出数组中索引为偶数的元素
		 *	3、输出数组中数值大/小于66的数据
		 *	4、输出数组中的3位数数字
		 *	5、倒序遍历输出数组中的数据
		 */
		
		int[] arr = new int[] {2,4365,3,5,235,66,77,444555,2233,1235,77,99};
		
		// 1、遍历输出数组中的每一个元素
		for (int i = 0; i < arr.length; i++) {	// i表示数组元素的索引,从0开始,到数组长度-1结束,逐渐向后一个
			System.out.println(arr[i]);
		}
		
		// 倒序遍历输出数组中的数据
		/**
		 * 	倒序：
		 * 		开始：arr.length-1
		 * 		结束：0
		 */
		System.out.println("------------------");
		
		// 5、倒序遍历输出数组中的数据
		for (int i = arr.length-1; i >= 0; i--) {	// i表示数组元素的索引,从arr.length-1开始,到0结束,逐渐向前
			System.out.println(arr[i]);
		}
		
		System.out.println("------------------");
		
		// 2、遍历输出数组中索引为偶数的元素
		for (int i = 0; i < arr.length; i++) {
			// 判定索引是否偶数
			if (i % 2 == 0) {
				// 索引是偶数
				System.out.println(arr[i]);
			}
		}
		System.out.println("------------------");
		
		// 3、输出数组中数值大/小于66的数据
		
		// 遍历每一个元素
		for (int i = 0; i < arr.length; i++) {
			// 判定元素是否大于66
			if (arr[i] > 66) {
				// 元素大于66
				System.out.println(arr[i]);
			}
		}
		System.out.println("------------------");
		
		// 4、输出数组中的3位数数字【100~999】
		// 遍历每一个元素
		for (int i = 0; i < arr.length; i++) {
			// 判定元素是否三位数
			if (arr[i]>=100 && arr[i]<=999) {
				// 输出三位数元素
				System.out.println(arr[i]);
			}
		}
		System.out.println("------------------");
	}
}

计算练习

package com.shine.array02;

public class Demo02 {
	public static void main(String[] args) {
		/**
		 *	计算练习：创建int数组
		 *	1、计算数组中元素的总和
		 *	2、计算数组中元素的平均值
		 *	3、统计小于60数字的数量
		 * 	4、查询范围在60~70数字的数量
		 */
		
		// 1、计算数组中元素的总和
		int[] arr = new int[] {2,4365,3,5,235,66,77,444555,2233,1235,77,99};
		
		// 累计总和
		double sum = 0;
		
		// 遍历数组中的每一个数据
		for (int i = 0; i < arr.length; i++) {
			// 累加每一个数据
			// sum += i;	i是索引
			sum += arr[i];
		}
		System.out.println("总和:" + sum);
		
		// 2、计算数组中元素的平均值
		double avg = sum/arr.length;
		System.out.println("平均值:" + avg);
		
		// 3、统计小于60数字的数量
		// 计数
		int count = 0;
		// 遍历数组中的每一个数据
		for (int i = 0; i < arr.length; i++) {
			// 判定数据是否小于60
			if (arr[i] < 60) {
				// 发现小于60的数据,计数+1
				count++;
			}
		}
		System.out.println("小于60数据的数量是:" + count);
	}
}

二、数组扩容【掌握】

2.1 概述

数组创建的时候需要指定数据的类型和数组的长度
类型和长度一旦确定就不能更改
如果数组中已经存满了元素，还有更多的元素需要存入，数组就需要扩容
扩容的思路：
- 创建比原数组更大的数组，容纳原来的数据和后来的数据

2.2 手动扩容

package com.shine.array;

import java.util.Arrays;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 *	创建两个数组，分别存入三国演义魏国和吴国的5个好汉，编写代码合并两个数组
		 */
		
		String[] nameWei = new String[] {"曹操","典韦","许褚","张辽","夏侯惇"};
		String[] nameWu = new String[] {"孙坚","孙策","孙权","黄盖","周瑜"};
		
		/**
		 *	原来的数组已经满了，不能容纳更多的数据
		 *	需要创建更大的数组，用来存放更多的数据
		 *	新数组的大小
		 *		至少能容纳眼前的数据：数组01的长度 + 数组02的长度
		 */
		// 创建更大的数组
		String[] names = new String[nameWei.length + nameWu.length];
		
		// 把数组复制到新数组
		/**
		 * 
			names[0] = nameWei[0];
			names[1] = nameWei[1];
			names[2] = nameWei[2];
			names[3] = nameWei[3];
			names[4] = nameWei[4];
			
			names[5+0] = nameWu[0];
			names[5+1] = nameWu[1];
			names[5+2] = nameWu[2];
			names[nameWei.length + 3] = nameWu[3];
			names[nameWei.length + 4] = nameWu[4];
		 */
		// 遍历nameWei中的每一个元素,把元素存入names数组
		for (int i = 0; i < nameWei.length; i++) {
			names[i] = nameWei[i];
		}
		
		// 遍历nameWu中的每一个元素,把元素存入names数组
		for (int i = 0; i < nameWu.length; i++) {
			// nameWei已经占据了nameWei.length数量的位置,需要从这个位置之后继续存入
			names[nameWei.length + i] = nameWu[i];
		}
		System.out.println(Arrays.toString(names));
	}
}

2.3 API扩容

System.arraycopy
- 复制数据
Arrays.copyOf
- 创建更大的、包含原数组数据的新数组

package com.shine.array;

import java.util.Arrays;

public class Demo02 {
	public static void main(String[] args) {
		/**
		 *	从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
		 * 	src - 源数组。
			srcPos - 源数组中的起始位置。
			dest - 目标数组。
			destPos - 目标数据中的起始位置。
			length - 要复制的数组元素的数量。
		 */
		// 源数组
		String[] nameWei = new String[] {"曹操","典韦","许褚","张辽","夏侯惇"};
		String[] nameWu = new String[] {"孙坚","孙策","孙权","黄盖","周瑜"};
		
		// 创建新数组
		String[] names = new String[nameWei.length + nameWu.length];
		
		// 复制nameWei数据到names
		System.arraycopy(nameWei, 0, names, 0, nameWei.length);
		System.out.println(Arrays.toString(names));
		
		// 把nameWu中的数据复制到names
		System.arraycopy(nameWu, 0, names, nameWei.length, nameWu.length);
	}
}

package com.shine.array;

import java.util.Arrays;

public class Demo03 {
	public static void main(String[] args) {
		// 源数组
		String[] nameWei = new String[] {"曹操","典韦","许褚","张辽","夏侯惇"};
		String[] nameWu = new String[] {"孙坚","孙策","孙权","黄盖","周瑜"};
		
		// 在nameWei的基础上创建更大的数组：包含nameWei中的数据
		
		// 创建长度为10的数组，产生一个新的数组，数组中包含nameWei中的数据
		String[] names = Arrays.copyOf(nameWei, 10);
		System.out.println(Arrays.toString(names));
		
		// 把nameWu复制到新的数组
		System.arraycopy(nameWu, 0, names, nameWei.length, nameWu.length);
		
	}
}

三、Arrays

3.1 概述

操作数组的一个工具类
有些快捷方法操作数组
- 查找
- 排序
- 扩容
- 填充
- 转换成字符串

3.2 方法使用

package com.shine.array;

import java.util.Arrays;

public class Demo04 {
	public static void main(String[] args) {
		/**
			static <T> T[] copyOf(T[] original, int newLength) 
			          复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
			static void sort(int[] a) 
			          对指定的 int 型数组按数字升序进行排序。 
			static int binarySearch(int[] a, int key) 
			          使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。 
			static void fill(int[] a, int val) 
			          将指定的 int 值分配给指定 int 型数组的每个元素。 
			static String toString(Object[] a) 
			          返回指定数组内容的字符串表示形式。 
		 */
		
		int[] arr = new int[] {2,4365,3,5,235,66,77,444555,2233,1235,77,99};
		System.out.println(Arrays.toString(arr));
		
		// 排序
		Arrays.sort(arr);
		// 输出数组的字符串形式
		System.out.println(Arrays.toString(arr));
		
		// 二分查找
		System.out.println(Arrays.binarySearch(arr, 66));
		System.out.println(Arrays.binarySearch(arr, 77));
		
		// 使用指定数据填充数组
		Arrays.fill(arr, 0);
		System.out.println(Arrays.toString(arr));
	}
}

四、冒泡排序【重点】

4.1 概述

数组中相邻的两个元素比较，大的向后小的向前
比较的轮数
- 数组长度-1
- 每次找到一个最大元素放到最后，如果是长度为10的数组，需要找到9次最大值
每一轮比较的次数
- 逐渐减少
- 如果数组长度是10，第一轮需要比较9对，第二轮需要比较8对…

4.2 冒泡排序代码实现

package com.shine.array;

import java.util.Arrays;

public class Demo05 {
	public static void main(String[] args) {
		int[] arr = new int[] {2,3,5,66,235,4365};
		// 确定比较的总轮数：数组长度-1，每轮都找出一个最大值放在最后
		for (int i = 0; i < arr.length - 1; i++) {
			// 每一轮中相邻的两个元素比较,比较的次数是长度-1-i,需要比较的元素随着轮数的增加逐渐减少
			for (int j = 0; j < arr.length-i-1; j++) {
				// 相邻的元素比较
				if (arr[j] > arr[j+1]) {
					// 发现前面的数据大于后面的数据,交换他们的位置
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));
	}
}

五、引用类型参数和返回值【困难】【量力而行】

5.1 概述

引用类型变量也可以当做方法中的参数和返回值类型

5.2 引用类型参数

package com.shine.array02;

import java.util.Arrays;

public class Demo03 {
	public static void main(String args[]) {
		/**
		 *	1、编写方法，传入一个数组，返回数组中的最大值
		 *	2、编写方法，传入一个数组，对数组排序【无需返回值】
		 *	3、编写方法，传入一个数组，计算元素平均值
		 *	4、传入数组和新的长度，返回新指定长度的数组【包含原数组中的内容】
		 *	5、编写方法，传入数组，返回数组的字符串表示形式
		 */
		
		int[] arr = new int[] {2,66,235,4365,3,5};
		int m = max(arr);
		System.out.println(m);
		
		System.out.println(avg(arr));
		
		int[] newArr = copyOf(arr, 20);
		System.out.println(Arrays.toString(newArr));
	}
	
	/**
	 * 	返回数组中的最大值
	 * @param arr
	 * @return
	 */
	public static int max(int arr[]) {
		// 假设第一个就是最大的
		int max = arr[0];
		// 遍历后面的每一个数据
		for (int i = 1; i < arr.length; i++) {
			// 比较每一个数据
			if (max < arr[i]) {
				// 发现更大的数据,记录这个数据
				max = arr[i];
			}
		}
		return max;
	}
	
	/**
	 *	计算数组元素平均值
	 * @param arr
	 * @return
	 */
	public static double avg(int[] arr) {
		double sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum / arr.length;
	}
	
	/**
	 * 	传入数组和新的长度，返回新指定长度的数组【包含原数组中的内容】
	 * @param arr
	 * @param newLength
	 * @return
	 */
	public static int[] copyOf(int[] arr,int newLength) {
		// 创建指定长度的数组
		int[] newArr = new int[newLength];
		// 复制源数据到新数组
		System.arraycopy(arr, 0, newArr, 0, arr.length);
		return newArr;
	}
	
}

5.3 引用类型返回值

package com.shine.array02;

import java.util.Arrays;
import java.util.Random;

public class Demo04 {
	public static void main(String[] args) {
		/**
		 *	生成指定长度的随机数数组，数字范围0~100
		 */
		
		System.out.println(Arrays.toString(getNums(10)));
		
	}
	
	/**
	 *	生成指定长度的随机数数组，数字范围0~100
	 * @param count
	 * @return
	 */
	public static int[] getNums(int count) {
		// 创建随机对象类
		Random r = new Random();
		
		// 创建指定长度的数组
		int[] arr = new int[count];
		
		// 指定的次数
		for (int i = 0; i < arr.length; i++) {
			// 生成随机数存入数组
			arr[i] = r.nextInt(101);
		}
		return arr;
	}
	
}

六、方法重载【掌握】

6.1 概述

在同一个类中出现了多个名字相同的方法，它们的参数列表不同

6.2 重载案例

package com.shine.overload;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 *	编写方法计算整数相加的结果
		 *		整数的数量不详
		 */
		
	}
	
	public static int sum(int a,int b) {
		return a+b;
	}
	
	public static double sum(double a,int b) {
		return a+b;
	}
	
	public static double sum(int a,double b) {
		return a+b;
	}
	
	public static double sum(double a,double b) {
		return a+b;
	}
	
	public static int sum(int a,int b,int c) {
		return a+b+c;
	}
	
	public static int sum(int a,int b,int c,int d) {
		return a+b+c+d;
	}
	
	public static int sum(int a,int b,int c,int d,int e) {
		return a+b+c+d+e;
	}	
}

6.3、可变长参数【了解】

6.3.1 概述

可以在方法的形参中声明可变长参数，用来接受任意长度相同类型的参数

6.3.2 入门案例

package com.shine.array02;

public class Demo05 {
	public static void main(String[] args) {
		/**
		 *	求和的方法
		 */
		System.out.println(sum(1,2,3));
		System.out.println(sum(1,2,3,4,5));
		System.out.println(sum(1,2,3,4,5,6,7));
		
		int[] arr = {11,22,33};
		System.out.println(sum(arr));
	}
	
	/**
	 *	计算任意数量整数相加的结果
	 * @param nums	任意数量的整数
	 * @return		相加的结果
	 */
	public static int sum(int...nums) {
		int sum = 0;	// 记录总和
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}
	
}

6.3 注意事项

一个方法中只能存在一个可变长参数
可变长参数必须在方法的最后一个形参位置
方法中可以定义其他非可变长参数

七、二维数组【熟悉】

7.1 概述

数组中存储的对象是另一个数组：数组嵌套

7.2 创建二维数组

package com.shine.arr2d;

public class Demo02 {
	public static void main(String[] args) {
		/**
		 *	创建二维数组
		 */
		
		/**
		 *	创建二维数组
		 *		二维数组中有3个一维数组
		 *		每个一维数组的长度是5
		 */
		int[][] arr01 = new int[3][5];
		
		/**
		 *	创建二维数组
		 *		二维数组中有5个一维数组
		 *		一维数组都还没有创建，都是null
		 */
		int[][] arr02 = new int[5][];
		
		// 创建二维数组中的一位数组
		arr02[0] = new int[3];
		arr02[1] = new int[4];
		arr02[3] = new int[5];
		
		arr02[2] = new int[] {111,222,333};
		//arr02[4] = {11,22,33};	// 必须使用new
		
		/**
		 *	创建二维数组,向二维数组中添加数据
		 */
		int[][] arr03 = new int[][] {{111,222,333,44},{55,66,77}};
		
		int[][] arr04 = {{111,222,333,44},{55,66,77}};
	}
}

7.3 访问和遍历二维数组

package com.shine.arr2d;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 *	创建二维数组存储魏蜀吴三国的好汉
		 */
		
		String[][] names = {
				{"曹操","曹丕","曹植"},
				{"刘备","关羽","张飞","赵云","黄忠"},
				{"孙策","孙权","孙坚","周瑜","陆逊","黄盖","鲁肃"}
		};
		
		System.out.println(names);			// 输出整个二维数组
		System.out.println(names[0]);		// 输出二维数组中的第一个一维数组
		System.out.println(names[0][0]);	// 输出二维数组中第一个一维数组中的第一个元素
		
		System.out.println(names[1][3]);
		
		// 遍历二维数组
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
			for (int j = 0; j < names[i].length; j++) {
				System.out.println(names[i][j]);
			}
		}
		
	}
}

八、作业题

基础题

1、创建数组，键盘录入5个学生的年龄
a、找到年龄最大/小的值
b、找到指定年龄最后一次出现的位置
c、计算年龄的总和
d、计算平均年龄
e、查找年龄为15的学生所在的位置【第一次】
f、查找指定年龄出现的次数
g、使用冒泡排序方式对输入的学生年龄排序
h、编写方法，传入年龄数组，返回年龄平均值

2、倒序遍历数组

3、创建两个数组，分别存入三国演义和水浒传中的5个好汉
a、编写代码合并两个数组，得到一个新的数据，存储这些学员的名字
b、拓展：编写方法，传入两个数组，得到一个存储所有人名字的新数组

4、查阅资料, 思考新的数组排序方法

拓展题

String[] names = {房祖名,张默,柯震东,陈羽凡,满文军,尹相杰,宋冬野,莫少聪,谢东}中的明星随机分配到三个房间String[][] rooms = new String【3】【3】;
在歌唱比赛中,共有10位评委进行打分,在计算歌手得分时,去掉一个最高分,去掉一个最低分, 然后剩余的8位评委的分数进行平均,就是该选手的最终得分.输入每个评委的评分,求某选手的得分
编写方法获取一个长度是11的数组,其中的元素都是斐波那契数列中的值
{1,1,2,3,5…}
定义一个一维的int 数组，长度任意,然后将它们按从小到大的顺序输出
给定一个有9个整数（1,6,2,3,9,4,5,7,8）的数组，先排序，然后输出排序后的数组的值
输出一个double型二维数组（长度分别为5、4，值自己设定）的值。
生成一个4*6的二维整型数组，使用随机数填充，遍历输出该数组的所有值，并且找出最大值