java学习笔记之数组

最新推荐文章于 2025-11-27 17:11:16 发布

原创最新推荐文章于 2025-11-27 17:11:16 发布 · 93 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法

这篇博客详细介绍了数组的创建、操作及常见问题，包括两种创建方式和如何通过下标访问数组元素。此外，还探讨了如何在数组中寻找最大值，展示了冒泡排序的原理和代码实现，以及二分查找的基本概念和应用。通过这些内容，读者可以加深对数组操作和基础排序算法的理解。

1、数组

常用格式1 数据类型[] 数组名称 = {数据1,数据2,数据3，，，，，，，数据n}

            创建数组的同时，指定数组中的内容

常用格式2 数据类型[] = new 数据类型[数据长度]

                 数组长度通过int数据指定

数组不常用的创建方式：

创建数组，不初始化格式：数组类型[] 数组名；
数据类型[] 数组名称 = new 数据类型[]{内人1，内容2，内容3，，，内容n}

通过下标操作数组数据的方式：

给数组某个下标赋值   数组名称[] = 值

 从数组某个下标取址： 数组名称[下标]

 获取数组的长度：数组名称.length

操作数组出现的常见问题：

数组下标越界问题
空指针问题
注意：数组的长度在创建时就固定了
eg：
public static void main(String[] args) {
//创建数组的格式
//常用格式1.创建数组的同时，制定数组中的内容。
// 数据类型[] 数组名称 = {数据1,数据2,数据3…数据n};
int[] ages = {10,11,12,13,14};
//常用格式2.创建数组，并指定长度，不指定数组中的内容。
// 数据类型[] 数组名称 = new 数据类型[数组长度];
// 数组长度通过int数据指定
int[] ages2 = new int[10];
```
	//通过下标操作数组数据的方式：
	//1.	给数组某个下标 赋值：   数组名称[下标] = 值;
	ages[0] = 100;
	//2.	从数组某个下标 取值： 数组名称[下标]
	System.out.println(ages[0]);
	ages2[0] = 99;
	System.out.println(ages2[0]);
	
	
	System.out.println("------------------------");
	
	//如何获取数组的长度：  数组名称.length
	//数组的遍历
	for(int index=0;index<ages.length;index++) {
		//index: 0 1 2 3 4 
		System.out.println(ages[index]);
	}
	
	
	
	
	
	
}
```
寻找数组中的最大值（最小值差不多）

创建一个变量，用于存储遍历数组时发现的最大值
  定义一个最大值等于数组中的第一个值

```
 循环取出数组中的每一个内容，从1开始
  将数组中的每一个内容与n比较，如果比n大，就将n的值赋值给最大值
```
eg：
//寻找数组中的最大值 | 最小值
public static void main(String[] args) {
int[] nums = {10,30,40,33,22,20,11,0};
//1. 创建一个变量，用于存储遍历数组时发现的最大值
int n = nums[0];
//2. 循环取出数组中的每一个内容，从1开始
for(int i=1;i<nums.length;i++) {
//将数组中的每一个内容与n比较，如果比n大，则将n的值赋值为这个内容。
n = n<nums[i]?n:nums[i];
}
System.out.println(n);
}

冒泡排序：

原理：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

升序排列的口诀:

       N个数字来排队 

       两两相比小靠前, 

       外层 循环length-1 

       内层循环length-i-1

降序排序的口诀:

       N个数字来排队 

       两两相比大靠前, 

       外层 循环length-1 

       内层循环length-i-1

eg：

/**
 * 冒泡排序
 * @param args
 */
public static void main(String[] args) {
	int[] nums = {20,15,18,13,30,60};
	int temp;
	//外层循环控制的是， 比较的轮数。
	//外层循环次数： length-1
	for(int i=0;i<nums.length-1;i++) {
		//内层循环控制的是，每轮比较的次数
		//第i轮（i从0开始计算）， 比较次数为：length-i-1
		for(int j=0;j<nums.length-i-1;j++) {
			if(nums[j]>nums[j+1]) {
				//两两相比， 满足移动条件
				temp = nums[j];
				nums[j] = nums[j+1];
				nums[j+1] = temp;
			}
		}
	}
	
	
	//排序已经完成。 下面是遍历打印查看的过程
	for(int i=0;i<nums.length;i++) {
		System.out.println(nums[i]);
	}
	
	
	
}

二分查找（折半查找）

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺序存储结构有序排列。

原理：

首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查找后子数组。

重复以上过程，直到找到满足条件的数据，则表示查找成功，

直到子数组不存在为止，表示查找不成功。

eg：

/**
 * 二分查找（折半查找）
 */
public static void main(String[] args) {
	int[] nums = {10,20,30,40,50,60,70,80,90};
	
	//要查找的数据
	int num = 20;
	
	//关键的三个变量：
	//1.	最小范围下标
	int minIndex = 0;
	//2.	最大范围下标
	int maxIndex = nums.length-1;
	//3.	中间数据下标
	int centerIndex = (minIndex+maxIndex)/2;
	while(true) {
		System.out.println("循环了一次");
		if(nums[centerIndex]>num) {
			//中间数据较大
			maxIndex = centerIndex-1;
		}else if(nums[centerIndex]<num) {
			//中间数据较小
			minIndex = centerIndex+1;
		}else {
			//找到了数据  数据位置：centerIndex
			break;
		}
		
		if(minIndex > maxIndex) {
			centerIndex = -1;
			break;
		}
		//当边界发生变化， 需要更新中间下标
		centerIndex = (minIndex+maxIndex)/2;
	}
	
	System.out.println("位置："+centerIndex);
	
}