Java数组

前言

适合有一定C语言基础的萌新学习
个人笔记

java数组与C语言数组的区别

书写区别

C语言的写法:

int a[] = {1,2,3,4,5,6};
int a[10] = {1,2,3};

java的写法:
其实java的写法更加复合逻辑
前面是数组的类型 int[],后面就是变量名,这样跟其他类型的写法一致

int[] arr1 = {1,2,3,4,5,6};//与arr2相同,只是更方便一些
int[] arr2 = new int[]{1,2,3,4,5,6};

int[] arr3 = new int[6];//arr3中所有元素初始化为0
//只有这种类型的才可以往中括号里写数字!

// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};

//要拆分的话,只能如下
int[] array2;
array2 = new int[]{1,2,3};

// 局部变量使用时,一定要初始化,否则报错
// int[] array1;
// System.out.println(array1);

存储区别

我们可以用引用类型来赋值给另一个引用类型(相同类型):

int[] arr1 = {1,2,3,4,5};
int[] arr2 = arr1;

注意,上面是两个引用共同指向了同一个数组
并不是把arr1的数组拷贝了一份再给arr2

arr2[0] = 3;

上面的代码也会改变arr1,因为它们共同指向了一个数组

注意:

• 数组没有引用指向它时,就会自动销毁,不用担心堆上的空间被浪费
• 引用类型被赋值null时,引用没有指向任何的数组

int[] arr = {1,2,3};
arr = null;//arr不再指向数组{1,2,3} 
//数组{1,2,3}没有被任何引用指向,程序自动销毁

• java中并没有约定null与0之间有什么关系

扩展:
C语言中NULL(C语言是大写,java是小写)是表示0,可以赋值给指针,表示指针不指向任何地址

数组传参

java传参是把引用类型传了过去,引用类型指向堆上的数组,也就是可以在方法中修改传参过去的引用所指向的数组

public static void fun(int[] arr) {
        arr[0] = 3;
    }
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5};
    fun(arr);
    System.out.println(Arrays.toString(arr));
    //打印[3, 2, 3, 4, 5]
}

---

那我们思考一下下面一段代码会输出什么?

public static void fun1(int[] arr) {
    arr = new int[]{11,33,3};
}
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5};
    fun1(arr);
    System.out.println(Arrays.toString(arr));
}

打印为[1,2,3,4,5]
因为在方法中重新创建了一个数组,而数组在堆上,指向该数组的是fun1方法中的arr引用变量本来是指向数组{1,2,3,4,5}的,然后指向了新的数组{11,33,3}
main中的arr不受影响,还是指向数组{1,2,3,4,5}
注意:数组传参是把引用变量拷贝一份然后传过去的

Arrays类的常用方法

需要导包
import java.util.Arrays;

格式:类名.方法名()
例如Arrays.toString()

数组转换为字符串

Arrays.toString(数组名)

    int[] arr = {1,2,3,4,5};
    String str = Arrays.toString(arr);
    System.out.println(str);//打印: [1, 2, 3, 4, 5]

数组拷贝

数组直接拷贝

数组名.clone
并不是Arrays中的方法，而且clone可以应用到任何类型

public static void main(String []args) {
    int[] arr = {1,2,3,4,5,6};
    int[] arr2 = arr.clone();
    arr2[0] = 33;
    System.out.println(Arrays.toString(arr));//打印[1, 2, 3, 4, 5, 6]
    System.out.println(Arrays.toString(arr2));//打印[33, 2, 3, 4, 5, 6]
}

数组长度拷贝

Arrays.copyOf(数组名,长度)

public static void main(String []args) {
    int[] arr = {1,2,3,4,5,6};
    int[] arr2 = Arrays.copyOf(arr,arr.length);//前面是数组名，后面是数组长度
    arr2[0] = 33;//因为arr2是拷贝arr的，不是共同指向同一个数组，所以对arr没有影响
    System.out.println(Arrays.toString(arr));//打印[1, 2, 3, 4, 5, 6]
    System.out.println(Arrays.toString(arr2));//打印[33, 2, 3, 4, 5, 6]
}

后面的参数可以是任意长度

public static void main(String []args) {
    int[] arr = {1,2,3,4,5,6};
    int[] arr2 = Arrays.copyOf(arr,arr.length * 2);//前面是数组名，后面是数组长度
    int[] arr3 = Arrays.copyOf(arr,arr.length / 2);
    System.out.println(Arrays.toString(arr2));//打印[1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0]
    System.out.println(Arrays.toString(arr3));//打印[1, 2, 3]
}

数组任意拷贝

Arrays.copyOfRange(数组名,从哪坐标开始,到坐标结束)

java都遵循左闭右开 例如2,4 大于等于2 且 小于4 [2,4)

public static void main(String []args) {
    int[] arr = {1,2,3,4,5,6};
    int[] arr2 = Arrays.copyOfRange(arr,1,3);//前面是数组名，后面是区间，java都遵循左闭右开 [2,4)
    System.out.println(Arrays.toString(arr2));//打印[2, 3]
}

数组排序

Arrays.sort(数组名)
顺序排序

public static void main(String []args) {
    int[] arr = {5,1,3,8,7,9,11,2};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));//打印[1, 2, 3, 5, 7, 8, 9, 11]
}

数组元素查找

Arrays.binarySearch(数组名,要找的元素)
找到的话：返回找到的数组下标
没找到的话：返回一个负数

public static void main(String []args) {
    int[] arr = {5,1,3,8,7,9,11,2};
    int p = Arrays.binarySearch(arr,3);//返回下标2
    System.out.println(p);
}

判断数组是否相同

Arrays.equals(数组1,数组2)
返回布尔类型，相同返回true，不同返回false

public static void main(String []args) {
    int[] arr1 = {1,2,3};
    int[] arr2 = {1,2,3};
    System.out.println(Arrays.equals(arr1,arr2));//打印true

    arr2[0] = 3;
    System.out.println(Arrays.equals(arr1,arr2));//打印false

}

数组初始化

Arrays.fill(数组名,全部元素被置为什么)

public static void main(String []args) {
    int[] arr1 = {1,2,3};
    Arrays.fill(arr1,3);
    System.out.println(Arrays.toString(arr1));//打印[3, 3, 3]

}

数组局部初始化

Arrays.fill(数组名,从哪坐标开始,到坐标结束，被置为什么)

java都遵循左闭右开 例如2,4 大于等于2 且 小于4 [2,4)

public static void main(String []args) {
    int[] arr1 = {1,2,3,4,5,6};
    Arrays.fill(arr1,0,3,99);//[0,3)置为99
    System.out.println(Arrays.toString(arr1));//打印[99, 99, 99, 4, 5, 6]

}

二维数组

与C语言的区别

arr[行][列]

java二维数组 不能省略行,可以省略列 和C语言相反 (没初始化的二维数组每个元素(一维数组）都是null)

C语言 二维数组可以省略行,但不能省略列

java不规则数组

这时我们会有一个疑问,为什么不能省略行,可以省略列呢?

是因为java当中有不规则数组,因为java的数组存放在了堆上,且不是连在一块的,每个二维数组的元素都是一维数组的引用,而每个引用所指向的数组都是单独存放在堆上的
java二维数组中的每个一维数组长度可以不一样

public static void main(String[] args) {
    /*也可以直接赋值
    int[][] arr = {{1,2,3,4,5},{1,2,3},{1,2,3,4}};
    */
    int[][] arr = new int[3][];
    arr[0] = new int[]{1,2,3,4,5};
    arr[1] = new int[]{1,2,3};
    arr[2] = new int[]{1,2,3,4};

    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println();
    }
    //打印也可以这样:
    //System.out.println(Arrays.deepToString(arr));//多维函数的打印
}

打印为:
1 2 3 4 5
1 2 3
1 2 3 4

小技巧_1:上面代码中的 arr[i].length 表示每个二维数组的元素(一维数组)的长度

小技巧_2:Arrays.deepToString(),需要Arrays的导包,可以把多维数组转换为字符串

当然还有三维,四维等多维数组,不过使用频率极低