【Java学习笔记】数组

数组

一、数组的定义方法

int[] a = {0, 1, 2};

数组的引用（使用 / 访问 / 获取数组元素）

数组名[下标 / 索引 / index]

注意：数组的下标从 0 开始编号

数组的本质：是引用类型，底层是一个指针

补充

Java 中的引用数据类型：数组，类，接口

---

二、数组的底层存储机制

jvm 的内存

_____________   ——————————————————————————————
|            |  |  堆空间
|            |  |
|   栈空间   |  |
|            |  |______________________________
|            |  |   方法区
——————————————  |______________________________

定义一个数组int[] a,此时数组为空，为数组分配一个空间时，会在堆空间中生成一块区域存储数组元素，同时会返回一个地址，把这块区域赋值给 a。即int[] a = new int[5],这个时候a就会指向这段空间的地址

1. 值传递

int a = 10;
int b = a;

底层：先把a的值拷贝一份，然后赋值给b，两个值之间不会相互影响

2. 数组的传递（传的是地址）

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 10;

注意：传的的是地址，这个时候b就会指向a所指的栈空间的地址，相当于a b指向同一个空间{1, 2, 3}，b数组改变数值会影响a数组的值

---

三、数组的初始化

1. 静态初始化

int[] a = {1, 2, 3};

2. 动态初始化

方法：int[] a = new int[5]

使用new进行数组空间的申请，同时需要指定数组的数据类型和数组的空间大小

方式一：直接使用动态分配

double scores[] = new double[5];

方式二：先声明后分配

double scores[];  // 此时 scores 是 null
scores = new double[5];

---

四、数组的动态值录入

补充：使用数组名.length可以获取数组长度

import java.util.Scanner
public class hello{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int[] a = new int[5];
        for( int i = 0; i < a.length; i++){
            a[i] = input.nextInt();
        }
        for( int i = 0; i < a.length; i++){
            System.out.print(a[i] + " ");
        }
    }
}

五、数组的使用细节

• 1. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用

int[] a = {1, 2, 3.0}

• 错误点：不可以吧一个double赋值给int

• 2. 数组创建后，如果没有赋值，就是默认值 0，根据数据类型的不同变化

  • int： 0

  • short： 0

  • byte： 0

  • long： 0

  • float： 0.0

  • double： 0.0

  • char： \u0000

  • boolean： false

  • String： null

• 3. 数组的下标是从 0 开始的，也就是说第一个元素的在数组中用a[0]表示，即元素物理位置 = 对应数组下标 + 1 ----> 小心数组下标越界访问

int[] arr = new int[5];  // 有效下标为 0 - 4

• 4. 数组属于引用类型，数组型数据是对象（object）

---

六、数组的拷贝

区别于数组的地址传递，数组拷贝后两个数组独立，互不影响

int[] a ={1, 2, 3};
int[] b = new int[a.length];
for( int i = 0; i < a.length; i++){
    b[i] = a[i];
}

b[0] = 10;

System.out.print("a数组的值：");
for( int i = 0; i < a.length; i++){
    System.out.print(a[i] + " ");
}

System.out.println("");

System.out.print("b数组的值：");
for( int i = 0; i < b.length; i++){
    System.out.print(b[i] + " ");
}


// 输出结果
// a数组的值：1 2 3
// b数组的值：10 2 3

---

七：数组的反转

方法一：找规律

理解：假设有两个指针，一个指向头，一个指向尾，两个指针向中间移动，每次所指的元素就交换位置，完成数组的翻转只需要数组长度的一半次就可以完成

int[] a = {1, 2, 3};
for( int  i = 0; i < a.length/2; i++){
    int temp = a[i];
    a[i] = a[a.length-1-i];
    a[a.length-1-i] = temp;
}
for( int i = 0; i < a.length; i++){
    System.out.print(a[i] + " ");
}

//输出： 3 2 1

方法二：逆序赋值

注意 Java 中的垃圾回收机制

int[] a = {1, 2, 3};
int[] b = new int[a.length];
for( int i = a.length-1,j = 0; i >= 0; i--,j++){
    b[j] = a[i];
}
a = b; //让 a 指向 b
for( int i = 0; i < b.length; i++){
    System.out.print(b[i] + " ");
}
System.out.println("");
for( int i = 0; i < a.length; i++){
    System.out.print(a[i] + " ");
}

//原先 a 所指的空间没有变量引用，就会被当作垃圾处理，回收
//现在 a b 都是指向同一空间，输出的结果一样