文章目录
- 1. 数组的作用
- 2. 数组的创建及初始化
- 2.1 数组的创建
- 2.2 数组的初始化
- 3. 数组的使用
- 3.1 数组中元素的访问
- 3.2 遍历数组方法
- 4. 数组是引用类型
- 4.1 JVM中的内存有那些
- 4.2 数组如何开辟空间
- 4.3 数组 null 的意思
- 4.4 引用不能同时指向多个对象
- 4.5 数组作为方法返回值
- 5. 二维数组
- 5.1 二维数组的使用
- 5.2 遍历打印二维数组
- 5.3 不规则数组
1. 数组的作用
当我们要对打印几位学生其中一门科目的成绩时
public class Blogs {
public static void main(String[] args) {
int score1 = 60;
int score2 = 69;
int score3 = 79;
int score4 = 83;
int score5 = 99;
System.out.println(score1);
System.out.println(score2);
System.out.println(score3);
System.out.println(score4);
System.out.println(score5);
}
}
这样写是没问题的，但是当我们要打印全校的学生成绩呢，那就会很麻烦，
值得注意的是成绩的类型都是一样的，这时我们就可以使用数组进行打印。
2. 数组的创建及初始化
2.1 数组的创建
int[] array1 = new int[5]; //创建一个可以容纳5个 int 类型元素的数组
double[] array2 = new double[5]; //创建一个可以容纳5个double类型元素的数组
char[] array3 = new char[5]; //创建一个可以容纳5个char类型元素的数组
2.2 数组的初始化
初始化的三种方式
public class Blogs2 {
public static void main(String[] args) {
//第一种初始化方式
int[] array1 = {1, 2, 3, 4, 5, 6, 10};
//第二种初始化方式
int[] array2 = new int[]{1, 2, 3, 4, 5, 6, 10};
//第三种初始化方式
int[] array3 = new int[7];
System.out.println(array1.length); //同过 数组名.length 计算数组长度
}
}
- 第一、二种初始化方式为静态初始化，静态初始化即在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定，即在初始化时编译器会根据 {} 中元素个数确定数组长度，第二种中 T[] 的 [] 中不能输入具体的数字。
- 第一种其实是和第二种是一样的，这样写就是省略了 new int[] 但是编译器在编译代码时会还原。
- 第三种为动态初始化，动态初始化即在创建数组时，直接指定数组中元素的个数，T[] 的 [] 中必须指明数组长度，当我们没有对其进行赋值时，默认为类型对应的 0 值，如果数组中存储元素类型为引用类型，默认值为null。
- 计算数组长度方法，
数组名.length
注意：使用静态初始化分两行写时不可以省略 new T[]
int[] array1;
array1 = new int[]{1, 2, 3, 4,};
3. 数组的使用
3.1 数组中元素的访问
数组的下标是从 0 开始的，通过下标可以访问和修改元素，如下图：
public class Main {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
array[2] = 19; //下标为2的元素变为19
System.out.println(array[2]); //打印下标为2的元素
}
}
下标为 2 的元素被改变了，即元素 3 变为 19
3.2 遍历数组方法
所谓 “遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作
1. 使用 for 循环进行遍历。
public class Main {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
2. 使用 for-each 进行遍历
public class Main{
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
for (int x : array) { //将 array 中元素值从0下标开始逐一赋值给x
System.out.print(x + " ");
}
}
}
这个意思是每循环一次 array 就会把一个值赋给 x ，直到数组中元素都赋值一遍，需要注意的是冒号左边的类型需要和 array 数组类型一致。
3. 使用 Arrays 工具类的方法进行遍历
import java.util.Arrays;
public class Main{
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
String ret = Arrays.toString(array); //会返回一个字符串，需要接收
System.out.println(ret);
}
}
1. 传入数组会返回一个字符串的表达方式
2. 使用Arrays.toString();时需要在开头写import java.util.Arrays;原因是使用库的工具类时需要说明。
3. 使用时会返回一个字符串，所以要用一个String引用类型进行接收
4. 数组是引用类型
4.1 JVM中的内存有那些
内存是一段连续的存储空间，主要用来存储程序运行时数据的。比如：
- 程序运行时代码需要加载到内存
- 程序运行产生的中间数据要存放在内存
- 程序中的常量也要保存
- 有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁
- 如果对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。
4.2 数组如何开辟空间
public class Main{
public static void main(String[] args) {
int[] array = {2, 3, 6, 19};
}
}
以下是 array 开辟空间过程：
我们试着打印 array 这个变量，它会是一个地址。
public class Main{
public static void main(String[] args) {
int[] array = {2, 3, 6, 19};
System.out.println(array);
}
}
4.3 数组 null 的意思
int[] array = null; 代表这个引用 不指向任何对象
public class Main{
public static void main(String[] args) {
//int[] array = 0; 错误的，
int[] array = null; //代表 array 这个引用不指向任何对象
System.out.println(array.length); // 错误，array 不指向任何对象，没有长度
System.out.println(array[0]); // 错误，和上面一个道理
}
}
让我们再来看看以下程序：
import java.util.Arrays;
public Main {
public static void main(String[] args) {
int[] array1 = {1, 2, 3, 4};
int[] array2 = array1;
System.out.println("array1=" + Arrays.toString(array1));
System.out.println("array2=" + Arrays.toString(array2));
}
}
int[] array2 = array1;代表 array2这个引用 引用/指向了 array1 所引用/指向的对象，同时可以通过array2 来修改 array1，它们存着一样的地址，下面我们来画画图理解：
4.4 引用不能同时指向多个对象
我们来看看为什么
import java.util.Arrays;
public class Main{
public static void main(String[] args) {
int[] array = {1, 2, 4};
array = new int[]{1, 3, 9};
array = new int[]{2, 0, 3};
System.out.println(Arrays.toString(array));
}
}
可以猜猜这个数组最后打印了什么，下面我们来画画图，这里我们简略画一下就好
4.5 数组作为方法返回值
public class Main {
public static int[] array() {
int[] array = {1, 2, 4};
return array;
}
public static void main(String[] args) {
int[] ret = array();
System.out.println(Arrays.toString(ret));
}
}
我们来画图理解：
5. 二维数组
5.1 二维数组的使用
public class Main {
public static void main(String[] args) {
int[][] array1 = {{1, 2, 3}, {3, 2, 1}};
int[][] array2 = new int[][]{{1, 2, 3}, {3, 2, 1}};
int[][] array3 = new int[2][3];
}
}
5.2 遍历打印二维数组
1. 使用 for 循环打印
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {3, 2, 1}};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。
所以代码可改成
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {3, 2, 1}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
2. 使用 for-each 进行遍历打印
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {3, 2, 1}};
//因为二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组，所以我们用一维数组接收
for (int[] array1 : array) {
for (int x : array1) {
System.out.print(x + " ");
}
System.out.println();
}
}
解释：因为二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组，所以我们用一维数组接收，一维数组接收后再经过每一次循环从 0 下标开始逐一将元素赋值给 x
3. 使用 Arrays.deepToString()
public class Main {
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {3, 2, 1}};
System.out.println(Arrays.deepToString(array));
}
}
5.3 不规则数组
当我们这样写时，编译器不会报错
int[][] array = new int[2][];
它是长这样的
那我们再来看看
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[][] array = new int[2][];
array[0] = new int[]{1, 2};
array[1] = new int[]{1, 2, 3, 4};
System.out.println(Arrays.deepToString(array));
}
}
我们可以看到这就是不规则数组。
我们来画图看看
好的，到这里本章节就结束了，如发现有错误，请各位大佬及时指出。
