概述
数组是一个引用类型，是一种容器。
数组存储多个相同数据类型的数据，允许自动类型转换。例如 int 类型的数组，可以存放 byte、short 和 int 类型的数据，double 类型的数组，可以存放 byte、short、int、long、float 和 double 类型的数据。boolean 类型的数据不能存放进 int 类型或者 double 类型的数组中。
程序示例：
public class array1 {
public static void main(String[] args) {
double[] hens = {1, 2, 3}; // 定义数组
// 数组名为 hens，数组的类型为 double[]，数组中的元素的类型为 double
// 遍历数组
for (int i = 0; i < hens.length; i++) {
System.out.println(hens[i]);
}
}
}
数组定义之后，长度就固定了，不能再发生变化。
获取数组元素个数：数组名.length
数组名是一个地址：
public static void main(String[] args) {
double[] double1 = {1.1, 2.2, 3, 4, 5};
System.out.println(double1); // [D@119d7047
float[] float1 = {1.1F, 2.2F, 3, 4, 5};
System.out.println(float1); // [F@776ec8df
long[] long1 = {1, 2, 3};
System.out.println(long1); // [J@4eec7777
int[] int1 = {1, 2, 3};
System.out.println(int1); // [I@3b07d329
short[] short1 = {1, 2, 3};
System.out.println(short1); // [S@41629346
byte[] byte1 = {1, 2, 3};
System.out.println(byte1); // [B@404b9385
boolean[] boolean1 = {false, false, true, false, true};
System.out.println(boolean1); // [Z@6d311334
char[] char1 = {'1', '2', '3'};
System.out.println(char1); // 123
String[] String1 = {"Hello", "World"};
System.out.println(String1); // [Ljava.lang.String;@682a0b20
}
结果前面的字母指出了数组元素的类型。结果最前面的 [ 表示是一个数组。@ 后面的内容才是真正的地址值，是一个十六进制的值。平时习惯性地将整个结果称为地址，但实际上只有 @ 后面的才是真正的地址。@ 是间隔符号，是一个固定的格式。
对于字符数组，打印数组名得到的结果比较特殊：
public static void main(String[] args) {
char[] char1 = {'1', '2', '3'};
System.out.println(char1); // 123
char[] char2 = {'1', '2', '3', '9'};
System.out.println(char2); // 1239
char[] char3 = {'9', '8', '7'};
System.out.println(char3); // 987
}
数组的动态初始化 1
数组的初始化：在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
数组初始化有两种方式：动态初始化和静态初始化。
动态初始化：初始化时只指定数组的长度，由虚拟机为数组分配初始值。
动态初始化的数组的定义：
数据类型 数组名[] = new 数据类型[数组长度];
或者：
数据类型[] 数组名 = new 数据类型[数组长度]; // 两者等价，但是推荐使用这一种
不同数据类型的数组，默认的初始值不同。
int 类型默认初始值为 0
short 类型默认初始值为 0
byte 类型默认初始值为 0
long 类型默认初始值为 0
float 类型默认初始值为 0.0
double 类型默认初始值为 0.0
char 类型默认初始值为 \u0000 (零字符)，打印出来就是一个空格。
boolean 类型默认初始值为 false
引用数据类型默认初始值为 NULL
程序示例：
public class array1 {
public static void main(String[] args) {
double[] hens = new double[3]; // 定义数组
int[] kens = new int[4];
double sumHens = 0;
int sunKens = 0;
// 遍历数组
for (int i = 0; i < hens.length; i++) {
System.out.print(hens[i] + "\t");
sumHens += hens[i];
}
System.out.println("");
for (int i = 0; i < kens.length; i++) {
System.out.print(kens[i] + "\t");
sunKens += kens[i];
}
System.out.println();
System.out.println(sumHens);
System.out.println(sunKens);
}
}
结果：
0.0 0.0 0.0
0 0 0 0
0.0
0
程序示例：
public class array1 {
public static void main(String[] args) {
byte[] bytes = new byte[10];
short[] shorts = new short[10];
int[] ints = new int[10];
long[] longs = new long[10];
char[] chars = new char[10];
boolean[] booleans = new boolean[10];
float[] floats = new float[10];
double[] doubles = new double[10];
String[] Strings = new String[10];
System.out.println(bytes[0]); // 0
System.out.println(shorts[0]); // 0
System.out.println(ints[0]); // 0
System.out.println(longs[0]); // 0
System.out.println(chars[0]);
System.out.println(booleans[0]); // false
System.out.println(floats[0]); // 0.0
System.out.println(doubles[0]); // 0.0
System.out.println(Strings[0]); // null
}
}
执行结果：
0
0
0
0
false
0.0
0.0
null
程序示例：
// 空字符 \u0000 打印出来就是一个空格
public class array1 {
public static void main(String[] args) {
System.out.println("Hello\u0000World!"); // Hello World!
}
}
-
数组的动态初始化 2
先声明数组，语法：
数据类型 数组名[];
或者：
数据类型[] 数组名;
再创建数组，语法：
数组名 = new 数据类型[数组长度];
例如：
int[] a; // 或者 int a[]; 此时还没有在内存中为 a 分配空间，a 是 NULL
a = new int[10]; // 此时在内存中为 a 分配了空间，只有分配了存储空间，才能存放数据，否则报错，显示空指针异常
其实就是把方式 1 分两步写了。
错误代码：
在未分配空间的情况下，访问数组的长度：
public class array1 {
public static void main(String[] args) {
double[] a;
System.out.println(a.length); // 可能尚未初始化变量 a
}
}
数组的静态初始化
语法：
完整格式：
数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, ... , 元素n};
例如：
int[] arr1 = new int[]{1, 2, 3};
double[] arr2 = new double[]{1.1, 2.2, 3.3};
简化格式：
数据类型[] 数组名 = {元素1, 元素2, ... , 元素n};
或者：
数据类型 数组名[] = {元素1, 元素2, ... , 元素n};
例如：
int[] a = {1, 2, 3}; // 等价于 int a[] = {1, 2, 3};
程序示例：
// 定义一个数组，存储 1，2，3，4，5
// 遍历数组得到每一个元素，求数组里面所有的数据和
public class array1 {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5};
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
System.out.println(sum); // 15
}
}
程序示例：
// 定义一个数组
// 存储 1，2，3，4，5，6，7，8，9，10
// 遍历数组得到每一个元素，统计数组里面一共有多少个能被 3 整除的数字
public class array1 {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int count = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] % 3 == 0)
++count;
}
System.out.println("数组中能被3整除的数字有" + count + "个。");
}
}
执行结果：
数组中能被3整除的数字有3个。
程序示例：
// 定义一个数组，存储 1，2，3，4，5，6，7，8，9，10
// 遍历数组得到每一个元素。
// 要求：
// 1、如果是奇数，则将当前数字扩大两倍
// 2、如果是偶数，则将当前数字变成二分之一
public class array1 {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println("原始数组为：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
// 处理数组
for (int i = 0; i < nums.length; i++) {
if (nums[i] % 2 == 0)
nums[i] /= 2;
else nums[i] *= 2;
}
System.out.println("\n处理之后的数组为：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
}
}
执行结果：
原始数组为：
1 2 3 4 5 6 7 8 9 10
处理之后的数组为：
2 1 6 2 10 3 14 4 18 5
程序示例：
// 需求：已知数组元素为 {33, 5, 22, 44, 55}
// 请找出数组中最大值并打印在控制台
public class array1 {
public static void main(String[] args) {
int[] nums = {33, 5, 22, 44, 55};
int max = nums[0];
for (int i = 0; i < nums.length; i++) {
max = (max > nums[i] ? max : nums[i]);
}
System.out.println("最大值为" + max);
}
}
执行结果：
最大值为55
程序示例：
// 冒泡排序
public class array1 {
public static void main(String[] args) {
int[] nums = new int[]{33, 5, 22, 44, 55};
// i 表示要比较多少趟，总趟数是数组长度减一
// 同时，i 也表示两个比较大小的元素其中之一的索引
for (int i = 0; i < nums.length - 1; i++) {
// j 表示两个比较大小的元素其中之一的索引，表示的是i元素后面的那个元素
for (int j = i + 1; j < nums.length; j++) {
if (nums[i] < nums[j]) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
}
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
}
}
执行结果：
从大到小进行排序：
55 44 33 22 5
程序示例：
// 需求：生成 10 个 1~100 之间的随机数存入数组。
// 1) 求出所有数据的和
// 2) 求所有数据的平均数
// 3) 统计有多少个数据比平均值小
import java.util.Random;
public class array1 {
public static void main(String[] args) {
Random r = new Random();
int[] nums = new int[10];
// 打印数组初始值
System.out.println("数组初始值：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
// 生成数组的值
for (int i = 0; i < nums.length; i++) {
nums[i] = r.nextInt(100) + 1;
}
// 打印数组现在的值
System.out.println("\n数组现在的值：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
// 求数组元素之和
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
// 求数组元素平均数
int avg = sum / nums.length;
// 求数组值小于平均数的个数
int count = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] < avg)
++count;
}
System.out.println("\n数组元素之和为" + sum);
System.out.println("数组元素平均值为" + avg);
System.out.println("数组中元素小于平均值的个数有" + count + "个");
}
}
执行结果：
数组初始值：
0 0 0 0 0 0 0 0 0 0
数组现在的值：
72 6 35 98 45 85 16 100 85 47
数组元素之和为589
数组元素平均值为58
数组中元素小于平均值的个数有5个
程序示例：
// 需求：定义一个数组，存入 1, 2, 3, 4, 5。按照要求交换索引对应的元素。
// 交换前：1, 2, 3, 4, 5
// 交换后：5, 2, 3, 4, 1
public class array1 {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5};
System.out.println("交换之前的数组：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
// 交换
// int i = 0, j = nums.length - 1;
// while (i <= j) {
// int tmp = nums[i];
// nums[i] = nums[j];
// nums[j] = tmp;
// ++i;
// --j;
// }
for (int i = 0, j = nums.length - 1; i <= j; ++i, --j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
System.out.println("\n交换之后的数组：");
for (int k = 0; k < nums.length; k++) {
System.out.print(nums[k] + "\t");
}
}
}
执行结果：
交换之前的数组：
1 2 3 4 5
交换之后的数组：
5 4 3 2 1
程序示例：
// 需求：定义一个数组，存入 1~9。要求随机打乱数组中所有数据的顺序。
import java.util.Random;
public class array1 {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println("初始状态的数组：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
Random r = new Random();
// 每一次遍历到当前数组元素时，只和后面的随机一个元素进行交换
for (int i = 0; i < nums.length - 1; i++) {
int randomIndex = r.nextInt(nums.length - 1 - i - 1 + 1) + i + 1;
int tmp = nums[i];
nums[i] = nums[randomIndex];
nums[randomIndex] = tmp;
}
System.out.println("\n方法一打乱之后的数组：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
// 每一次遍历到当前数组元素时，和一个随机元素进行交换
for (int i = 0; i < nums.length - 1; i++) {
int randomIndex = r.nextInt(nums.length);
int tmp = nums[i];
nums[i] = nums[randomIndex];
nums[randomIndex] = tmp;
}
System.out.println("\n方法二打乱之后的数组：");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
}
}
执行结果：
初始状态的数组：
1 2 3 4 5 6 7 8 9
方法一打乱之后的数组：
9 8 6 2 4 5 1 7 3
方法二打乱之后的数组：
3 1 9 8 7 4 5 6 2
数组动态或者静态初始化时，允许自动类型转换，能进行自动类型转换的类型可以被赋值给数组元素，不能进行自动类型转换的类型不能赋值给数组元素，否则报错：不兼容的类型。
程序示例：
public class array1 {
public static void main(String[] args) {
double[] nums = {1.1, 2.2, 3, 4, 5}; // 此处的静态初始化，利用了自动类型转换
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
}
}
执行结果：
1.1 2.2 3.0 4.0 5.0
IDEA 提供了一个快速生成数组遍历的方式：数组名.fori
数组中的数据类型，可以是基本类型或者引用类型。
数组下标越界会报错。编译时不检查是否越界，运行时才报错。
程序示例：
public class array1 {
public static void main(String[] args) {
int[] nums = {1, 2, 3};
System.out.println(nums[3]); // ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
}
}