1.为什么要有数组
现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，
用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。
为了解决这种问题，Java就提供了数组供我们使用
结论：
数组是存储多个变量(元素)的东西(容器)
==这多个变量的数据类型要一致 ==
2.数组定义
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
- 数组定义格式
格式1： 数据类型[] 数组名；
格式2： 数据类型 数组名[];
举例：
int[] a； 定义了一个int类型的数组a；
int a[]; 定义了一个int类型的a数组；
推荐使用第一种定义方式。
3.数组的初始化
- 1.什么是数组的初始化
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。 - 2.初始化的分类：
- a:动态初始化: 只指定长度，由系统给出初始化值
- b:静态初始化: 给出初始化值，由系统决定长度
注意事项： 这两种方式，只能使用一种，不能进行动静结合
- 3.动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
4.Java中的内存分配以及栈和堆的区别
- A:栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。 - B:堆: 存放的是所有new出来的东西
特点：
a: 每一个new出来的东西都会为其分配一个地制值。
b: 每一个变量都有一个默认的值
byte，short，int，long – 0
float，double – 0.0
char – ‘\u0000’
boolean – false
引用数据类型 – null
c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收 - C:方法区:(面向对象部分讲解)
- D:本地方法区:(和系统相关)
- E:寄存器:(cpu使用)
5.数组的内存图解☞一个数组)
定义一个数组，输出数组名称和数组中的元素值，给数组赋值，再次输出数组名称和数组中的元素值
6.数组的内存图解☞二个数组
定义两个数组，分别输出数组名称和数组中的元素值，分别给两个数组赋值，再次输出数组名称和数组中的元素值
7.数组的内存图解☞三个引用2个数组
定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重新赋值。
最后，再次输出第一个数组数组名称和元素。
8.数组的初始化静态初始化
- A:静态初始化的格式：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例： int[] arr = new int[]{1,2,3};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例： int[] arr = {1,2,3};
9.数组遍历
public class ArrayDemo2 {
public static void main(String[] args) {
int[] arr = new int[]{10, 20, 30};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
10.二维数组概述和格式
10.1二维数组格式1
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选
举例:
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
C:注意事项
A:以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
B:注意下面定义的区别
int x,y;
int[] x,y[];
区别是:
int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
x=new int[3];
y=new int[3][];
内存图解
10.2二维数组格式2
二维数组格式2
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
10.3二维数组格式
二维数组格式3
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
简化版:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
举例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};
11.二维数组遍历
案例演示
需求：二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。
public class ArrayDemo2 {
public static void main(String[] args) {
int[][] arr = new int[][]{{10, 20, 30}, {5, 6}, {6, 8}};
//二维数组的遍历
for (int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]);
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
12.二维数组☞求和
- A:案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
public class ArrayDemo3 {
public static void main(String[] args) {
/* A:
案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22, 66, 44
第二季度：77, 33, 88
第三季度：25, 45, 65
第四季度：11, 66, 99*/
// int[][] arr={{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
int[][] arr = new int[4][3];
int[] one={22, 66, 44};
int[] two={77, 33, 88};
int[] three={25, 45, 65};
int[] four={11, 66, 99};
arr[0]=one;
arr[1]=two;
arr[2]=three;
arr[3]=four;
//遍历二维数组的元素，累加求和
int sum=0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
sum+=arr[i][j];
}
}
System.out.println("总销售额"+sum);
}
}
- B:
需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
public class MyTest {
public static void main(String[] args) {
/*
* 1.每一行的第一个元素和最后一个元素都是1
* 2.从第三行开始，从第二列开始，中间的数等于上一行的前一列和本列之和
3.每一行的数据可以看作一个一维数组
然后把每一行的数据再用二维数组从起来。
* */
Scanner scanner = new Scanner(System.in);
System.out.println("请输入行数");
int n = scanner.nextInt();
//构建二维数组
int[][] arr = new int[n][n]; //
//1.把第一元素和最后一个元素置为1
for (int i = 0; i < arr.length; i++) {
arr[i][0]=1;
arr[i][i]=1;
}
//2.算出中间元素
//从第三行开始，从第二列开始，中间的数等于上一行的前一列和本列之和
for (int i = 2; i < arr.length; i++) {
for (int j = 1; j <= i; j++) {
arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
}
}
//3，打印出三角形
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <=i; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
分析:看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
步骤：
A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。
13.思考题
Java中的参数传递问题
public class MyTest2 {
public static void main(String[] args) {
//基本类型的数据，作为参数传递，形参的改变，不影响实参 值传递
//引用类型作为参数传递，形参的改变，会影响实参 引用传递
//定义两个局部变量
int a = 10;
int b = 20;
//打印变量的值
System.out.println("a: " + a + ",b: " + b);//1 10 20
//调用方法 把 a 和 b 传递过去
change(a, b);
//继续打印变量的值
System.out.println("a: " + a + ",b: " + b); //4.10 20
//定义一个数组
int[] arr = {1, 2, 3, 4, 5};
//调用方法，把数组传过去
change(arr);
//输出数组中第二个元素的值
System.out.println(arr[1]); //4
}
public static void change(int a, int b) {
System.out.println("a: " + a + ",b: " + b); //2 10 20
a = b;
b = a + b;
System.out.println("a: " + a + ",b: " + b); //3. 20 40
}
public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
