Java数组的定义与常用使用方法

系统管理员 2024-02-19 08:06 21阅读 0赞

![e5c3636dc1c641c0892e7e3dcf9299b0.gif][]

**目录**

一.什么是数组

二.数组的创建及初始化

数组的创建

数组的初始化

动态初始化：

静态初始化：

【注意】

三.数组的使用

数组中元素访问

遍历数组

四.数组作为方法的参数

参数传基本数据类型

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

作为方法的返回值

五.java.util.Arrays 常用方法

数组转字符串

数组拷贝

求数组中元素的平均值

查找数组中指定元素(顺序查找)

查找数组中指定元素(二分查找)

数组排序

六.二维数组

--------------------

## **一.什么是数组** ##

数组：可以看成是 **相同类型元素的一个集合** 。在内存中是一段连续的空间。比如现实中的车库：

![82c9af7b50064e06baed09378c0371ac.png][]

> 数组有以下特征：
> 
>  *  数组中存放的元素其类型相同 
>  *  数组的空间是连在一起的 
>  *  每个空间有自己的编号，其实位置的编号为0，即数组的下标

--------------------

## **二.数组的创建及初始化** ##

### **数组的创建** ###

> **T\[ \] 数组名 = new T\[N\];**

在上述表达式中：

*  T：表示数组中存放元素的类型
 *  T\[ \]：表示数组的类型
 *  N：表示数组的长度

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
    double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
    String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组

### **数组的初始化**  ###

数组的初始化可以分为 **动态初始化** 以及 **静态初始化**

#### **动态初始化：** ####

> **在创建数组时，直接指定数组中元素的个数**
> 
>     int[] array = new int[10];

#### **静态初始化：** ####

> **在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定**
> 
>     int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
>     double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
>     String[] array3 = new String[]{"hell", "Java", "!!!"};

#### 【注意】 ####

*  **静态初始化虽然没有指定数组的长度，编译器在编译时会根据 \{ \} 中元素个数来确定数组的长度**
 *  **静态初始化时, \{ \} 中数据类型必须与 \[ \] 前数据类型一致**
 *  **静态初始化可以简写，省去后面的new T\[ \]**

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
    int[] array1 = {0,1,2,3,4,5,6,7,8,9};
    double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
    String[] array3 = {"hell", "Java", "!!!"};

*  **数组也可以按照如下C语言个数创建，不推荐，该种定义方式不太友好，容易造成数组的类型就是int的误解，\[\]如果在类型之后，就表示数组类型，因此int\[\]结合在一块写意思更清晰**

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

*  **静态和动态初始化也可以分为两步，但是省略格式不可以**

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

*  **如果没有对数组进行初始化，数组中元素有其默认值，如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，比如：**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>类型 </strong></span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>默认值 </strong></span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">byte </span></strong> 
    </div> </td> 
   <td><strong>0</strong></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">short </span></strong> 
    </div> </td> 
   <td><strong>0</strong></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">int </span></strong> 
    </div> </td> 
   <td><strong>0</strong></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">long </span></strong> 
    </div> </td> 
   <td><strong>0</strong></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">float </span></strong> 
    </div> </td> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">0.0f </span></strong> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">double</span></strong> 
    </div> </td> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">0.0 </span></strong> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">char</span></strong> 
    </div> </td> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">/u0000 </span></strong> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">boolean </span></strong> 
    </div> </td> 
   <td> 
    <div> 
     <strong><span style="color:#333333;">false </span></strong> 
    </div> </td> 
  </tr> 
  <tr> 
   <td><strong><span style="color:#333333;">引用</span></strong></td> 
   <td><strong>null</strong></td> 
  </tr> 
 </tbody> 
</table>

--------------------

## **三.数组的使用** ##

### **数组中元素访问** ###

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

int[]array = new int[]{10, 20, 30, 40, 50};
    System.out.println(array[0]);
    System.out.println(array[1]);
    System.out.println(array[2]);
    System.out.println(array[3]);
    System.out.println(array[4]);
    
    // 也可以通过[]对数组中的元素进行修改
    array[0] = 100;
    System.out.println(array[0])

数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素，下标从0 开始，介于 \[0, N ）之间不包含 N ， N为元素个数，不能越界，否则会报出下标越界异常

int[] array = {1, 2, 3};
    System.out.println(array[3]); // 数组中只有3个元素，下标一次为：0 1 2，array[3]下标越界

// 执行结果
    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

### **遍历数组** ###

使用循环来进行打印

int[]array = new int[]{10, 20, 30, 40, 50};
        for(int i = 0; i < 5; i++) {
        System.out.println(array[i]);
    }

在数组中可以通过  数组对象 **.length**  来获取数组的长度

int[]array = new int[]{10, 20, 30, 40, 50};
        for(int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }

也可以使用  **for-each**  遍历数组， **for-each**  是  **for**  循环的另外一种使用方式 .  能够更方便的完成对数组的遍历 .  可以避免循环条件和更新语句写错

int[] array = {1, 2, 3};
        for (int x : array) {
        System.out.println(x);
    }

--------------------

## **四.数组作为方法的参数** ##

### **参数传基本数据类型** ###

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

> **执行结果：**
> 
> x = 10
> 
> num = 0 
> 
> **发现在func方法中修改形参 x 的值, 不影响实参的 num 值**

### **参数传数组类型****(****引用数据类型****)** ###

public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        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]);
    }

> **执行结果** 
> 
> a\[0\] = 10
> 
> arr\[0\] = 10
> 
> 发现在func 方法内部修改数组的内容 ,  方法外部的数组内容也发生改变 .

**这是因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的**

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

### **作为方法的返回值** ###

我们可以用数组做返回值求得斐波那契数列的前N项

public class TestArray {
        public static int[] fib(int n){
            if(n <= 0){
                return null;
            }
            int[] array = new int[n];
            array[0] = array[1] = 1;
            for(int i = 2; i < n; ++i){
                array[i] = array[i-1] + array[i-2];
            }
            return array;
        }
        public static void main(String[] args) {
            int[] array = fib(10);
            for (int i = 0; i < array.length; i++) {
                System.out.println(array[i]);
            }
        }
    }

--------------------

## **五.java.util.Arrays 常用方法** ##

### **数组转字符串**  ###

Java  中提供了  **java.util.Arrays**  包 ,  其中包含了一些操作数组的常用方法，如 toString 就可以将我们的数组转化为字符串，方便了我们输出

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

### **数组拷贝** ###

使用 Arrays 中 copyOf 方法完成数组的拷贝，copyOf 方法在进行数组拷贝时，创建了一个新的数组，arr 和 newArr 引用的不是同一个数组

public static void func() {
            // newArr和arr引用的是同一个数组
            // 因此newArr修改空间中内容之后，arr也可以看到修改的结果
            int[] arr = {1,2,3,4,5,6};
            int[] newArr = arr;
            newArr[0] = 10;
            System.out.println("newArr: " + Arrays.toString(arr));
    
            // 使用Arrays中copyOf方法完成数组的拷贝：
            // copyOf方法在进行数组拷贝时，创建了一个新的数组
            // arr和newArr引用的不是同一个数组
            arr[0] = 1;
            newArr = Arrays.copyOf(arr, arr.length);
            System.out.println("newArr: " + Arrays.toString(newArr));
    
            // 因为arr修改其引用数组中内容时，对newArr没有任何影响
            arr[0] = 10;
            System.out.println("arr: " + Arrays.toString(arr));
            System.out.println("newArr: " + Arrays.toString(newArr));
    
            // 拷贝某个范围.
            int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
            System.out.println("newArr2: " + Arrays.toString(newArr2));
        }

**如图：**

![5af9cfc6181440c0a8642a013c707a5a.png][]

![d995d805dbb54820a6408fb7c9596583.png][]

### **求数组中元素的平均值** ###

我们可以使用 avg 将数组传入，就可以得到平均值

public static void main(String[] args) {
            int[] arr = {1,2,3,4,5,6};
            System.out.println(avg(arr));
        }
        public static double avg(int[] arr) {
            int sum = 0;
            for (int x : arr) {
                sum += x;
            }
            return (double)sum / (double)arr.length;
        }

### **查找数组中指定元素****(****顺序查找****)** ###

使用 find，传入目标数组和要查询的值

public static void main(String[] args) {
        int[] arr = {1,2,3,10,5,6};
        System.out.println(find(arr, 10));
    }
    public static int find(int[] arr, int data) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == data) {
                return i;
            }
        }
        return -1; // 表示没有找到
    }

### **查找数组中指定元素****(****二分查找****)** ###

针对 **有序数组** , 可以使用更高效的二分查找，以升序数组为例 ,  二分查找的思路是先取中间位置的元素 ,  然后使用待查找元素与数组中间元素进行比较：

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

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

### **数组排序** ###

Java  中内置了高效的排序算法

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

--------------------

## **六.二维数组** ##

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

> **基本语法**
> 
> 数据类型 \[\]\[\]  数组名称  =  new  数据类型  \[ 行数 \]\[ 列数 \] \{  初始化数据  \};

int[][] arr = {
       {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    for(int row=0;row<arr.length;row++) {
        for(int col=0;col<arr[row].length;col++) {
            System.out.printf("%d\t",arr[row][col]);
        }
        System.out.println("");
    }

二维数组的用法和一维数组并没有明显差别，唯一需要注意的一点是，**在省略数组大小的时候，我们不能省略行数，这与c语言是截然相反的**

正确格式：

int[][] arr = new int [3][];

错误格式：

int[][] arr = new int [][3];
    int[][] arr = new int [][];

--------------------

[e5c3636dc1c641c0892e7e3dcf9299b0.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/ebe21b07c1c9444cb040b06d226c1738.png
[82c9af7b50064e06baed09378c0371ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/ba8545aed5984271970d250e298d90ad.png
[5af9cfc6181440c0a8642a013c707a5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/6d423926b2804912ac1bd39ca139bcb1.png
[d995d805dbb54820a6408fb7c9596583.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/d6ffb05aa6d24c2eb4c014259dabd369.png