JAVA基础——数组

最新推荐文章于 2023-07-19 19:59:41 发布

小武i

最新推荐文章于 2023-07-19 19:59:41 发布

阅读量341

点赞数 7

分类专栏： JAVA基础文章标签： java 数组

本文链接：https://blog.csdn.net/m0_53586574/article/details/119699132

版权

JAVA基础专栏收录该内容

3 篇文章 1 订阅

订阅专栏

本文详细介绍了Java中的数组，包括一维和二维数组的声明、初始化、元素访问、长度获取及遍历。讲解了数组特点、默认初始化值、异常处理，并展示了冒泡排序、查找、复制和反转等算法。还探讨了Arrays工具类的实用方法。

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

一、数组概述

1.数组的理解：数组（Array），是多个相同类型数据按一定顺序排列的集合。使用一个名字命名
,并通过编号的方式对这些数据进行统一管理。
2.数组相关的概念
  ①数组名
  ②元素
③角标、下标、索引
④数组的长度：存储元素的个数

3.数组的特点：
①数组是有序排列的。
②数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
③创建数组对象会在内存中开辟一整块连续的空间。
④数组长度一旦确定就不可以去修改。

4. 数组的分类：
① 按照维数：一维、二维等。
② 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组。

二、一维数组

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

int num; //声明
		num = 10; //初始化
		int id = 1001; //声明＋初始化
        
		int[] ids; //声明
		//静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};
		
		//动态初始化：数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];
		
		//总结：数组一旦初始化完成，其长度就确定了。

2.如何调用数组指定位置的元素：通过角标的方式调用

//数组的角标（索引）从0开始的，到数组长度-1结束。
		names[0] = "小明";
		names[1] = "小贺";
		names[2] = "小张";
		names[3] = "小孙";
		names[4] = "小朱"; //charAt(0)

3.如何获取数组的长度

//属性：length
		System.out.println(names.length);//5
		System.out.println(ids.length);

4.如何遍历数组

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

5.不同类型一维数组的默认初始化值是多少？

①数组元素是整型：0
②数组元素是浮点型：0.0
③数组元素是char型：0 或‘\u0000’,而非‘0’
④数组元素是boolean型：false
⑤数组元素是引用数据类型时：null

public class ArrayTest1 {
	public static void main(String[] args) {
		//5.数组元素的默认初始化值
		int[] arr = new int[4];
		for(int i =0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}
	System.out.println("****************");
		short[] arr1 = new short[4];
		for(int i =0;i < arr1.length;i++) {
			System.out.println(arr1[i]);
		}
		System.out.println("****************");
		float[] arr2 = new float[4];
		for(int i =0;i < arr2.length;i++) {
			System.out.println(arr2[i]);
	}
		System.out.println("****************");
		char[] arr3 = new char[4];
		for(int i =0;i < arr3.length;i++) {
			System.out.println("-------"+ arr3[i] + "****");
			}
		if(arr3[0] == 0) {
			System.out.println("你好！");
		}
		System.out.println("****************");
		boolean[] arr4 = new boolean[5];
		System.out.println(arr4[0]);
		
		System.out.println("****************");
		String[] arr5 = new String[5];
		System.out.println(arr5[0]);
		if(arr5[0] == null) {
			System.out.println("太原天气不错！");
		}
		
	}
}

//数组小练习
public class ArrayDemo {
	public static void main(String[] args) {
		
	
	int[] arr = new int[] {5,2,1,0,3,4};
	int[] index = new int[] {2,0,0,2,4,1,5,5,2,1,2};
	String tel = "";
	for(int i = 0;i < index.length;i++) {
		tel += arr[index[i]];
	}
		System.out.println("武先生");
		System.out.println("联系方式：" + tel);
}

三、二维数组

1.对于二维数组的理解

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

2.二维数组的声明和初始化

//二维数组的声明和初始化
	int[] arr = new int[] {1,2,3};//一维数组
	//静态初始化
	int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
	//动态初始化1
	String[][] arr2 = new String[3][2];
	//动态初始化2
	String[][] arr3 = new String[3][];
	
//错误情况
//	String[][] arr4 = new String[][4];
//	String[4][3] arr5 = new String[][];
//	int[][] arr1 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
	
	//正确
	int[] arr4[] = new int[][]{{1,2,3},{4,5},{6,7,8}};
	int[][] arr5 = {{1,2,3},{4,5},{6,7,8}};

3.如何去调用二维数组指定位置的元素

//调用
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]);

4.如何二维获取数组长度

//获取数组长度
	System.out.println(arr4.length);//3
	System.out.println(arr4[0].length);//3
	System.out.println(arr4[1].length);

5.如何遍历二维数组

//遍历
 for(int i = 0;i < arr4.length;i++) {
        	 
        	 for(int j = 0;j < arr4[i].length;j++) {
        	 System.out.println(arr4[i][j] + " ");
        	 }
        	 System.out.println();
        	 }

6.二维数组例题（杨辉三角）

/*
 * 使用二维数组打印一个十行的杨辉三角
 * 
 * 1.第一行有1个元素，第n行有n个元素
 * 2.每一行的第一个元素和最后一个元素是1
 * 3.第三行开始，对于非第一个元素和最后一个元素的元素，即：
 * yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
 * 
 */

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

四、关于数组的常见算法

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

/*
 * 算法的考查；求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组。包含十个元素，分别赋一些随机数，
 * 然后求出所有元素的最大值，最小值，和值，平均数，并输出出来。
 * 要求：所有随机数都是俩位数
 * 
 * [10,99]
 * 公式“(int)(Math.random() * (99 - 10 + 1) + 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() * (99 - 10 + 1) + 10) ;
		}
		//遍历
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}
		System.out.println();
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;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(arr[i] < minValue) {
				maxValue = 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 average = 0;
		average = sum / arr.length;
		System.out.println("数组元素的平均数为：" + average);
}

2.数组的复制、反转、查找（线性查找、二分法查找）

public class ArrayTest2 {
public static void main(String[] args) {
		
		String[] arr = new String[] {"jj","dd","mm","oo","qq","ss"};
		
		//数组的复制（区别于数组变量的赋值；arr1 = arr）
		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 - i - 1];
			//arr[arr.length - i - 1] = temp;
		//}
		
		//方法二：
		for(int i = 0,j = arr.length - 1;i < j;i++,j--)
		{
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++) {
			
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		
		
		//查找
		//线性查找：
		String dest = "dd";
		
		boolean isFlag = true;
		for(int i = 0; i < arr.length;i++) {
			if(dest.equals(arr[i])) {
				System.out.println("找到了指定的元素，位置为：" + i);
				break;
			}
		}
		if(isFlag) {
		System.out.println("很遗憾，没有找到哦！");
		
		}
		
		//二分法查找:
		//前提：所要查找的数组必须有序
		int[] arr2 = new int[] {-98,-35,5,78,99,65,78,43,55,79};
		
		int dest1 = -35;
		int head = 0; //初始的首索引
		int end = arr.length - 1;
		boolean isFlag1 = true;
		while(head <= end) {
			int middle = (head + end)/2;
			
			if(dest1 == arr2[middle]) {
				System.out.println("找到指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1) {
				end = middle - 1;
			}else {
				head = middle + 1;
			}
		}
		
				if(isFlag1) {
					System.out.println("很遗憾，没有找到！");
				}	
		
	}
}

3.数组的排序（冒泡排序）

public class BubbleSortTest {
public static void main(String[] args) {
		
	
	
	int[] arr = new int[]{53,44,68,-77,89,45,22,33,38};
	
	//冒泡排序
	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] + "\t");
	}
		
	}
}

五、Arrays工具类的使用

public class ArrayTest {
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,2,4};
	boolean isEquals = Arrays.equals(arr1,arr2);
	System.out.println(isEquals);
	
	
	//2.String toString(int[] a):输出数组信息
	System.out.println(Arrays.toString(arr1));
	
	//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[] arr3 = new int[] {-98,-35,5,78,99,65,78,43,55,79};
	int index = Arrays.binarySearch(arr3, 211);
	if(index >= 0) {
	System.out.println(index);
	}else {
		System.out.println("未找到");
	}
 }
}

六、数组中的常见异常

1.数组角标越界的异常：ArrayIndexOutOfBoundsExcetion

2.空指针异常：NullPointerException

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

	//情况三：
	String[] arr3 = new String[] {"aa","bb","cc"};
	arr3[0] = null;
	System.out.println(arr3[0].toString());
}
}

小武i

关注

7
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
2
评论
JAVA基础——数组

一、数组概述1.数组的理解：数组（Array），是多个相同类型数据按一定顺序排列的集合。使用一个名字命名,并通过编号的方式对这些数据进行统一管理。2.数组相关的概念①数组名②元素 ③角标、下标、索引 ④数组的长度：存储元素的个数3.数组的特点：①数组是有序排列的。②数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型③创建数组对象会在内存中开辟一整块连续的空间。④数组长度一旦确定就不可以去修改。4. 数组的分类：...
复制链接

扫一扫