一、引言
现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名 员工，用前面所学的知识，程序首先需要声明80个变量来分配记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。
二、概念
是内存中一块连续的存储空间，作用为同时存放多个相同数据类型的值
三、创建
1. 先声明，后指明长度
数据类型 []数组名;//声明
数组名=new 数据类型[长度];//指明长度
int []arr;
arr=new int[3];
数据类型 []数组名;
数据类型[] 数组名;
数据类型 数组名[];
- 数组创建时必须指明长度，作用为方便内存分配空间
- 长度必须为整型
2. 声明的同时直接指明长度
数据类型[] 数组名=new 数据类型[长度];
int[] arr2 = new int[3];
3. 创建的同时直接存放数据
数据类型[] 数组名=new 数据类型[]{值1,值2,..};
int[] arr3=new int[]{10,20,30,40};
- 数组长度由值的个数决定
- 右侧[]中不可再次指明长度
4. 创建的同时直接存放数据-简写
数据类型[] 数组名={值1,值2,..};
int[] arr4 = {10, 20, 30};
- 无法先声明，后{}直接赋值
int []arr5;
arr5 = {10, 20, 30};//错误！
arr5 = new int[]{10, 20, 30};//正确
四、使用
-
通过下标操作数组元素
-
下标从0开始，至数组长度前一位结束
-
通过下标取值赋值：
取值：数组名[下标]
存值：数组名[下标]=值;
-
下标的使用不可超出范围，否则会报出数组下标越界异常
java.lang.ArrayIndexOutOfBoundsException; -
可以通过
数组名.length动态获取数组长度
//创建一个长度为3的整型数组
int[] arr = new int[3];
//往下标位置中依次存放数据
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
// arr[3] = 40; java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
//获取存放数据
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//创建数组
int[] arr2 = {10, 20, 30, 40};//0-3
//获取数组长度
System.out.println(arr2.length);//4
六、遍历
依次获取查看数组的数据
for(int i=0;i<数组名.length;i++){
//i代表下标
//通过数组名[i]获取当前正在被遍历的元素值
}
for (int i = 0; i < arr.length; i++) {
//获取当前数组元素
System.out.println(arr[i]);
}
//定义一个长度为5的整型数组并任意赋值
//要求计算数组值之和
//定义数组
int[] arr = {10, 20, 30, 40, 50};
//遍历数组
int sum=0;//累加器
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("sum: "+sum);
//定义一个长度为5的整型数组并任意赋值
//找出数组中最大的值
//定义数组
int[] arr = {11, 23, 56, 17, 45};
int max=0;//接收最大值
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
System.out.println("最大值为： "+max);
public static void main(String[] args) {
//定义一个整型数组
int[] a = {10, 20, 30, 40, 50};
method1(a);
}
//定义一个函数，传入一个整型数组，要求计算输出数组的平均值
public static void method1(int[] arr){
int sum=0;//累加器
//遍历数组
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println(sum/arr.length);
}
public static void main(String[] args) {
//创建一个整型数组，用来传参
int[] a = {10, 11, 12, 13, 14};
int[] b = method(a);
//查看返回值
for (int i = 0; i < b.length; i++) {
System.out.println(b[i]);
}
}
//定义一个函数，传入一个整型数组a,要求找出a数组中所有的偶数并返回
public static int[] method(int[] a) {
//1. 最上方定义用来返回的数组，并完整创建
//获取a数组中偶数的数量
int num=0;//累加器，接收偶数的数量
//遍历数组a
for (int i = 0; i < a.length; i++) {
//判断当前元素是否为偶数
if (a[i] % 2 == 0) {
num++;
}
}
int[] arr=new int[num];//arr长度为3：0 1 2 {10,12,14}
//2. 在操作过程中给数组进行赋值
int j=0;//表示arr数组下标
//遍历a数组
for (int i = 0; i < a.length; i++) {//a={10,11,12,13,14} 0-4
//判断当前元素是否为偶数
if (a[i] % 2 == 0) {
//将元素放入arr数组进行返回
arr[j]=a[i];//arr[2]=a[4]
j++;//使下标后移，准备做下次赋值
}
}
//3. 最下方返回该数组
return arr;
}
七、数组高级
（1）深入数组底层
-
数组是引用类型
-
底层存放：栈中存放引用名(数组名),引用名对应堆中的一块空间，堆空间中存放数组的具体信息(值)
- 引用中存放着对应的堆地址
- 程序员在操作时必须先进入栈,再由栈中存储的堆地址进入堆操作数据
-
引用类型之间相互赋值传递的是堆地址
public static void main(String[] args) {
int a = 10;
int b = a;//基本类型间相互赋值传递的是值
a++;//a+=1;
System.out.println("a: "+a);//11
System.out.println("b: "+b);//10
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2=arr1;//将arr1的堆地址赋值给了arr2
//将arr1下标为0的位置的值改成66
arr1[0] = 66;
//将arr2下标为1的位置值改成88
arr2[1] = 88;
//查看数组的值
System.out.println("arr1: ");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i]+"\t");//66 88 3 4 5
}
System.out.println();
System.out.println("arr2: ");
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+"\t");//66 88 3 4 5
}
}
-
“逢new必开”：只要执行到new关键字，堆中一定会开辟空间
-
为了保证内存空间的正常分配，数组存在默认值
默认值：是编译器给的，是空间的第一次赋值
初始值：是程序员手动第一次赋值
int : 0double : 0.0
boolean : false
char : 空
String : null
（2）数组扩容
1.步骤
- 创建一个长度更大的数组，推荐扩容两倍
- 将原数组的数据复制到新数组中
- 将原数组的地址转换为新数组地址
2.for循环实现
int[] a = {10, 20, 30, 40, 50};
//创建一个长度为2倍的数组
int[] newA = new int[a.length * 2];//{0, 0, 0, 0, 0,0,0,0,0,0}
//{10,20,30,40,50,0,0,0,0,0}
//将原数组数据复制到新数组中
for (int i = 0; i < a.length; i++) {
newA[i]=a[i];//newA[1]=a[1]
}
//将原数组的地址转换为新数组地址
a = newA;
3.System.arraycopy方法实现
- System.arraycopy(原数组名，原数组复制起始下标，新数组名，新数组存放起始下标，复制长度)
int[] a = {10, 20, 30, 40, 50};
//创建一个长度为2倍的数组
int[] newA = new int[a.length * 2];//{0, 0, 0, 0, 0,0,0,0,0,0}
//{10,20,30,40,50,0,0,0,0,0}
//将原数组数据复制到新数组中
System.arraycopy(a,0,newA,0,a.length);
//将原数组的地址转换为新数组地址
a = newA;
4.Arrays.copyOf方法实现
- 新数组地址 java.util.Arrays.copyOf(原数组名，预期的数组长度)
- 使用前需要导包java.util.Arrays
int[] a = {10, 20, 30, 40, 50};
//对a进行扩容并将返回的新数组地址赋值给原数组
a=Arrays.copyOf(a, a.length * 2);
（3）排序
1.冒泡排序
- 思路：让相邻两个位置的值进行比较，根据比较结果决定是否换位
- 特点：每轮比较之后，都会从后往前确定一个位置的值
- 实现：外层循环代表比较轮数，内层循环代表比较次数
int[] a = {3, 17, 88, 66, 99};
/* 从大到小
第1轮：
第1次（0-1）：17 3 88 66 99
第2次（1-2）：17 88 3 66 99
第3次（2-3）：17 88 66 3 99
第4次（3-4）：17 88 66 99 3
第2轮：
第1次（0-1）：88 17 66 99 3
第2次（1-2）：88 66 17 99 3
第3次（2-3）：88 66 99 17 3
第3轮：
第1次（0-1）：88 66 99 17 3
第2次（1-2）：88 99 66 17 3
第4轮：
第1次（0-1）：99 88 66 17 3
* */
for (int i = 1; i < a.length; i++) {//轮数
for (int j = 0; j < a.length-i; j++) {//次数 j=下标
//让当前的a[j]与a[j+1]进行值的比较
//从大到小
if (a[j + 1] < a[j]) {//从小到大：替换为<即可
int temp = a[j + 1];
a[j + 1] = a[j];
a[j] = temp;
}
}
}
2.选择排序
- 思路: 固定一个下标位置,让其他位置与该位置的值进行比较,根据比较结果决定是否换位
- 特点:每轮比较结束之后,固定下标位置的值能被确定
- 实现:外层循环表示固定下标,内层循环表示与其比较的下标
int[] a = {3, 17, 88, 66, 99};
/* 从大到小
固定下标0:
下标1: 17 3 88 66 99
下标2: 88 3 17 66 99
下标3: 88 3 17 66 99
下标4: 99 3 17 66 88
固定下标1:
下标2: 99 17 3 66 88
下标3: 99 66 3 17 88
下标4: 99 88 3 17 66
固定下标2:
下标3:99 88 17 3 66
下标4:99 88 66 3 17
固定下标3:
下标4: 99 88 66 17 3
* */
for (int i = 0; i < a.length - 1; i++) {//固定下标的范围
for (int j = i + 1; j < a.length; j++) {//与其比较的下标
if (a[j] > a[i]) {//从大到小:> 从小到大:<
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
3.JDK排序
- java.util.Arrays.sort(数组名)
- 使用前需要导包java.util.Arrays
int[] a = {3, 17, 88, 66, 99};
Arrays.sort(a);
扫一扫
575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
