Day 07，Day08笔记--数组

supzyh

已于 2023-03-23 21:04:34 修改

阅读量74

点赞数

分类专栏： Java学习文章标签： java Powered by 金山文档

于 2023-03-23 20:59:20 首次发布

本文链接：https://blog.csdn.net/supzyh/article/details/129739378

版权

Java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

JavaSE基础

多听一遍不如多练一遍，多练一遍不如总结一遍，希望各位在学习的过程中，要多听，多写，多练，每天将自己所学汇总一遍，查缺补漏，成就更好的自己

一、数组入门

1.1 概述

变量和素组的不同：

变量：变量是在内存中开辟了一片空间，用来存储对应类型的数据

数组：数组是在内存中开辟了一组连续的空间，用来存储对应类型的数据

数组注意事项

数据类型

数组的长度

int[] arr = new int[8];  // 数据类型为int , 数组长度为 8；

1.2 创建数组

1.2.1动态创建

先声明后创建

int [] arr01 ;
arr01 = new int [5];

声明的同时创建

int [] arr02 = new int[8];

1.2.2静态创建

全写【通用】

int [] arr03 = new int[]{22,123,433,55,666,1070,899};

简写【有些场景不适用】

int [] arr04 = {1,2,3,4};

1.2.3 不同

动态创建：确定类型和长度在数组创建之初没有向数组中存入数据,数组中的数据都是默认值

静态创建：确定类型，长度由自动计算得到,在数组创建的同时就存入了数据

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;

1.4 遍历数组

package com.shine.array;

public class Demo05 {
	public static void main(String[] args) {
		// 创建数组
		int[] arr = new int[] {2,4365,3,5,235};
		// 读取数组中的数据
		
		//使用for循环
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		//使用foreach循环
		/**
		 * 	foreach
		 * 		增强for
		 * 		高级for
		 *	for(数据类型 变量名 : 数组){
		 *		
		 *	}
		 */
		for (int i : arr) {
			System.out.println(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]); //输出为0
		System.out.println(arrInt[8]);//输出为0
		
		double[] arrDouble = new double[10];
		System.out.println(arrDouble[2]); //输出为0.0
		System.out.println(arrDouble[8]);//输出为0.0
		
		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]); //输出为null 
		System.out.println(arrStr[6]);//输出为null 
		
		Scanner[] arrScanner = new Scanner[10];
		System.out.println(arrScanner[2]);//输出为null 
		System.out.println(arrScanner[7]);//输出为null 
		
	}
}

1.6 练习题【掌握】

输出练习

package com.javastudy08;

public class ClassTest03 {
	 public static void main(String[] args) {
			/**
			 *	输出练习：创建int数组
			 *	1、遍历输出数组中的每一个元素
			 *	2、遍历输出数组中索引为偶数的元素
			 *	3、输出数组中数值大/小于66的数据
			 *	4、输出数组中的3位数数字
			 *	5、倒序遍历输出数组中的数据
			 */ 
		 int [] arr = new int [] {1,345,665,1234,90,87};
		 
		 
		 //1、遍历输出数组中的每一个元素
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 System.out.print(arr[i]+"	");
		 }
		 System.out.println();
		 
		 //2、遍历输出数组中索引为偶数的元素
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 if(i % 2 == 0) {
				 System.out.print(arr[i]+"	");
			 }
		 }
		 System.out.println();
		 
		 
		 //3、输出数组中数值大/小于66的数据
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 if(arr[i] > 66) {
				 System.out.print(arr[i]+"	");
			 }
		 }
		 System.out.println();
		 
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 if(arr[i] < 66) {
				 System.out.print(arr[i]+"	");
			 }
		 }
		 System.out.println();
		 
		 //4、输出数组中的3位数数字
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 if(arr[i] >= 100 && arr[i] <= 999) {
				 System.out.print(arr[i]+"	");
			 }
		 }
		 System.out.println();
		 
		 //5、倒序遍历输出数组中的数据
		 for(int i = arr.length-1 ; i >= 0 ; i--) {
			 System.out.print(arr[i]+"	");
		 }
		 System.out.println();
	}
}

计算练习

package com.javastudy08;

public class ClassTest04 {
	public static void main(String[] args) {
		/**
		 *	计算练习：创建int数组
		 *	1、计算数组中元素的总和
		 *	2、计算数组中元素的平均值
		 *	3、统计小于60数字的数量
		 * 	4、查询范围在60~70数字的数量
		 */
		
		int[] arr = {1,43,54,68,61,22};
		double sum = 0.0;//用来计算总和
		int  count1 = 0; //用来统计小于60数字的数量
		int count2 = 0;//用来统计范围在60~70数字的数量
		
		
		//1、计算数组中元素的总和
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 sum+= arr[i];
		 }
		 System.out.println(sum);
		 
		 //2、计算数组中元素的平均值
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 sum+= arr[i];
		 }
		 System.out.println(sum/arr.length);
		 
		 //3、统计小于60数字的数量
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 if(arr[i] < 60) {
				 count1++ ;
			 }
		 }
		 System.out.println(count1);
		 
		 
		 //4、查询范围在60~70数字的数量
		 for(int i = 0 ; i <= arr.length-1 ; i++) {
			 if(arr[i] >= 60 && arr[i] <= 70) {
				 count2 ++ ;
			 }
		 }
		 System.out.println(count2);
	}

}

二、数组扩容

2.1 概述

数组创建的时候需要指定数据的类型和数组的长度，类型和长度一旦确定就不能更改

如果数组中已经存满了元素，还有更多的元素需要存入，数组就需要扩容

扩容的思路：

创建比原数组更大的数组，容纳原来的数据和后来的数据

2.2 手动扩容

package com.javastudy08;

import java.util.Arrays;

public class ClasstTest05 {
	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];
		
		// 遍历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

创建更大的、包含原数组数据的新数组


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);
	}
}

	// 源数组
	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.javastudy08;

import java.util.Arrays;

public class ClassTest06 {
	
	public static void main(String[] args) {
		/**
		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.javastudy08;

import java.util.Arrays;

public class ClassTest07 {
	public static void main(String[] args) {
		 //冒泡排序
		 int[] arr = new int [] {1,91,87,35,42,66,12};
		// 确定比较的总轮数：数组长度-1
		 for(int i = 0 ;i < arr.length-1 ; i++) {
			// 每一轮中比较的次数是长度-1-i,需要比较的元素随着轮数的增加逐渐减少
			 for(int j = 0 ; j < arr.length-1-i ; j++) {
				// 相邻的元素比较
				 if(arr[j] > arr[j+1]) {
					 int temp = 0 ;
					// 发现前面的数据大于后面的数据,交换他们的位置
					 temp = arr[j+1];
					 arr[j+1] = arr[j];
					 arr[j] = temp;
				 }
			 }
		 }
		 System.out.println(Arrays.toString(arr));
	}
}

五、引用类型参数和返回值

5.1 概述

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

5.2 引用类型参数

package com.javastudy08;

import java.util.Arrays;

public class ClassTest08 {
	public static void main(String[] args) {
		/**
		 *	1、编写方法，传入一个数组，返回数组中的最大值
		 *	2、编写方法，传入一个数组，对数组排序【无需返回值】
		 *	3、编写方法，传入一个数组，计算元素平均值
		 *	4、传入数组和新的长度，返回新指定长度的数组【包含原数组中的内容】
		 *	5、编写方法，传入数组，返回数组的字符串表示形式
		 */
		
		int[] arr01 = new int[] {2,66,3,51,34,59};
		//最大值
		int maxnum = max(arr01);
		System.out.println(maxnum);
		//排序
		arrSort(arr01);
		//平均值
		double avg = comp(arr01);
		System.out.println(avg);
		//扩容数组
		newArr(arr01,15);
		//字符串返回
		backString(arr01);
	}

	//1、编写方法，传入一个数组，返回数组中的最大值
	private static int max(int arr[]) {
		// TODO Auto-generated method stub	
		int max = 0 ;
		for(int i = 0 ; i <= arr.length-1; i++) {
			if(arr[i] > max) {
				max = arr[i];
			}
		}
		return max;
	}
	
	
	//2、编写方法，传入一个数组，对数组排序【无需返回值】
	private static void arrSort(int arr[]) {
		// TODO Auto-generated method stub
		Arrays.sort(arr);
	}
	
	
	//3、编写方法，传入一个数组，计算元素平均值
	private static double comp(int arr[]) {
		double sum = 0.0;
		// TODO Auto-generated method stub
		for(int i = 0 ; i <= arr.length-1; i++) {
			sum += arr[i]; 
		}
		return sum/arr.length;
	}
	
	//传入数组和新的长度，返回新指定长度的数组【包含原数组中的内容】
	private static void newArr(int arr[],int length) {
		// TODO Auto-generated method stub
		System.out.println(Arrays.toString(Arrays.copyOf(arr, length)));
	}
	
	//编写方法，传入数组，返回数组的字符串表示形式
	private static void backString(int arr[]) {
		// TODO Auto-generated method stub
		System.out.println(Arrays.toString(arr));

	}
}

5.3 引用类型返回值

package com.javastudy08;

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

public class ClassTest09 {
	public static void main(String[] args) {
	/**
	 *	生成指定长度的随机数数组，数字范围0~100
	 */
		System.out.println(Arrays.toString(randomNum(10)));
	}
	
	private static int[] randomNum(int count) {
		// TODO Auto-generated method stub
		// 创建随机对象类
		Random r = new Random();
		
		// 创建指定长度的数组
		int[] arr = new int[count];
		
		// 指定的次数
		for (int i = 0; i <= arr.length-1; i++) {
			// 生成随机数存入数组
			arr[i] = r.nextInt(101);//[0-101)， 前包后不包
		}
		return arr;
	}
	
}

六、可变长参数【了解】

6.1 概述

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

6.2 入门案例

package com.javastudy08;

public class ClassTest10 {
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 注意事项

一个方法中只能存在一个可变长参数

可变长参数必须在方法的最后一个形参位置

方法中可以定义其他非可变长参数

基本类型和引用类型的比较

package com.javastudy08;

public class ClassTest11 {
	public static void main(String[] args) {
		int num = 10 ;
		System.out.println("main方法中的num001:" + num);
		
		
		changeNum(num);
		System.out.println("main方法中的num004:" + num);
		
	}
	
	
	private static void changeNum(int num) {
		// TODO Auto-generated method stub
		System.out.println("changeNum方法中的num002:" + num );
		
		num = 20 ;
		System.out.println("changeNum方法中的num003:" + num);
	}
}

/**  
输出结果:
	main方法中的num001:10
	changeNum方法中的num002:10
	changeNum方法中的num003:20
	main方法中的num004:10
*/

package com.javastudy08;

public class ClassTest12 {
	public static void main(String[] args) {
		
		int[] nums = new int[] {10,20,30};
		System.out.println("main方法中的num001:" + nums[0]);
		
		
		changeNum(nums);
		System.out.println("main方法中的num004:" + nums[0]);
		
	}
	private static void changeNum(int nums[]) {
		// TODO Auto-generated method stub
		System.out.println("changeNum方法中的num002:" + nums[0] );
		
		nums[0] = 100 ;
		System.out.println("changeNum方法中的num003:" + nums[0]);
	}
	
}
/** 
输出结果：
        main方法中的num001:10
        changeNum方法中的num002:10
        changeNum方法中的num003:1000
        main方法中的num004:10
*/

package com.javastudy08;

public class ClassTest13 {
	public static void main(String[] args) {
		
		int[] nums = new int[] {10,20,30};
		System.out.println("main方法中的num001:" + nums[0]);
		
		
		changeNum(nums);
		System.out.println("main方法中的num004:" + nums[0]);
		
	}
	private static void changeNum(int nums[]) {
		// TODO Auto-generated method stub
		System.out.println("changeNum方法中的num002:" + nums[0] );
		
		nums = new int[] {1000,2000,3000};
		System.out.println("changeNum方法中的num003:" + nums[0]);
	}
	
}
/** 
输出结果
        main方法中的num001:10
        changeNum方法中的num002:10
        changeNum方法中的num003:1000
        main方法中的num004:10
*/