数组
使用变量可以存储单个值，比如存5个人分数
int score1 = 99;
int score2 = 78;
int score3 = 69
int score4 = 83;
int score5 = 100;
这样虽然可以完成目标，但是繁琐。
1.初识数组
public class Array1{
public static void main(String[] args){
// 1.声明数组
int[] arr;
// 2.创建数组
arr = new int[5];
// 3.元素赋值
arr[0] = 99;
arr[1] = 78;
arr[2] = 69;
arr[3] = 83;
arr[4] = 100;
// 4.打印展示
for(int i = o; i < arr.length ; i++){
System.out.println(arr[i]);
}
}
}
2.使用数组
把大象放入冰箱步骤：
(1) 打开冰箱;
(2) 塞入大象;
(3) 关上冰箱!
2.1 数组创建
2.1.1 声明数组
# 格式如下:
dataType [] arrayNmae;
int[] arr1;
double[] arr2;
String[] arr3;
char[] arr4;
......
2.1.2 数组基本元素
- 数组数据类型声明
dataType
- 数组变量名
arrName
- 数组长度
[size]
arrName.length
- 数组下标索引
从零开始
2.1.3 创建数组
一. 静态初始化
#格式如下:
arrName = new dataType[size];
arr1 = new int[5];
arr2 = new double[10];
arr3 = new String[10];
arr4 = new char[10];
以上操作两步骤:
一.使用dataType[size]创建了一个数组
二.把新创建的数组引用赋值给arrName
以上步骤可以简化如下
dataType[] arrName = new dataType[size];
可以再进一步简化:
dataType[] arrName = {val1, val2 ... valk};
此时虽然没有声明数组的长度，但是JVM可以自动推断合适长度
二.动态初始化
语法如下:
// 声明数组, 指定长度
数组名 = new 元素数据类型[长度]
//循环动态赋值
for(int i = 0; i<长度; i++){
数组名[i] = 值;
}
2.2 数组操作/分析
2.2.1 遍历操作
语法格式
for(int i = 0; i<长度; i++){
// 赋值操作
数组[下标] = 值;
//或者显示
System.out.println(i);
//或者其他操作
...
}
2.2.2 简单数组分析
int[] arr;
arr = new int[5];
arr[0] = 1;
arr[1] = 3;
arr[2] = 5;
arr[3] = 7;
arr[4] = 9;
(1) 首先在栈上生成变量arr
(2) arr变量指向堆上面一块区域；这块区域分配有5个大小相同房子。此时, arr变量指向的是这块区域首地址；
(3) 通过下标索引进行赋值，从而一一排列
2.2.3 动态数组内存分析
int[] arr = new int[5];
for(int i=0; i<arr.length; i++){
arr[i] = i+1;
}
3.数组算法
3.1 找最值
思路:
(1) 先找一个基准值
(2) 然后用基准值依次跟其他值比较
int[] arr = {4, 8, 9, 3, 7, 1};
// 假设基准值为 arr[0]
int base = arr[0];
for(int i = 1; i<arr.length; i++){
if(base > arr[i]){
base = arr[i];
}
}
演变 找最值及其下标
思路1:
(1) 先找一个基准值
(2) 然后用基准值依次跟其他值比较
(3) 需要申请两个变量保存最值和下标
int[] arr = {4, 8, 9, 3, 7, 1};
// 假设基准值为 arr[0]
int base = arr[0];
int minIndex = 0;
for(int i = 1; i<arr.length; i++){
if(base > arr[i]){
base = arr[i];
minIndex = i;
}
}
思路2:
一个变量完成
int[] arr = {4, 8, 9, 3, 7, 1};
int maxIndex = 0;
for(int i=1; i<arr.length; i++){
if(arr[i] < arr[maxIndex]){
maxIndex = i;
}
}
System.out.println("最大值：" + arr[maxIndex]);
3.2 找最值及其所有下标
思路:
(1) 先找一个基准值
(2) 然后用基准值依次跟其他值比较
(3) 找到结果和其他对比是否相同
int[] arr = {1, 3, 5, 7, 1, 9, 1};
int result = 0;
for(int i = 1; i<arr.length; i++){
if(arr[result] > arr[i]){
result = i;
}
}
for(int i = 0; i<arr.length; i++){
if(arr[result] == arr[i]){
System.out.print(i + "/t/t");
}
}
3.2 数组统计、求和、平均值操作
3.2.1 求和操作
遍历全部元素，依次累加
int[] arr1 = {2, 5, 8, 12, 9};
int sum = 0;
for(int i = 0; i<arr1.length; i++){
sum += arr1[i];
}
System.out.println(sum);
3.2.2 求均值
int[] arr2 = {2, 5, 8, 12, 9};
int sum = 0;
double num = 0;
double avg ;
for(int i = 0; i<arr2.length; i++){
sum += arr2[i];
num++;
avg = sum / num;
}
System.out.println(avg );
3.2.3 求奇数个数
int[] arr2 = {2, 5, 8, 12, 9};
int sum = 0;
int num = 0;
for(int i = 0; i<arr2.length; i++){
if(arr2[i] % 2 != 0){
num++;
}
}
System.out.println(num);
3.3 数组反转操作
方法一 : 借助新数组进行置换
通过首尾交换位置
int[] arr3 = {1,2,3,4,5,6,7,8,9};
// 1.创建新数组
int[] newArray = new int[arr3.lenght];
// 2.元素复制
int len = arr3.length;
for(int i = 0; i<arr3.length; i++){
newArray[i] = arr3[len - 1 - i];
}
// 3.重新指向新的数组
arr3 = newArray;
方法二: 原地反转
int[] arr3 = {1,2,3,4,5,6,7,8,9};
// 1.计算交换次数 arr3.length / 2
// 2.借助第三方变量交换
int temp = 0;
for(int i = 0; i<arr3.length / 2; i++){
temp = arr3[i];
arr3[i] = arr3[arr3.length - 1 - i];
arr3[arr3.length - 1 - i] = temp;
}
3.4 复制
应用:
-
扩容
-
备份
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]);
}
3.5 查找
- 顺序查找
对数组没要求
例子:
int[] arr4 = {4, 5, 9, 3, 6, 8, 12}
int value = 6;
int index = -1;
for(int i = 0; i<arr4.length; i++){
if(arr4[i] == value){
index = i;
}
}
if(index != -1){
System.out.println("value的index是: " + index);
}else{
System.out.println("404 Not found!")
}
- 二分查找
对数组要求： 必须是按序排列
int[] arr5 = {1, 3, 5, 7, 9. 11, 13, 15,17};
int value = 13;
int index = -1;
int left = 0;
int right = arr5.length - 1;
int mid = (left + right) / 2;
while(left < right){
if(value == arr5[mid]){
index = mid;
break;
}else if(value > arr[mid]){
left = mid + 1;
}else{
right = mid - 1;
}
}
if(index != -1){
System.out.println("value的index是: " + index);
}else{
System.out.println("404 Not found!");
}
for 循环改写
int[] arr5 = {1,3,5,7,11,13,15,17,19};
int value = 13;
int index = -1;
for(int left = 0, right = arr5.length - 1, mid = (right + left) / 2; left <= right; mid = (right + left) / 2 ){
if(value == arr5[mid]){
index = mid;
break;
}else if( value > arr5[mid]){
left += 1;
}else if(value < arr[mid]){
right -= 1;
}
}
if(index == -1){
System.out.println("404 Not found!");
}else{
System.out.println("value的index是: " + index);
}
3.6 排序
- 冒泡排序
例子
int[] arr = {5, 8, 4, 2, 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 i = 0; i<arr.length; i++){
//两两比较
//从小到大，说明前面的比后面的大，就交换
for(int j = 1; j<arr.length - i; j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j+1] = arr[j];
arr[j] = 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.1 相关表示方式
（1）二维数组的长度/行数：
二维数组名.length
（2）二维数组的其中一行：
二维数组名[行下标]
行下标的范围：[0, 二维数组名.length-1]
（3）每一行的列数：
二维数组名[行下标].length
因为二维数组的每一行是一个一维数组
（4）每一个元素
二维数组名[行下标][列下标]
4.2二维数组的声明初始化
1、二维数组的声明
//推荐
元素的数据类型[][] 二维数组的名称;
2、二维数组的初始化
（1）静态初始化
二维数组名 = new 元素的数据类型[][]{
{第一行的值列表},
{第二行的值列表},
...
{第n行的值列表}
};
//如果声明与静态初始化一起完成
元素的数据类型[][] 二维数组的名称 = {
{第一行的值列表},
{第二行的值列表},
...
{第n行的值列表}
};
（2）动态初始化（不规则：每一行的列数可能不一样）
//（1）先确定总行数
二维数组名 = new 元素的数据类型[总行数][];
//（2）再确定每一行的列数
二维数组名[行下标] = new 元素的数据类型[该行的总列数];
//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;
3.二维数组的遍历
for(int i=0; i<二维数组名.length; i++){
for(int j=0; j<二维数组名[i].length; j++){
System.out.print(二维数组名[i][j]);
}
System.out.println();
}
京公网安备 11010502036488号