自学Java第四章——《数组》
4.1 数组的相关概念和名词（了解）
1、数组(array)：
一组具有相同数据类型的数据的按照一定顺序排列的集合。
把有限的几个相同类型的变量使用一个名称来进行统一管理。
2、数组名：
（1）这个数组名，代表的是一组数
（2）这个数组名中存储的整个数组的“首地址”
3、下标(index)：
我们使用编号、索引、下标来区别表示一组数当中某一个。
范围：[0,数组长度-1]
例如：for(int i = 0; i<arr.length; i++){}
4、元素(element)：
这一组中的的每一个数据都是元素。
如何表示数组元素？ 数组名[下标]
5、数组的长度(length)
数组中元素的总个数。
如何获取数组长度？ 数组名.length
注意：名称是为了沟通的方便，概念不用一字不落背下来
4.2 数组的相关语法
4.2.1 数组的声明
语法格式：
//推荐
元素的数据类型[] 数组名;
//也对，但是不推荐
元素的数据类型 数组名[];
示例：
//要存储一组整数
int[] array;
//要存储一组单字符
char[] array;
//要存储一组字符串
String[] array;
4.2.2 数组的初始化
初始化的目的：（1）确定数组的长度（2）为元素赋值
两种初始化方式：
1、动态初始化
语法格式：
//指定数组长度
数组名 = new 元素的数据类型[长度];
//为元素赋值
数组名[下标] = 值; //这个值可以是个常量值，也可以是个表达式的计算结果，也可以是键盘输入的
//如果每个元素的赋值比较有规律，通常使用for循环赋值
for(int i=0; i<长度; i++){
数组名[下标] = 值;
}
问：如果只指定数组长度，没有为元素手动赋值，那么元素有值吗？
有默认值
（1）基本数据类型
byte,short,int,long：0
float,double：0.0
char：\u0000
boolean：false
（2）引用数据类型
统统都是null
2、静态初始化
语法格式：
数组名 = new 元素的数据类型[]{值列表};
//int[] arr = new int[5]{1,2,3,4,5};//错误的
//更简洁
//当声明与静态初始化一起完成时，可以简化
元素的数据类型[] 数组名 = {值列表};
适用场合：
当数组的元素是已知的有限个时，可以使用静态初始化。
示例代码：
String[] weeks = {"monday","tuesday","wednesday","thursday","friday","saturday","sunday"};
int[] daysOfMonths = {31,28,31,30,31,30,31,31,30,31,30,31};
char[] letters = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
4.2.3 数组的遍历
for循环遍历数组：
for(int i=0; i<数组名.lenght; i++){
//或赋值
数组名[i] = 值;
//或显示
System.out.println(数组名[i])；
//或其他操作
//例如：判断是否是偶数
if(数组名[i]%2==0){
//...
}
}
4.2.4 数组的内存分析
元素是基本数据类型的一维数组内存分析：
int[] arr = {1,2,3,4,5};
int[] arr = new int[5];
for(int i=0; i<arr.length; i++){
arr[i] = i+1;
}
4.3 数组的相关算法
4.3.1 数组找最值
1、数组中找最值
思路：
（1）先假设第一个元素最大/最小
（2）然后用max/min与后面的元素一一比较
示例代码：
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
2、数组中找最值及其下标
情况一：找最值及其第一次出现的下标
思路：
（1）先假设第一个元素最大/最小
（2）然后用max/min与后面的元素一一比较
示例代码：
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
int index = 0;
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
index = i;
}
}
或
int[] arr = {4,5,6,1,9};
//找最大值
int maxIndex = 0;
for(int i=1; i<arr.length; i++){
if(arr[i] > arr[maxIndex]){
maxIndex = i;
}
}
System.out.println("最大值：" + arr[maxIndex]);
情况二：找最值及其所有最值的下标（即可能最大值重复）
思路：
（1）先找最大值
①假设第一个元素最大
②用max与后面的元素一一比较
（2）遍历数组，看哪些元素和最大值是一样的
示例代码：
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
//遍历数组，看哪些元素和最大值是一样的
for(int i=0; i<arr.length; i++){
if(max == arr[i]){
System.out.print(i+"\t");
}
}
4.3.2 数组统计：求总和、均值、统计偶数个数等
思路：遍历数组，挨个的累加，判断每一个元素
示例代码：
int[] arr = {4,5,6,1,9};
//求总和、均值
int sum = 0;//因为0加上任何数都不影响结果
for(int i=0; i<arr.length; i++){
sum += arr[i];
}
double avg = (double)sum/arr.length;
示例代码2：
int[] arr = {4,5,6,1,9};
//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
result *= arr[i];
}
示例代码3：
int[] arr = {4,5,6,1,9};
//统计偶数个数
int even = 0;
for(int i=0; i<arr.length; i++){
if(arr[i]%2==0){
even++;
}
}
4.3.3 反转
方法有两种：
1、借助一个新数组
2、首尾对应位置交换
第一种方式示例代码：
int[] arr = {1,2,3,4,5,6,7,8,9};
//(1)先创建一个新数组
int[] newArr = new int[arr.length];
//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
newArr[i] = arr[len -1 - i];
}
//(3)舍弃旧的，让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr
//(4)遍历显示
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
第二种方式示例代码：
int[] arr = {1,2,3,4,5,6,7,8,9};
//(1)计算要交换的次数： 次数 = arr.length/2
//(2)首尾交换
for(int i=0; i<arr.length/2; i++){//循环的次数就是交换的次数
//首 与 尾交换
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
//（3）遍历显示
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
4.3.4 复制
应用场景：
1、扩容
2、备份
3、截取
示例代码：扩容
int[] arr = {1,2,3,4,5,6,7,8,9};
//如果要把arr数组扩容，增加1个位置
//(1)先创建一个新数组，它的长度 = 旧数组的长度+1
int[] newArr = new int[arr.length + 1];
//(2)复制元素
//注意：i<arr.length 因位arr比newArr短，避免下标越界
for(int i=0; i<arr.length; i++){
newArr[i] = arr[i];
}
//(3)把新元素添加到newArr的最后
newArr[newArr.length-1] = 新值;
//(4)如果下面继续使用arr，可以让arr指向新数组
arr = newArr;
//(4)遍历显示
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
示例代码：备份
int[] arr = {1,2,3,4,5,6,7,8,9};
//1、创建一个长度和原来的数组一样的新数组
int[] newArr = new int[arr.length];
//2、复制元素
for(int i=0; i<arr.length; i++){
newArr[i] = arr[i];
}
//3、遍历显示
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
示例代码：截取
int[] arr = {1,2,3,4,5,6,7,8,9};
int start = 2;
int end = 5;
//1、创建一个新数组，新数组的长度 = end-start + 1;
int[] newArr = new int[end-start+1];
//2、赋值元素
for(int i=0; i<newArr.length; i++){
newArr[i] = arr[start + i];
}
//3、遍历显示
for(int i=0; i<newArr.length; i++){
System.out.println(newArr[i]);
}
4.3.5 查找
查找分为两种：
1、顺序查找：挨个看
对数组没要求
2、二分查找：对折对折再对折
对数组有要求，元素必须有大小顺序的
顺序查找示例代码：
int[] arr = {4,5,6,1,9};
int value = 1;
int index = -1;
for(int i=0; i<arr.length; i++){
if(arr[i] == value){
index = i;
break;
}
}
if(index==-1){
System.out.println(value + "不存在");
}else{
System.out.println(value + "的下标是" + index);
}
二分查找示例代码：
/*
2、编写代码，使用二分查找法在数组中查找 int value = 2;是否存在，如果存在显示下标，不存在显示不存在。
已知数组：int[] arr = {1,2,3,4,5,6,7,8,9,10};
*/
class Exam2{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7,8,9};//数组是有序的
int value = 2;
int index = -1;
int left = 0;
int right = arr.length - 1;
int mid = (left + right)/2;
while(left<=right){
//找到结束
if(value == arr[mid]){
index = mid;
break;
}//没找到
else if(value > arr[mid]){//往右继续查找
//移动左边界，使得mid往右移动
left = mid + 1;
}else if(value < arr[mid]){//往左边继续查找
right = mid - 1;
}
mid = (left + right)/2;
}
if(index==-1){
System.out.println(value + "不存在");
}else{
System.out.println(value + "的下标是" + index);
}
}
}
使用for
class Exam2{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7,8,9};//数组是有序的
int value = 2;
int index = -1;
for(int left=0,right=arr.length-1,mid = (left+right)/2; left<=right; mid = (left + right)/2){
//找到结束
if(value == arr[mid]){
index = mid;
break;
}//没找到
else if(value > arr[mid]){//往右继续查找
//移动左边界，使得mid往右移动
left = mid + 1;
}else if(value < arr[mid]){//往左边继续查找
right = mid - 1;
}
}
if(index==-1){
System.out.println(value + "不存在");
}else{
System.out.println(value + "的下标是" + index);
}
}
}
4.3.6 排序
数组的排序算法有千万种，我们只讲了两种：
1、冒泡排序
2、简单的直接排序
示例代码：冒泡：从小到大，从左到右两两比较
int[] arr = {5,4,6,3,1};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
/*
第1轮，i=1,从左到右两两比较，arr[0]与arr[1]。。。。。arr[3]与arr[4]
第2轮，i=2,从左到右两两比较，arr[0]与arr[1]。。。。。arr[2]与arr[3]
...
arr[j]与arr[j+1]比较
找两个关键点：（1）j的起始值：0（2）找j的终止值，依次是3,2,1,0，得出j<arr.length-i
*/
for(int j=0; j<arr.length-i; j++){
//两两比较
//从小到大，说明前面的比后面的大，就交换
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
示例代码：从大到小，从右到左
char[] arr = {'h','e','l','l','o','j','a','v','a'};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
/*
第1轮，i=1，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[1]与arr[0]
第2轮，i=2，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[2]与arr[1]
...
第8轮，i=8，从右到左两两比较，arr[8]与arr[7]
arr[j]与arr[j-1]
找两个关键点：（1）j的起始值：8（2）找j的终止值，依次是1,2,3,。。。8，得出j>=i
*/
for(int j=8; j>=i; j--){
//从大到小，后面的元素 > 前面的元素，就交换
if(arr[j]>arr[j-1]){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
}
}
示例代码：简单的直接选择排序
int[] arr = {3,2,6,1,8};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
//（1）找出本轮未排序元素中的最值
/*
未排序元素：
第1轮：i=1,未排序，[0,4]
第2轮：i=2,未排序，[1,4]
...
每一轮未排序元素的起始下标：0,1,2,3，正好是i-1的
未排序的后面的元素依次：
第1轮：[1,4] j=1,2,3,4
第2轮：[2,4] j=2,3,4
第3轮：[3,4] j=3,4
第4轮：[4,4] j=4
j的起点是i，终点都是4
*/
int max = arr[i-1];
int index = i-1;
for(int j=i; j<arr.length; j++){
if(arr[j] > max){
max = arr[j];
index = j;
}
}
//（2）如果这个最值没有在它应该在的位置，就与这个位置的元素交换
/*
第1轮，最大值应该在[0]
第2轮，最大值应该在[1]
第3轮，最大值应该在[2]
第4轮，最大值应该在[3]
正好是i-1的值
*/
if(index != i-1){
//交换arr[i-1]与arr[index]
int temp = arr[i-1];
arr[i-1] = arr[index];
arr[index] = temp;
}
}
//显示结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]);
}
4.4 二维数组
二维数组的标记：[][]
4.4.1 相关的表示方式
（1）二维数组的长度/行数：
二维数组名.length
（2）二维数组的其中一行：
二维数组名[行下标]
行下标的范围：[0, 二维数组名.length-1]
（3）每一行的列数：
二维数组名[行下标].length
因为二维数组的每一行是一个一维数组
（4）每一个元素
二维数组名[行下标][列下标]
4.4.2 二维数组的声明和初始化
1、二维数组的声明
//推荐
元素的数据类型[][] 二维数组的名称;
//不推荐
元素的数据类型 二维数组名[][];
//不推荐
元素的数据类型[] 二维数组名[];
面试：
int[] x, y[];
//x是一维数组，y是二维数组
2、二维数组的初始化
（1）静态初始化
二维数组名 = new 元素的数据类型[][]{
{第一行的值列表},
{第二行的值列表},
...
{第n行的值列表}
};
//如果声明与静态初始化一起完成
元素的数据类型[][] 二维数组的名称 = {
{第一行的值列表},
{第二行的值列表},
...
{第n行的值列表}
};
（2）动态初始化（不规则：每一行的列数可能不一样）
//（1）先确定总行数
二维数组名 = new 元素的数据类型[总行数][];
//（2）再确定每一行的列数
二维数组名[行下标] = new 元素的数据类型[该行的总列数];
//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;
（3）动态初始化（规则：每一行的列数是相同的）
//（1）确定行数和列数
二维数组名 = new 元素的数据类型[总行数][每一行的列数];
//（2）再为元素赋值
二维数组名[行下标][列下标] = 值;
4.4.3 二维数组的遍历
for(int i=0; i<二维数组名.length; i++){
for(int j=0; j<二维数组名[i].length; j++){
System.out.print(二维数组名[i][j]);
}
System.out.println();
}
如果生活变得难以忍受，我们会想到改变我们的环境。
