[TOC]
本单元目标
1、数组的特点和好处
2、数组的使用步骤 ★
3、数组的基本使用 ★
求和、求最值、查找、排序
4、数组的复杂使用 ★
赋值、反转
5、数组的高级使用
增删改查
6、二维数组
1、数组的特点和好处
1.1、概念
数组：其实就是一个容器，和变量很像。变量只能保存一个数，而数组可以保存一组数.
1.2、好处
1、同时开辟多个空间，语句更加简洁，且提高效率
2、分类存储，而且数组中的空间都是连续的，所以查找比较方便
1.3、特点
1、数组是多个相同类型数据的组合，实现对这些数据的统一管理
2、数组中的元素可以是任何数据类型，包括基本类型和引用类型(定义)
3、数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量
数组名又称为对象名或引用名
注意：引用类型的变量名(也叫对象名)存放在栈中，值(也叫对象)存放在堆中！
基本类型的变量名和值都存放在栈中
image
1.4、数组的四要素
1、数组类型
2、数组名(对象名或引用)
3、数组元素(多个)
4、下标(从0开始，到数组的长度-1)
访问数组的元素，不是仅仅通过数组名,而是通过数组名+下标
语法：score[下标]
2、数组的使用步骤
2.1、数组的动态初始化
class ArrayDemo1
{
public static void main(String[] args)
{//步骤1：声明(仅仅告诉jvm要开辟房间保存多个元素)
//语法：数据类型[] 数组名;或 数据类型 数组名[];
int[] arr;
//步骤2：开辟空间(在堆中开辟指定长度的空间,并且系统自动为每个成员赋予初始值)
//语法：数组名 = new 数据类型[长度];
/*
int 0
double 0.0
char \u0000
boolean false
String null
*/
arr = new int[5];
//可以合二为一
int[] arr2 = new int[5];
//步骤3：手动赋值
arr[0] = 100;//为数组中的第一个成员赋值
arr[1] = 300;//为数组中的第二个成员赋值
arr[2] = 900;//为数组中的第三个成员赋值
//arr[5] = 10000; ArrayIndexOutOfBoundsException
//arr={1,2,3};错误
//步骤4：使用
System.out.println(arr);//[I@7852e922 相当于 地址号
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[1]);
}
}//此类用于演示数组的动态初始化——赋的值有规律
class Test_
{
public static void main(String[] args)
{//1.声明并开辟空间
int[] arr = new int[5];
//2.赋值
for(int i=0;i
arr[i] = (int)(Math.random()*100+1);
}//3.使用
for(int i=0;i
System.out.println(arr[i]);
}
}
}1、声明
数据类型[] 数组名;或
数据类型 数组名[];
2、开辟空间
数组名 = new 数据类型[长度];//长度必不可少
3、手动赋值
数组名[下标] = 值;
4、使用(打印、运算、判断等)
System.out.println(数组名[下标]);
注意事项：
①数组的元素如果不赋值，也有默认值
int 0
double 0.0
char \u0000
boolean false引用类型 null
②访问数组的元素时，下标必须在0——长度-1 的范围内，否则报数组下标越界的异常
③数组的长度，可以通过 数组名.length表示，提高代码的维护性
④数组的赋值和使用，往往可以通过搭配for循环一起操作
for(int i=0;i
//每一个元素表示为：数组名[i]
}案例：
求一个班级10名同学的平均分
import java.util.Scanner;
//此类用于演示数组的动态初始化——赋的值有规律
class Test_
{
public static void main(String[] args)
{
Scanner intput = new Scanner(System.in);
double[] scores = new double[10];
for(int i=0; i
scores[i] = intput.nextDouble();
}
double sum=0;
for(int i=0;i
sum += scores[i];
}
double mean = sum /scores.length;
System.out.println(mean);
}
}2.2、数组的静态初始化
步骤1：声明并初始化
语法：数据类型[] 数组名 = new 数据类型[]{值，值，值};
或 数据类型[] 数组名 = {值，值，值};
int[] arr = {3,4,5,6,100};
//int[] arr2 = new int[] {3,4,5,6,100};
‘A’+1 转换为66
(char)('A'+1) 转为B
步骤2：使用
for(int i=0;i
//每一个元素表示为：数组名[i]
}
3、数组的基本使用
3.1、数组的最值
class ArrayUtils1
{
public static void main(String[] args)
{
//1.声明并初始化
int[] arr = new int[]{5,4,3,6,7,1};
//2.使用：求最大值
//①定义一个max，初始化为第一个元素
int max = arr[0];
int maxIndex = 0;//记录最大值的下标
//②车轮战术，进行和max的pk
for(int i=1;i
if(arr[i]>=max){
max=arr[i];
maxIndex = i;
}
}
//③获取max
System.out.println("最大值："+max+"，下标："+maxIndex);
}
}
3.2、数组的查找
class ArrayUtils1_2
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
//1.声明并初始化
String[] names = {"白眉鹰王","青易斧王","金毛狮王","紫衫龙王"};
//2.查找
System.out.println("请输入你要查找的名:");
String search = input.next();
//----------------核心的查找------------
/*
查找：线性查找、二分查找
线性查找：依次将数组中的元素提取出来和要查找进行匹配
二分查找：要求待查找的数组已经排好序，查找效率较高
*/
boolean flag = false;
for(int i=0;i
if(names[i].equals(search)){//找到了
System.out.println("找到了，下标是："+i);
flag = true;
break;
}
}
if(!flag){
System.out.println("没找到");
}
}
}
3.3、数组的排序
image
//冒泡排序：每次比较相邻两个数 小的交换到前面 每轮结束后最大的数交换到最后
class ArrayUtils1_3
{
public static void main(String[] args)
{
int[] arr = {2,3,4,1,5};
//排序
/*
i j
0 0 arr[0] vs arr[1]
1 arr[1] vs arr[2]
2 arr[2] vs arr[3]
3 arr[3] vs arr[4]
*/
for(int i=0;i
//循环操作：每一轮发生的事情
for(int j=0;j
//循环操作：每一次发生的事情(比较)
if(arr[j]
//交换两个相邻元素
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//打印
for(int i=0;i
System.out.print(arr[i]+"\t");
}
System.out.println();
}
}
4、数组的复杂使用
4.1、数组的赋值
image
基本类型的赋值：
int a = 10;
int b = a;//赋值
引用类型的赋值：
int[] arr1={1,2,3};
int[] arr2=arr1;//赋值
特点：
基本类型的赋值，赋的是值(内容)，其中一个变量对其更改不影响另外一个
引用类型的赋值，赋的是地址，两个引用共同指向一个地址(对象)，所以其中一个引用对其更改影响另外一个
//注意：如果希望引用类型赋值时，只赋内容，则可以使用循环赋值的方式，语法：
int[] array2 = new int[array1.length];
for(int i=0;i
array2[i] = array1[i];
}
4.2、数组的反转
方式一：
for(int i=0;i
//交换两个数 i vs arr.length-1-i
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
方式二：
//①创建一个新数组，长度=arr.length
int[] newArr = new int[arr.length];
//②逆序赋值
/*
i
0 arr.length-1
1 arr.length-2
*/
for(int i=0,j=arr.length-1;i
newArr[j]=arr[i];
}//③将新数组的地址赋值给arr
arr=newArr;
5、数组的高级使用
5.1、数组的添加
//----------------具体的添加业务----------
//①新建一个数组，长度=arr.length+1
int[] newArr = new int[arr.length+1];
//②依次为新数组的元素赋值
for(int i=0;i
newArr[i] = arr[i];
}
//③将add赋值到新数组的空位上
newArr[newArr.length-1] = add;
//④将newArr的地址赋值给arr
arr = newArr;
System.out.println("添加成功！");
5.2、数组的插入
class Test_
{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int[] arr = {2,3,1,4,6};
for(int i=0;i
System.out.print(arr[i]+"\t");
}
int add = input.nextInt();
int index = input.nextInt();
//1 创建一个新数组 长度 = arr.length+1
int[] new_arr = new int [arr.length+1];//2 循环赋值
for(int i=0;i
new_arr[i] = arr[i];
}//3 循环后移
for(int i=new_arr.length-1;i>index;i--) {
new_arr[i] = new_arr[i-1];
}//4 将新元素赋值到index位置上
new_arr[index] = add;
// 5 将new的数组赋值给arr
arr = new_arr;
for(int i=0;i
System.out.print(arr[i]+"\t");
}
}
}6、二维数组
6.1、理解
二维数组其实就是 一维数组的组合,也就是一维数组的定义类型又为一维数组
int[][] num;
int[] num[];
int num[][];
6.2、使用步骤
方式一：动态初始化
1.声明
数据类型[][] 数组名;或
数据类型 数组名[][];
数据类型[] 数组名[];
2.开辟空间
情况1：固定列数
数组名 = new 数据类型[行数][列数];
情况2：不固定列数
数组名 = new 数类型[行数][];
3.赋值
情况1：固定列数
for(int i=0;i
for(int j=0;j
nums[i][j]=值;
}
}情况2：不固定列数
for(int i=0;i
nums[i]=new 数据类型[长度]; //开辟空间
for(int j=0;j
nums[i][j]=值;
}
}方式二：静态初始化
1.声明并初始化
数据类型[][] 数组名={{},{},{}};
或
数据类型[][] 数组名=new 数据类型[][]{{},{},{}};
2.使用(打印、求和、最值)
for(int i=0;i
for(int j=0;j
System.out.print(nums[i][j])；
}
}
