数组应该怎么用？

痛定思痛。 2023-10-09 19:01 13阅读 0赞

#### 文章目录 ####

*  前言
 *  一、数组是什么？
 *  二、数组的创建
 *   *  1.数组的创建：
     *  2.数组的初始化
 *  三.数组的遍历
 *   *  1.逐个打印
     *  2.使用for循环
     *  四.二维数组
     *  1.语法：
     *  2.遍历
 *  五.数组的一些常用方法
 *   *  1.数组转换字符串
     *  2.数组拷贝
     *  3.二分查找
     *  4.冒泡排序
     *  5.数组逆序
 *  总结

## 前言 ##

为什么要使用数组，因为使用数组可以避免过于的冗杂，方便美观，简洁

## 一、数组是什么？ ##

可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

## 二、数组的创建 ##

### 1.数组的创建： ###

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

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

### 2.数组的初始化 ###

代码如下（示例）：

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

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

![在这里插入图片描述][d2505bb6a3f14b7fa0c559ed8c5e8e61.png]  
\*\*\*注意：\*\*\*如果数组中存储元素类型为引用类型，默认值为null。

2.1动态初始化：创建数组，直接数组中元素的个数

int[] array = new int[10];

2.2 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定.

int[] array1 = new int[]{
        0,1,2,3,4,5,6,7,8,9};

注意事项：  
1.静态初始化虽然没有指定数组的长度，编译器在编译时会根据\{\}中元素个数来确定数组的长度。  
2.静态初始化时, \{\}中数据类型必须与\[\]前数据类型一致。  
3.静态初始化可以简写，省去后面的new T\[\]。  
静态和动态初始化也可以分为两步，但是省略格式不可以。

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

如果没有对数组进行初始化，数组中元素有其默认值  
如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，  
![在这里插入图片描述][9fe43afd8d724181b39625d1c2ee5ba2.png]

2.3数组中元素的访问：  
数组在内存中是一段连续的空间，空间的编号都是从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]);

![在这里插入图片描述][27ac296742d74e6795642be449d80171.png]  
还可以进行修改其中的数值

array[0] = 100;
    System.out.println(array[0]);

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

## 三.数组的遍历 ##

### 1.逐个打印 ###

如上图一样

### 2.使用for循环 ###

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

3.使用for -each

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

### 四.二维数组 ###

### 1.语法： ###

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

int[][] arr = {
        
    {
        1, 2, 3, 4},
    {
        5, 6, 7, 8},
    {
        9, 10, 11, 12}
    };

### 2.遍历 ###

int[][] arr = {
        
                    {
        1, 2, 3, 4},
                    {
        5, 6, 7, 8},
                    {
        9, 10, 11, 12}
            };
            for (int x[]:arr) {
        
                System.out.println(Arrays.toString(x));
            }
        }

用Arrays.toString可以很快遍历出来  
![在这里插入图片描述][2ffcda00d8d645cf925053551c21dec3.png]

## 五.数组的一些常用方法 ##

### 1.数组转换字符串 ###

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

### 2.数组拷贝 ###

int[] arr = {
        1, 2, 3, 4, 5};
            int[] newarr = new int[3];
            newarr = Arrays.copyOf(arr, arr.length);
            System.out.println(Arrays.toString(newarr));

![在这里插入图片描述][f467d07c2c3f4bee8d49c1a1d847ec51.png]

### 3.二分查找 ###

首先先进行对数组排序

public static int binarySearch(int[]arr,int toFind) {
        
                int left = 0;
                int right = arr.length - 1;
                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;
            }

### 4.冒泡排序 ###

public static void bubbleSort(int[] arr) {
        
            for (int i = 0; i < arr.length; i++) {
        
                for (int j = 1; j < arr.length-i; j++) {
        
                    if (arr[j-1] > arr[j]) {
        
                        int tmp = arr[j - 1];
                        arr[j - 1] = arr[j];
                        arr[j] = tmp;
                    }
                }
            } 
        }

当然了，Arrays.sort更便捷

### 5.数组逆序 ###

public static void reverse(int[] arr) {
        
            int left = 0;
            int right = arr.length - 1;
            while (left < right) {
        
                int tmp = arr[left];
                arr[left] = arr[right];
                arr[right] = tmp;
                left++;
                right--;
    
            }
        }

## 总结 ##

好了，今天关于数组的博客到这里结束了，欢迎大佬指正，希望大佬们能给个三连，在评论区畅所欲言啊。

[d2505bb6a3f14b7fa0c559ed8c5e8e61.png]: https://img-blog.csdnimg.cn/d2505bb6a3f14b7fa0c559ed8c5e8e61.png
[9fe43afd8d724181b39625d1c2ee5ba2.png]: https://img-blog.csdnimg.cn/9fe43afd8d724181b39625d1c2ee5ba2.png
[27ac296742d74e6795642be449d80171.png]: https://img-blog.csdnimg.cn/27ac296742d74e6795642be449d80171.png
[2ffcda00d8d645cf925053551c21dec3.png]: https://img-blog.csdnimg.cn/2ffcda00d8d645cf925053551c21dec3.png
[f467d07c2c3f4bee8d49c1a1d847ec51.png]: https://img-blog.csdnimg.cn/f467d07c2c3f4bee8d49c1a1d847ec51.png