目录
- 数组
- 静态初始化数组
- 数组的访问
- 数组的动态初始化
- 元素默认值规则：
- 数组的遍历
- 数组遍历-求和
- 冒泡排序
- 数组的逆序交换
数组
数组就是用来存储一批同种类型数据的容器。
20, 10, 80, 60, 90
int[] arr = {20, 10, 80, 60, 90};
//位置 0 1 2 3 4
数组的位置是从0开始的；
数组的初始化
- 分为静态初始化，动态初始化、
静态初始化数组
通俗的讲：定义数组的时候直接给数组赋值。
静态初始化数组的格式：
// 完整格式
数据类型[] double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] arr = new int[]{12, 24, 36}
数组名 = new 数据类型[]{元素1，元素2 ，元素3… };
// 简化格式
数据类型[] 数组名 = { 元素1，元素2 ，元素3，… };
int[] arr = {12, 24, 36};
注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型。
数组的访问
取值
格式：数组名称[索引]
赋值
格式：数组名称[索引] = 数据
int[] arr = {12, 24, 36};
//位置 0 1 2
// 取值： 数组名称[索引]
System.out.println(arr[0]);//12
System.out.println(arr[1]);//24
System.out.println(arr[2]);//36
// 赋值：数组名称[索引] = 数据;
arr[2] = 100;
System.out.println(arr[2]); // 100
// 访问数组的长度 数组名称.length
System.out.println(arr.length);
数组的动态初始化
数组的动态初始化格式：
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = {12, 24, 36};
//位置 0 1 2
//数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];
// 后赋值
arr[0] = 10;
System.out.println(arr[0]); // 10
元素默认值规则：
| 数据类型 | 明细 | 默认值 |
| 基本类型 | byte、short、char、int、long | 0 |
| float、double | 0.0 | |
| boolean | false | |
| 引用类型 | 类、接口、数组、String | null |
| 数据类型 | 明细 | 默认值 |
|---|---|---|
| 基本类型 | byte、short、char、int、long | 0 |
| float、double | 0.0 | |
| boolean | false | |
| 引用类型 | 类、接口、数组、String | null |
// 1、整型数组的元素默认值都是0
int[] arr = new int[10];
System.out.println(arr[0]);
System.out.println(arr[9]);
// 2、字符数组的元素默认值是多少呢？ 0
char[] chars = new char[100];
System.out.println((int)chars[0]);
System.out.println((int)chars[99]);
// 3、浮点型数组的元素默认值是0.0
double[] scores = new double[90];
System.out.println(scores[0]);
System.out.println(scores[89]);
// 4、布尔类型的数组
boolean[] booleans = new boolean[100];
System.out.println(booleans[0]);
System.out.println(booleans[99]);
// 5、引用类型的数组
String[] names = new String[90];
System.out.println(names[0]);
System.out.println(names[89]);
注意：
- 动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
- 静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。
- 两种格式的写法是独立的，不可以混用。
数组的遍历
代码：
int[] ages = {20, 30, 40, 50};
for (int i = 0; i < ages.length; i++) {
System.out.println(ages[i]);
}
数组遍历-求和
需求：某部门5名员工的销售额分别是：20、16、36、3、100，请计算出他们部门的总销售额。
分析
-
把这5个数据存储在数组中
int[] money = {16, 16, 36, 3, 100}; -
遍历数组中的每个数据，然后在外面定义求和变量把他们累加起来。
int sum = 0; for (int i = 0; i < money.length; i++) { // i = 0 1 2 3 4 sum += money[i]; }
冒泡排序
1、定义一个数组，存储一些数据啊
2、定义一个循环控制比较的轮数
核心代码
if(arr[j] > arr[j+1]) {
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
代码：
public static void main(String[] args) {
// 1、定义一个数组，存储一些数据啊
int[] arr = {5, 2, 3, 1};
// 0 1 2 3
// 2、定义一个循环控制比较的轮数
for (int i = 0; i < arr.length - 1; i++) {
// i == 0 比较的次数 3 j = 0 1 2
// i == 1 比较的次数 2 j = 0 1
// i == 2 比较的次数 1 j = 0
// 3、定义一个循环控制每轮比较的次数，占位
for (int j = 0; j < arr.length - i - 1; j++) {
// 判断j当前位置的元素值 是否 大于后一个位置 若较大 则交换
if(arr[j] > arr[j+1]) {
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
// 遍历数组内容输出
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
数组的逆序交换
/*
把一个数组的元素逆序交换，
int[] a = { 5, 11, 15, 24, 36, 47, 59, 66 };
交换元素后
int[] b = { 66 ,59 ,47 ,36 ,24,15 ,11 ,5 };
*/
public static void main(String[] args) {
int[] a = {5, 11, 15, 24, 36, 47, 59, 66};
int[] b = new int[8];
for (int i = 0; i < 8; i++) {
b[i] = a[a.length - 1 - i];
}
System.out.println(Arrays.toString(b));
}
