2021-11-22----韩顺平Java入门第十三天

最新推荐文章于 2024-09-15 19:46:31 发布

Tingyu23157

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量248

点赞数

分类专栏： JAVA学习记录&笔记文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/Tingyu23157/article/details/121466104

版权

JAVA学习记录&笔记专栏收录该内容

10 篇文章 1 订阅

订阅专栏

本文介绍了Java中的数组，包括动态和静态初始化、数组使用注意事项、赋值机制、数组拷贝、反转、添加与扩容等操作。通过示例代码详细展示了如何在实际编程中操作数组。还提供了两个课后练习题，分别是数组缩减和最大值查找。

摘要由CSDN通过智能技术生成

韩顺平Java入门第十二天（数组）

数组
数组介绍
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即：数(数据)组(一组)就是一组数据。
1.数组的使用
在这里插入图片描述

使用方式 2-动态初始化
先声明数组：语法:数据类型数组名[];
也可以：数据类型[] 数组名; int a[]; 或者 int[] a;
创建数组：语法: 数组名=new 数据类型[大小]; a=new int[10];
使用方式 3-静态初始化
在这里插入图片描述
2.数组使用注意事项和细节：
1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理。
2) 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3) 数组创建后，如果没有赋值，有默认值 int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null。
4) 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组。
5) 数组的下标是从 0 开始的。
6) 数组下标必须在指定范围内使用，否则报：下标越界异常，比如int [] arr=new int[5]; 则有效下标为 0-4
7) 数组属引用类型，数组型数据是对象(object)。
数组使用细节：

public class ArrayDetail { 
	//编写一个 main 方法 
	public static void main(String[] args) { 
		//1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理 
		//int[] arr1 = {1, 2, 3, 60,"hello"};//String ->int 
		double[] arr2 = {1.1, 2.2, 3.3, 60.6, 100};//int ->double 
		//2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用 
		String[] arr3 = {"北京","jack","milan"}; 
		//3. 数组创建后，如果没有赋值，有默认值 
		//int 0，short 0, byte 0, long 0, 
		//float 0.0,double 0.0，char \u0000， 
		//boolean false，String null //
		short[] arr4 = new short[3]; 
		System.out.println("=====数组 arr4====="); 
		for(int i = 0; i < arr4.length; i++) { 
			System.out.println(arr4[i]); 
		}
		//6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如 
		//int [] arr=new int[5]; 则有效下标为 0-4 
		//即数组的下标/索引 最小 0 最大 数组长度-1(4) 
		int [] arr = new int[5]; //
		System.out.println(arr[5]);//数组越界 
	} 
}

数组练习1
创建一个 char 类型的 26 个元素的数组，分别放置’A’-‘Z’。使用 for 循环访问所有元素并打印出来。

public class ArrayExercise01 { 
	//编写一个 main 方法 
	public static void main(String[] args) { 
		/*创建一个 char 类型的 26 个元素的数组，
		分别 放置'A'-'Z'。 使用 for 循环访问所有元素并打印出来。 
		提示：char 类型数据运算 'A'+1 -> 'B' 
		思路分析
			1. 定义一个 数组 char[] chars = new char[26] 
			2. 因为 'A' + 1 = 'B' 类推，所以老师使用 for 来赋值 
			3. 使用 for 循环访问所有元素 
		*/ 
		char[] chars = new char[26]; 
		for( int i = 0; i < chars.length; i++) {
			//循环 26 次 //chars 是 char[] 
			//chars[i] 是 char 
			chars[i] = (char)('A' + i); //'A' + i 是 int , 需要强制转换 
		}//循环输出 
		System.out.println("===chars 数组==="); 
		for( int i = 0; i < chars.length; i++) {
			//循环 26 次 
			System.out.print(chars[i] + " "); 
	    } 
    }   
}

数组练习2
请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标。

public class ArrayExercise02 { 
	//编写一个 main 方法 
	public static void main(String[] args) {
		//请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标 
		//老韩思路分析 
		//1. 定义一个 int 数组 int[] arr = {4,-1,9, 10,23}; 
		//2. 假定 max = arr[0] 是最大值 , maxIndex=0; 
		//3. 从下标 1 开始遍历 arr， 如果 max < 当前元素，说明 max 不是真正的 
		// 最大值, 我们就 max=当前元素; maxIndex=当前元素下标 
		//4. 当我们遍历这个数组 arr 后 , max 就是真正的最大值，maxIndex 最大值对应的下标 
		int[] arr = {4,-1,9,10,23}; 
		int max = arr[0];//假定第一个元素就是最大值 
		int maxIndex = 0; // 
		for(int i = 1; i < arr.length; i++) {
			//从下标 1 开始遍历 arr 
			if(max < arr[i]) {
				//如果 max < 当前元素 
				max = arr[i]; //把 max 设置成当前元素 
				maxIndex = i; 
			} 
		}//当我们遍历这个数组 arr 后 , max 就是真正的最大值，maxIndex 最大值下标 
		System.out.println("max=" + max + " maxIndex=" + maxIndex); 
	} 
}

3.数组赋值机制
1) 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。 int n1 = 2; int n2 = n1;
2) 数组在默认情况下是引用传递，赋的值是地址。

public class ArrayAssign{
	public static void main(String[] args) {
		//基本数据类型赋值,赋值方式为拷贝
		//n2的变化不影响n1的变化。
		int n1 = 10;
		int n2 = n1;

		n2 = 80;
		System.out.println("n1=" + n1);//10
		System.out.println("n2=" + n2);//80

		//数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用
		//是一个地址
		int [] arr1 = {1,2,3};
		int [] arr2 = arr1;//相当于把arr1赋给arr2

		arr2[0] = 10;
		System.out.println("=======arr1的元素");
		for (int i = 0;i < arr1.length ;i++ ) {
		System.out.println(arr1[i]);//10 2 3	
		}
	}
}

在这里插入图片描述
4.数组拷贝
将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 要求数据空间是独立的。

public class ArrayCopy {
	//编写一个 main 方法 
	public static void main(String[] args) { 
		//将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 
		//要求数据空间是独立的. 
		int[] arr1 = {10,20,30}; 
		//创建一个新的数组 arr2,开辟新的数据空间 
		//大小 arr1.length; 
		int[] arr2 = new int[arr1.length]; 
		//遍历 arr1 ，把每个元素拷贝到 arr2 对应的元素位置 
		for(int i = 0; i < arr1.length; i++) { 
			arr2[i] = arr1[i]; 
		}//老师修改 arr2， 不会对 arr1 有影响. 
		arr2[0] = 100; 
		//输出 arr1 
		System.out.println("====arr1 的元素===="); 
		for(int i = 0; i < arr1.length; i++) { 
			System.out.println(arr1[i]);//10,20,30 
		}
	    System.out.println("====arr2 的元素===="); 
	    for(int i = 0; i < arr2.length; i++) { 
	    	System.out.println(arr2[i]);//100,20,30 
	    } 
	} 
}

5.数组反转
要求：把数组的元素内容反转，arr {11,22,33,44,55,66} -->{66,55,44,33,22,11}

public class ArrayReverse { 
	//编写一个 main 方法 
	public static void main(String[] args) { 
		//定义数组 
		int[] arr = {11, 22, 33, 44, 55, 66}; 
		//老韩思路 
		//规律 
		//1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
		//2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11} 
		//3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11} 
		//4. 一共要交换 3 次 = arr.length / 2 
		//5. 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i] 
		//代码 
		//
		//优化 
		int temp = 0; 
		int len = arr.length; 
		//计算数组的长度 
		for( int i = 0; i < len / 2; i++) { 
			temp = arr[len - 1 - i];//保存 
			arr[len - 1 - i] = arr[i]; 
			arr[i] = temp; 
		}
		System.out.println("===翻转后数组==="); 
		for(int i = 0; i < arr.length; i++) { 
			System.out.print(arr[i] + "\t");//66,55,44,33,22,11 
		} 
	} 
}

6.数组添加/扩容
要求：实现动态的给数组添加元素效果，实现对数组扩容。
1). 原始数组使用静态分配 int[] arr = {1,2,3}
2). 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
3). 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

import java.util.Scanner;
public class ArrayAdd { 
	//编写一个 main 方法 
	public static void main(String[] args) { 
		/*要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java 
		1.原始数组使用静态分配 int[] arr = {1,2,3} 
		2.增加的元素 4，直接放在数组的最后 arr = {1,2,3,4} 
		3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n 
		思路分析 
		1. 定义初始数组 int[] arr = {1,2,3}
		//下标 0-2 2. 定义一个新的数组 int[] arrNew = new int[arr.length+1]; 
		3. 遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组 
		4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把 4 赋给 arrNew 最后一个元素 
		5. 让 arr 指向 arrNew ; arr = arrNew; 那么 原来 arr 数组就被销毁 
		6. 创建一个 Scanner 可以接受用户输入 
		7. 因为用户什么时候退出，不确定，老师使用 do-while + break 来控制 
		*/ 
		Scanner myScanner = new Scanner(System.in); 
		//初始化数组 
		int[] arr = {1,2,3}; 
		do {
			int[] arrNew = new int[arr.length + 1];
			//遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组 
			for(int i = 0; i < arr.length; i++) { 
				arrNew[i] = arr[i]; 
			}
			System.out.println("请输入你要添加的元素"); 
			int addNum = myScanner.nextInt(); 
			//把 addNum 赋给 arrNew 最后一个元素 
			arrNew[arrNew.length - 1] = addNum; 
			//让 arr 指向 arrNew, 
			arr = arrNew; 
			//输出 arr 看看效果 
			System.out.println("====arr 扩容后元素情况===="); 
			for(int i = 0; i < arr.length; i++) { 
			System.out.print(arr[i] + "\t"); 
			}//问用户是否继续 
			System.out.println("是否继续添加 y/n"); 
			char key = myScanner.next().charAt(0); 
			if( key == 'n') { 
				//如果输入 n ,就结束 
				break; 
			} 
		}while(true); 
		System.out.println("你退出了添加..."); 
	} 
}

课后练习题:
要求：有一个数组 {1， 2， 3， 4， 5}，可以将该数组进行缩减，提示用户是否继续缩减，每次缩减最后那个元素。当只剩下最后一个元素，提示，不能再缩减。

import java.util.Scanner;
public class ArrayReduce{
	public static void main(String[] args) {
		int[] arr = {1,2,3,5,6,7,8,9};
		do {
			Scanner myScanner = new Scanner(System.in);
			int[] arrNew = new int[arr.length - 1];
			//遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组 
			for(int i = 0; i < arr.length-1 ; i++) { 
				arrNew[i] = arr[i]; 
			}
			for(int i = 0; i < arr.length-1; i++) { 
			System.out.print(arrNew[i] + "\t"); 
			}
			arr = arrNew;
			//问用户是否继续 
			System.out.println("是否继续缩减 y/n"); 
			char key = myScanner.next().charAt(0); 
			if( key == 'n'   ) { 
				//如果输入 n ,就结束 
				break; 
			}else if(arr.length==1){
				System.out.println("只剩一个元素不能继续缩减...");
				break;
			} 
		}while(true); 
		System.out.println("你退出了缩减...");
	}
}