Java基础之：数组

Posted 2020-12-21 奋斗的小范同学

Java基础之：数组

一组相同数据类型的数据，我们即称之为 数组，数组也是一种数据类型。

需要注意的是 ， 数组和String 字符串 相同，也是引用类型的。

 

数组的初始化

方式一：动态初始化

四种格式：

1. int[] arr = new int[5];

2. int arr[] = new int[5];

3. int arr[]; arr = new int[5];

4. int[] arr; arr = new int[5];

我们可以通过 ： 数组名.length （返回值为int类型） 的方式获得数组的长度，需要注意的是，数组的下标是从0开始的。

//生成一个int类型数组，放入5个数 {1,2,3,4,5}
int[] arr = new int[5];
for(int i = 0;i < arr.length;i++){
    arr[i] = i + 1;
}

　　

注意：若声明了数组，却没有赋值，则需要注意每个数据类型创建的数组默认值是什么。

int/short/byte/long默认值为0，String默认值为null，float/double默认值为0.0，char默认值为 \\u0000，boolean默认值为false.

方式二：静态初始化

两种格式：

1. int[] arr = {1,2,3};

2. int[] arr = new int[]{1,2,3};

数组的赋值

arr[0] = 1; 这就是最基本的数组赋值方式，通常我们使用循环的方式来给数组赋值。

但需要注意的是，数组是引用类型。

说明：

1. 这里声明了两个数组，第二个数组并没有生成一个新的堆空间，而是在栈中生成了一个空间指向arr1在堆中的空间。

2. arr1 与 arr2共用一个堆空间，导致了若改变arr2中的值也会影响到arr1。

3. 若要改变这一点应该让arr2重新生成一个空间，再将arr1中的内容复制到arr2中，代码如下：

int[] arr1 = {1,2,3};
int[] arr2 = new int[arr1.length];
for(int i = 0;i < arr2.length;i++){
    arr2[i] = arr1[i];
}

　　

数组灵活运用

数组逆序输出

import java.util.Scanner;
//数组元素反转
public class ArrayApply 
{
	public static void main(String[] args) {
		//要求：随机生成五个数，并将其反转打印，把数组的元素内容反转.
		//arr{1,2,3,4,5}   {5,4,3,2,1}
		
		/*
		思路分析
		1. 第一个元素和最后元素交换， 第二个元素和倒数第二个元素交换 , 以此类推
		2. 交换次数 arr.length  / 2
		
		也可以使用一个中间数组 temp 先将arr放入temp中，再将temp逆序复制给arr
		*/
		
		int[] arr = {1, 2, 3, 4, 5, 10};
		int temp = 0;
		for( int i = 0 ;  i <  arr.length / 2; i++) { // i 次数， 同时下标
			
			// i = 0  i = 4 (arr.length-1-0) 
			// i = 1  i = 3 (arr.length-1- 1)
			temp = arr[i];
			arr[i] = arr[arr.length-1 - i];
			arr[arr.length-1 - i] = temp;
		}

		System.out.println("==============");

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

　　

在数组指定位置插入数据

//将一个数插入数组中的指定位置。   化繁为简的思路！！！

//1.首先考虑如何将一个数放入数组的最后，即数组扩容
//2.其次考虑如何实现数组的动态增减
//3.最后思考将数据放入数组中的指定位置
import java.util.Scanner;	//一定要注意这里需要一个分号！！
public class ArrayApply1
{
	public static void main(String[] args){
		//动态输入数组
		Scanner input = new Scanner(System.in);
		int max = 0;
		int maxIndex = 0;
		System.out.println("输入数组长度：");
		int arrLength = input.nextInt();
		int[] arr = new int[arrLength];
		System.out.println("输入数组内容：");
		for(int i = 0 ; i < arr.length ; i++){	
			arr[i] = input.nextInt();
		}

		//1.实现将一个数放入数组的最后，即数组扩容
		//		思路： 1.使用一个临时数组，temp，temp.length = arr.length+1
		//			  2.再将arr数组中的数据遍历赋值到temp中
		//		 	  3.最后将arr指向temp数组
		
//		String flag = null;	//初始化String，JVM默认分配的值也是null，所以这里可以不写null
//		do{
//			System.out.println("是否要添加数据（Y/N）");
//			flag = input.next();
//			if("Y".equalsIgnoreCase(flag)){		//equalsIgnoreCase()代表不区分大小写的比较
//				int[] temp = new int[arr.length + 1];
//				for(int i = 0 ; i < arr.length ; i++){	//先将arr赋值给temp
//					temp[i] = arr[i];
//				}
//				System.out.println("输入要添加的数据：");
//				int tempInt = input.nextInt();
//				temp[temp.length-1] = tempInt;	//将数据放在temp最后
//				arr = temp;		//栈空间中的arr指向temp数组在堆中的空间
//			}
//			System.out.println("插入数据后的数组为：");
//			for(int i = 0 ; i < arr.length ; i++){	//插入完后打印一下数组
//				System.out.print(arr[i]+ "\\t");
//			}
//			System.out.println();
//		}while(!"N".equalsIgnoreCase(flag));
		
//========================================================================================


		//2.实现数组的动态增减(默认减掉数组最后一个数据)
//		String flag = null;	//初始化String，JVM默认分配的值也是null，所以这里可以不写null
//		String flag2 ;
//		do{
//			System.out.println("是否要改变数据（Y/N）");
//			flag = input.next();
//			if("Y".equalsIgnoreCase(flag)){		//equalsIgnoreCase()代表不区分大小写的比较
//				System.out.println("增加数据或减少数据（IN/OUT）");
//				flag2 = input.next();
//				if("IN".equalsIgnoreCase(flag2)){
//					int[] temp = new int[arr.length + 1];
//					for(int i = 0 ; i < arr.length ; i++){	//先将arr赋值给temp
//						temp[i] = arr[i];
//					}
//					System.out.println("输入要添加的数据：");
//					int tempInt = input.nextInt();
//					temp[temp.length-1] = tempInt;	//将数据放在temp最后
//					arr = temp;		//栈空间中的arr指向temp数组在堆中的空间
//				}else if("OUT".equalsIgnoreCase(flag2)){	//减掉数组的最后一位
//					int[] temp = new int[arr.length - 1];
//					for(int i = 0 ; i < temp.length ; i++){	//先将arr赋值给temp
//						temp[i] = arr[i];
//					}
//					arr = temp;		//栈空间中的arr指向temp数组在堆中的空间
//				}else{
//					System.out.println("输入错误！");
//				}
//			}
//			System.out.println("改变数据后的数组为：");
//			for(int i = 0 ; i < arr.length ; i++){	//插入完后打印一下数组
//				System.out.print(arr[i]+ "\\t");
//			}
//			System.out.println();
//		}while(!"N".equalsIgnoreCase(flag));
		
//========================================================================================

		//3.数据放入数组中的指定位置	自己的思路
//		String flag ;	
//		int inIndex;
//		do{
//			System.out.println("是否要添加数据（Y/N）");
//			flag = input.next();
//			if("Y".equalsIgnoreCase(flag)){		//equalsIgnoreCase()代表不区分大小写的比较
//				System.out.println("输入要添加数据的位置（下标）：");
//				inIndex = input.nextInt();
//				int[] temp = new int[arr.length + 1];
//				for(int i = 0 ; i < arr.length ; i++){	//先将arr赋值给temp，i表示arr数组的下标
//					if(i == inIndex){		
//						temp[i] = 0;	//将要插入的位置空出
//						temp[i+1] = arr[i];		//由于将temp这个位置空出来了，所以arr[i]赋值给下一个位置
//					}else if(i < inIndex){
//						temp[i] = arr[i];	//将要插入位置前面的数据放入
//					}else{
//						temp[i+1] = arr[i];
//						//将要插入位置后面的数据放入，由于空出了一个位置所以这里需要i+1
//					}
//				}
//				System.out.println("输入要添加的数据：");
//				int tempInt = input.nextInt();
//				temp[inIndex] = tempInt;
//				arr = temp;		//栈空间中的arr指向temp数组在堆中的空间
//			}
//			System.out.println("插入数据后的数组为：");
//			for(int i = 0 ; i < arr.length ; i++){	//插入完后打印一下数组
//				System.out.print(arr[i]+ "\\t");
//			}
//			System.out.println();
//		}while(!"N".equalsIgnoreCase(flag));

		//3.数据放入数组中的指定位置	韩顺平老师的思路
		String flag ;	
		int inIndex;
		do{
			System.out.println("是否要添加数据（Y/N）");
			flag = input.next();
			if("Y".equalsIgnoreCase(flag)){		//equalsIgnoreCase()代表不区分大小写的比较
				System.out.println("输入要添加数据的位置（下标）：");
				inIndex = input.nextInt();
				//加入一个判断下标是否正确的语句
				if(!(inIndex >= 0 && inIndex <= arr.length)){ 
					//满足条件执行，那么取反则不执行，这样易于代码的阅读
					System.out.println("输入下标错误，应该在0-"+arr.length+"之间！");
					continue;
				}else{
					int[] temp = new int[arr.length + 1];
					
					//这里需要 i < temp.length ， 因为 i 不再是表示arr的下标，而是temp的下标
					for(int i = 0,j = 0 ; i < temp.length ; i++){	//j表示arr的下标
						if(i != inIndex){		//到了插入的位置，直接跳过temp数组的这个位置	
							temp[i] = arr[j];
							j++;
						}
					}

					System.out.println("输入要添加的数据：");
					int tempInt = input.nextInt();
					temp[inIndex] = tempInt;
					arr = temp;		//栈空间中的arr指向temp数组在堆中的空间
				}
			}
			System.out.println("插入数据后的数组为：");
			for(int i = 0 ; i < arr.length ; i++){	//插入完后打印一下数组
				System.out.print(arr[i]+ "\\t");
			}
			System.out.println();
		}while(!"N".equalsIgnoreCase(flag));
	}
}