数组

概述

数组是一个引用类型，是一种容器。

数组存储多个相同数据类型的数据，允许自动类型转换。例如 int 类型的数组，可以存放 byte、short 和 int 类型的数据，double 类型的数组，可以存放 byte、short、int、long、float 和 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@119d7047float[] float1 = {1.1F, 2.2F, 3, 4, 5};System.out.println(float1);             // [F@776ec8dflong[] long1 = {1, 2, 3};System.out.println(long1);              // [J@4eec7777int[] int1 = {1, 2, 3};System.out.println(int1);               // [I@3b07d329short[] short1 = {1, 2, 3};System.out.println(short1);             // [S@41629346byte[] byte1 = {1, 2, 3};System.out.println(byte1);              // [B@404b9385boolean[] boolean1 = {false, false, true, false, true};System.out.println(boolean1);           // [Z@6d311334char[] char1 = {'1', '2', '3'};System.out.println(char1);              // 123String[] 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);              // 123char[] char2 = {'1', '2', '3', '9'};System.out.println(char2);              // 1239char[] char3 = {'9', '8', '7'};System.out.println(char3);              // 987
}

数组的静态初始化

数组的初始化：在内存中，为数组容器开辟空间，并将数据存入容器中的过程。

数组初始化有两种方式：动态初始化和静态初始化。

语法：

// 完整格式：
数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, ... , 元素n};
// 或者：
数据类型 数组名[] = 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};

程序示例：

public class ArrayDemo {public static void main(String[] args) {// 需求1：定义数组存储5个学生的年龄int[] arr1 = new int[]{12, 14, 16, 17, 18};int[] arr2 = {12, 14, 16, 17, 18};// 需求2：定义数组存储3个学生的姓名String[] arr3 = new String[]{"zhangsan", "lisi", "wangwu"};String[] arr4 = {"zhangsan", "lisi", "wangwu"};// 需求3：定义数组存储4个学生的身高double[] arr5 = new double[]{1.9, 1.8, 1.7, 1.6};double[] arr6 = {1.9, 1.8, 1.7, 1.6};}
}

程序示例：

// 定义一个数组，存储 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 = {33, 5, 22, 44, 55};for (int i = 1; i <= nums.length - 1; i++) {for (int j = 0; j <= nums.length - 1 - i; j++) {if (nums[j] < nums[j + 1]) {int tmp = nums[j];nums[j] = nums[j + 1];nums[j + 1] = tmp;}}}System.out.println("从大到小进行排序：");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, 1public 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}
}

数组的动态初始化 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]);           // 0System.out.println(shorts[0]);          // 0System.out.println(ints[0]);            // 0System.out.println(longs[0]);           // 0System.out.println(chars[0]);System.out.println(booleans[0]);        // falseSystem.out.println(floats[0]);          // 0.0System.out.println(doubles[0]);         // 0.0System.out.println(Strings[0]);         // null}
}

执行结果：

0
0
0
0false
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}
}

数组赋值

数组赋值是引用传递，传递的是地址。

程序示例：

public class ArrayAssign {public static void main(String[] args) {int[] arr1 = {1, 2, 3};int[] arr2 = arr1;for (int i = 0; i < arr1.length; i++) {System.out.print(arr1[i] + " ");}System.out.println("");arr2[1] = 100;for (int i = 0; i < arr1.length; i++) {  // 修改 arr2 会影响 arr1System.out.print(arr1[i] + " ");}}
}

执行结果：

1 2 3 
1 100 3

程序示例：

public class test {public static void main(String[] args) {// 给定一个初始数组int[] arr1 = {1, 2, 3};// 遍历打印初始数组for (int i = 0; i < arr1.length; i++) {System.out.print(arr1[i] + " ");}// 调用方法修改数组change(arr1);// 遍历打印修改后的数组System.out.println();for (int i = 0; i < arr1.length; i++) {System.out.print(arr1[i] + " ");}}// 修改数组的方法public static void change(int[] arr) {arr[0] = 100;}
}