今天继续来说一下关于数组的问题.
一.数组练习
首先先来说一下关于数组的两个问题:
根据索引找元素和根据元素找索引.
1.根据索引找元素
(查表法)需求:封装一个函数,传入数字1 返回汉字一; 数字2 返回汉字二 ….
先根据需求封装一个函数
public static char findNumber(int a) {
// 需要一个容器把中文数据保存一下
char[] array = new char[]{'一','二','三','四','五','六','七'};
// 按照传入的数组查找对应的值
return array[a - 1];
}
然后在main函数中输出
har rel = findNumber(4);
System.out.println(rel);
得到结果
2.根据元素找索引
需求:定义一个数组,数组的值分别为3.6.11.22
在数组中查找11的位置
先封装一个函数
public static int findIndex(int array[] , int number) {
// 定义一个索引 为了返回值
// 如果索引的初值为0 当数组长度为零时会直接返回零
// 这样会与数组下标真正为零时混淆
// 所以定义初值为-1
int index = -1;
// 遍历数组,查找对应的索引
for (int i = 0; i < array.length; i++) {
// 如果值相等 就保存索引
if (array[i] == number) {
// return返回值
// 这里已经把值返回了,相当于程序结束了
// 后面再写代码就没有意义了
index = i; // 保存查找出来的下标
break;// 只要有相等的值 就停止循环
}
}
// 把查找到的下标返回
return index;
}
在main函数中输出
int[] array = new int[] {3,6,11,22};
int index = findIndex(array, 11);
System.out.println(index);
得到结果
二.数组的反转
根据字面意思解释下就是说把原数组中的元素的位置进行改变 .
既然要改变元素位置,先来看看怎么改变其中两个元素的位置
1.需求:编写一个函数 交换两个数的值
public static void change(int a,int b) {
int temp = 0;//定义空值存放数据
temp = a;
a = b;
b = temp;
System.out.println("a = " + a + " " + "b = " + b);
}
在main函数中输出
public static void main(String[] args) {
change(3,4);
}
得到结果
2.反向输出数组
接下来就是怎么实现数组的反转了.下面给出实例:
需求:反响输出数组int[] array = new int[] {1,2,3,4,5,6};
计算的规律:
array[0] 和 array[array.length - 1 - 0]交换
array[1] 和 array[array.length - 1 - 1]交换
array[2] 和 array[array.length - 1 - 2]交换
–>
array[ i ] 和 array[array.length - 1 - i ]交换
int[] array = new int[] {1,2,3,4,5,6};
// num 表示交换的次数 *重点*
int num = array.length / 2;
for (int i = 0; i < num; i++) {
int temp = 0;
temp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
System.out.println(Arrays.toString(array));
输出结果
三.数组的排序
数组排序的方法有很多,我们主要说说冒泡排序和选择排序这两个.
1.冒泡排序
什么是冒泡排序呢?
冒泡排序是两个比较相邻的元素,如果第一个比第二个大,就交换它们俩位置下标.对每一个相邻元素作同样的工作,从开始第一对到结尾的最后一对.针对除了最后一个元素以外所有的元素重复以上的步骤,直到没有任何一对数组需要比较.
简单来说,冒泡排序的核心就是相邻两个数比较大小,交换位置.
以数组3 2 5 1为例:
根据冒泡排序的核心分析下怎么排序
分析:
原数: 3 2 5 1
第一次排序:
3 2 5 1 –> 2 3 5 1 –> 2 3 5 1 –> 2 3 1 5 确定一个数(把最大值放在最后面)
array.length - 1 - 0 –>没有确定数减0找规律
第二次排序:
2 3 1 5 –> 2 1 3 5 又确定一个数
array.length - 1 - 1–>确定一个数就少一个数
第三次排序:
2 1 3 5 –> 1 2 3 5 又确定一个数
array.length - 1 - 2–>确定两个数就少两个数
–>
array.length - 1 - i–>确定i个数就少i个数
根据以上分析,封装一个函数
public static void sort(int array[]) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int temp = 0;
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
在main函数中输出
public static void main(String[] args) {
int[] array = new int[] {2,3,5,1};
// 传入的数组 相当于把数组的首地址传过去了
// 注意:这里是地址的传递
// 拿到地址 就可以随便更改数组元素的位置
// 这时sort函数中 就是对原数组的操作
sort(array);
输出结果
2.选择排序
选择排序是首先在未排序序列中找到最小元素,存放到排序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列的末尾. 以此类推,直到所有元素均排序完毕
简单来说,选择排序的核心是选择一个数与下一个数进行比较(用这个数和数组中的每一个数进行比较). 一般来说,就选数组下标第0个数交换位置
同样以3 2 5 1为例:
int[] array = new int[] {3,2,5,1};
// 外循环 -1 --> 最后一个数不用比较
// 内循环 j 的初始值要从1开始
// 因为array[0] 和 array[0]不用比较
// 内循环 +i --> 每一趟比较确定一个数
// 也就是说每次都可以少比一个数
for (int i = 0; i < array.length - 1; i++) {
for (int j = 1 + i; j < array.length; j++) {
if (array[j] < array[i]) {
/*
* 分析: 谁 和 谁进行交换
* array[i] 和 array[j]进行比较并换位
* array[j] 每一个数
* array[i] 确定一个数
*/
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
System.out.println(Arrays.toString(array));
输出结果
但实际上日常的开发中,我们都是优先使用系统给出的数组排序方法,系统给你的方法肯定比你自己写的好:
int[] array = new int[] {7,5,10,56,3,18};
// 该方法没有返回值 实际上这个方法操作的是原数组
Arrays.sort(array); // -->数组排序
System.out.println(Arrays.toString(array));
得到结果
四.二维数组
二维数组说白了就和一维数组一样,也是容器,保存的是多个一维数组并且是相同类型的一维数组.
声明方式和一维数组一样,主要的声明方式是:
数据类型[][] 数组名 = 初值;
声明方式也是两种:
1.声明方法一:
// 声明了有两个一维数组 并且每个一维数组中是三个元素的二维数组
// 注意:声明时需要把它有几个一维数组声明出来
// 声明方式一:
/*int[][] array = new int[2][3];
array[0][0] = 8;
System.out.println(array[0][0]);*/
2.声明方式二:
int[][] array = new int[][]{
{1,2,3,4}, // array[0].length
{2,5,8,0}, // array[1].length
{1,3,1,4}, // array[2].length
};
3.遍历二维数组
二维数组和一维数组一样,也是有遍历的:
int[][] array = new int[][]{
{1,2,3,4}, // array[0].length
{2,5,8,0}, // array[1].length
{1,3,1,4}, // array[2].length
};
// array.length 二维数组的长度指的是 有几个一维数组
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
输出结果