Java--数组的定义与使用

1.数组的基本概念

1.1为什么用数组

在程序设计中,每一个数据总是对应一个变量.当数据量越大,就需要更多的变量来存储.我们将相同类型的数据存储到一个集合中,就可以更方便我们对数据进行访问,同时可以减少不断定义变量.这个集合就叫做数组

1.2数组的定义

数组是一种基本的数据结构，用于存储相同类型的多个值。数组是引用数据类型，它可以存储基本数据类型或对象的集合。

1.3数组的创建及初始化

1.3.1语法格式

T[] 数组名 = new T[N];

T : 表示数组中存放元素的类型

T[ ] : 表示数组的类型

N : 表示数组的长度

  int[] arr = new int[10];

这样我们就创建了一个可以容纳10个int类型元素的数组

1.3.2数组的初始化

数组的初始化主要分为动态初始化和静态初始化

1.动态初始化:在创建数组时,直接指定数组中元素的个数

  int[] arr = new arr[10];

2.静态初始化:在创建数组时不指定元素个数,而是直接用数据进行指定

语法格式:

T[] 数组名称 = {data1,data2,data3.....datan};

int[] arr = new int[]{0,1,2,3,4,5,6};

注意事项:

• 静态初始化虽然没有指定数组的长度,编译器在编译时会根据{ }中元素个数来确定数组的长度.
• 静态初始化时, { }中数据类型必须与[]前数据类型一致.
• 静态初始化可以简写,省去后面的 new T[ ],但是编译器编译代码时还是会还原.
• 如果没有对数组初始化,数组中元素有其默认值,如果是基本数据类型,默认值为对应的默认值,如图

如果数组中存储元素类型为引用类型,默认值为null.

1.4数组的使用

1.4.1数组中元素访问

数组在内存中是一段连续的空间,空间的编号都是从0开始的,依次递增,该编号称为数组的下标,数组可以通过下标访问其任意位置的元素.

int[] arr = new int[]{11,22,33,44};
System.out.println(arr[0]);//11
System.out.println(arr[1]);//22
System.out.println(arr[2]);//33
System.out.println(arr[3]);//44

也可以通过下标对数组元素进行修改

arr[3] = 55;
System.out.println(arr[3]);//55

注意事项:

下标从0开始,介于 [ 0 , N ) 之间,不包含N,N为元素个数,不能越界,否则会报出下标越界异常

1.4.2数组遍历

遍历指的是将数组中所有元素都访问一遍,访问是指对数组中的元素进行某种操作,比如打印

1.4.1中的代码就是对数组arr进行了遍历,但问题是这种方法不易于修改,增加一个元素就要多一条打印语句,通过观察代码可以发现,遍历的下标都是是按照顺序逐渐增大,所有我们可以用一个循环来表示下标.

int[] arr = new int[]{11,22,33,44};
for(int i = 0;i<4;i++){
    System.out.println(arr[i]);
}

这样就简写了对数组的遍历,但是问题还没有解决,数组变大时还需要修改循环,我们可以通过 数组对象.length 来获取数组的长度,代码修改如下

int[] arr = new int[]{11,22,33,44};        
for(int i = 0;i< arr.length;i++){
    System.out.println(arr[i]);
}

还可以通过 for-each 来遍历数组

int[] arr = new int[]{11,22,33,44};
for(int i:arr){
    System.out.println(i);
}

这种写法更简洁,但是无法反向遍历

2.数组是引用类型

2.1基本类型变量与应用类型变量的区别

基本数据类型创建的变量,称为基本变量,该变量空间中直接存放的是其所对应的值;

而引用数据类型创建的变量,一般称为对象的引用,其空间中存储的是对象所在空间的地址.

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int[] arr = new int[]{1, 2, 3};
}

在上述代码中, a、b、arr 都是函数内部的变量,因此其空间都在main方法对应的栈帧中分配;

a、b是内置类型的变量,因此其空间中保存的就是给该变量初始化的值;

array是数组类型的引用变量,其内部保存的内容可以简单理解成是数组在堆空间中的首地址.

从上图可以看到,引用变量并不直接存储对象本身,可以简单理解成存储的是对象在堆中空间的起始地址.通过该地址,引用变量便可以去操作对象.

2.2引用变量的赋值

int[] arr1 = new int[]{1,2,3};
int[] arr2 = new int[]{100,200,300};
arr1 = arr2;
arr2[2] = 400;
for(int i:arr1){
    System.out.println(i);
}
for(int i:arr2){
    System.out.println(i);
}

这段代码中,定义了两个数组 arr1 和 arr2 ,修改了 arr2 的一个元素并对两个数组进行遍历打印

但是结果却把 arr2 打印了两遍,因为 arr1 = arr2 本质是把 arr1 去引用 arr2引用的数组的空间,此时arr1 和 arr2 实际是一个数组

修改之前

修改之后

2.3认识 null

null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用.

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操 作. 一旦尝试读写, 就会抛出 NullPointerException.同时 Java 中并没有约定 null 和 0 号地址的内存有任何关联

int[] arr = null;
System.out.println(arr[0]);

3.数组的应用场景

3.1保存数据

int[] arr = new int[]{11,22,33,44};
for(int i = 0;i<4;i++){
    System.out.println(arr[i]);
}

3.2作为函数的参数

1.参数传基本类型

    public static void main(String[] args) {
        int num = 0;
        func(num);
        System.out.println("num=" + num);
    }
    public static int func(int x){
        x = 10;
        System.out.println("x="+ x);
        return x;
    }

在 func 方法中修改形参 x 的值,不会影响实参的 num 的值

2.参数传数组类型(引用数据类型)

    public static void main(String[] args) {
        int[] arr ={1};
        func(arr);
        System.out.println("arr[0]="+arr[0]);
    }
    public static void func(int[] a){
        a[0] = 10;
        System.out.println("a[0]="+ a[0]);
    }

这一次改变了方法外部的值,是因为数组是引用类型,按照引用类型来进行传递,是可以修改其中存放的内容的

总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实 只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).

3.3数组转字符串

代码示例

import java.util.Arrays;

int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);

执行结果

通过将数组转为字符串,可以让打印更方便一些

3.4数组拷贝

代码示例

int[] arr = {1,2,3,4,5};
int[] newArr = arr;
newArr[0] = 10;
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("newArr:"+Arrays.toString(newArr));

当前 newArr 数组指向了 arr 数组,修改了 newArr 中的内容, arr 也会发生改变,虽然结果一样,但是不算真正意义上的拷贝

所以我们需要用到 Arrays 中的 copyOf 方法来完成数组的拷贝

语法格式: Arrays.copyOf(拷贝的数组,拷贝的长度)

int[] arr = {1,2,3,4,5};
int[] newArr = Arrays.copyOf(arr,arr.length);
newArr[0] = 10;
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("newArr:"+Arrays.toString(newArr));

这个时候,arr 和 newArr 就不是引用同一个数组了,改变其中一项就不会对另一个数组改变.

还可以使用 Arrays.copyOfRange 来指定拷贝范围

语法格式: Arrays.copyOfRange(拷贝的数组,拷贝的起点,拷贝的终点)

int[] arr = {1,2,3,4,5};
int[] newArr = Arrays.copyOfRange(arr,2,4);
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("newArr:"+Arrays.toString(newArr));

可以看到拷贝的范围是左闭右开区间 [ 2 , 4)

实现自己版本的拷贝数组

public static int[] copyOf(int[] arr){
    int[] ret = new int[arr.length];
    for(int i = 0;i< arr.length;i++){
        ret[i] = arr[i];
    }
    return ret;
}

 3.5查找指定元素(二分查找)

针对有序数组,可以使用更高效的二分查找

以升序数组为例,二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：

• 如果相等，即找到了返回该元素在数组中的下标;
• 如果小于，以类似方式到数组左半侧查找;
• 如果大于，以类似方式到数组右半侧查找.

代码示例

    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10};
        System.out.println(binarySearch(arr,7));

    }
    public static int binarySearch(int[] arr,int toFind){
        int left = 0;
        int right = arr.length;
        while (left <= right){
            int mid = (left+right) / 2;
            if(toFind < arr[mid]){
                //小于,去左侧找
                right = mid-1;
            } else if (toFind > arr[mid]) {
                //大于,去右侧找
                left = mid+1;
            }else
                //相等,说明找到了,返回下标
                return mid;
        }
        return -1;  //没找到
    }

3.6数组排序(冒泡排序)

给定一个数组,让数组实现升序或降序

算法思路:

将相邻两个数进行比较,将大的数交换置于后面,遍历一躺以后,最大的数就会被交换到最后一位

每一次遍历会有一个数到自己该有的位置,所以循环次数为数组元素的个数

(生活中泡泡总是不断向上,这个排序方法也是不断的向上,所以称为冒泡排序)

代码示例

    
public static void main(String[] args) {
    int[] arr = new int[]{9,5,8,3};
    bubbleSort(arr);
    System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] arr){
    for(int i = 0;i< arr.length;i++){
        for(int j = 0;j< arr.length-i-1;j++){
            if(arr[j] > arr[j+1]){
                int tmp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

运行结果

冒泡排序性能较低,Java中内置了更高效的排序算法

    public static void main(String[] args) {
        int[] arr = new int[]{9,5,8,3};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

运行结果如上

3.7二维数组

二维数组本质上也是一维数组,只不过每个元素又是一个一维数组

语法格式

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 }

同理,还有 "三维数组" , "四维数组",出现频率不高,这里不再介绍

感谢阅读,希望对你有帮助