第四节 数组
1、概述
数组是相同数据类型的多个数据的容器。
这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个 元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。
2、创建格式
2.1、常用格式
格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
2.2、非常用格式
格式 3. 数据类型[] 数组名;
格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n};
示例：
public class Demo {
public static void main(String[] args) {
//数组不常用的创建方式：
//1. 创建数组 ， 不初始化
//格式： 数据类型[] 数组名;
short s = 1;
s += 1;
int[] nums;
//2. 创建数组， 并指定数组中的内容
//格式： 数据类型[] 数组名称 = new 数据类型[]{内容1,内容2,内容3...内容n};
int[] ages = new int[] {11,12,13,14};
}
}
3、下标
可以理解为数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0~n-1。
可以通过下标的方式访问数组中的每一个元素。
例如： 创建 int 类型数组 arr ， 给数组 arr 的 5 下标赋值数据 ， 然后打印
int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);
4、数组长度获取
示例：
public class Demo1 {
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]);
}
}
}
5、注意事项：
使用数组不当， 会出现如下问题：
数组未赋值： 空指针异常
超出长度的下标操作： 数组越界异常
示例：
public class Demo2 {
public static void main(String[] args) {
//常见问题：
// 1. 数组下标越界问题：
//int[] nums = {10,11,12,13,14};
//System.out.println(nums[5]);
// 2. 空指针问题
int[] nums = null;
System.out.println(nums[1]);
}
}
注意：数组的长度在创建时就固定了。java数组不能修改、删除、添加元素
将数组转化为List，然后使用List提供的方法来删除对象，然后再将List转换为数组。
数组是在大小是固定的 删除元素后不会减少数组的大小只能创建一个新的数组，将剩下的元素拷贝到新的数组中。
6、数组常用算法
6.1、寻找最值(最大或最小值)
循环遍历数组挨个比较得出最大或者最小值
public class Demo3 {
//寻找数组中的最大值 | 最小值
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);
}
}
6.2、冒泡排序
原理：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。
- 在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
名字由来:
是因为最小（或最大）的元素会经由交换慢慢“浮”到数列的顶端（降序或升序），
就如同水中的气泡最终会上浮到
顶端一样，故名“冒泡排序”。
升序排列的口诀:
N个数字来排队
两两相比小靠前,
外层 循环length-1
内层循环length-i-1
降序排序的口诀:
N个数字来排队
两两相比大靠前,
外层 循环length-1
内层循环length-i-1
示例：
public class Demo4 {
/**
* 冒泡排序
*
*/
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]);
}
}
}
6.3、二分查找 （折半查找）
6.3.1、概述
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。
但是，二分查找要求数组数据必须采用顺序存储结构有序排列。
6.3.2、原理
首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用
中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查
找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功，
直到子数组不存在为止，表示查找不成功。
示例：
public class Demo5 {
/**
* 二分查找（折半查找）
*/
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);
}
}
扫一扫
1622
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
