阿里面試：我差點倒在了數組上

原創 有头发的代码匠 2020-06-19 07:13

一、數組的概述

1.1 什麼是數組？

數組(Array)是多個相同類型數據按一定順序排列的集合，並使用一個名字命名，並通過編號的方式對這些數據進行統一管理。

1.2 數組的相關概念

數組名
下標(或索引)
元素
數組的長度

1.3 數組的特點

（1）創建數組對象會在內存中開闢一整塊連續的空間，而數組名中引用的是這塊連續空間的首地址。
（2）數組本身是引用數據類型，而數組中的元素可以是任何數據類型，包括基本數據類型和引用數據類型。
（3）數組的長度一旦確定，就不能修改。
（4）數組是有序排列的，我們可以直接通過下標(或索引)的方式獲取指定位置的元素，速度很快。

1.4 數組的分類

按照維度分：一維數組、二維數組、多維數組
按照元素的數據類型分：基本數據類型元素的數組、引用數據類型元素的數組(即對象數組)

二、一維數組的使用

2.1 數組的聲明和初始化

2.1.1 靜態初始化

靜態初始化是指：數組的初始化和數組元素的賦值操作同時進行

int[] ids=new int[]{1001,1002,1003,1004};

2.1.2 動態初始化

動態初始化是指：數組的初始化和數組元素的賦值操作分開進行

String[] names=new String[4];
names[0]="張三";//數組的下標（索引）從0開始，到數組的長度-1結束
names[1]="李四";
names[2]="王五";
names[3]="趙六";

注意：數組初始化時，要指定數組的長度，因爲只有確定了數組的長度之後，才能在內存中開闢所需要的空間。
並且數組一旦初始化完成，其長度就確定了。

2.2 調用數組指定位置的元素(通過下標調用)

System.out.println("id:"+ids[0]+",name:"+names[0]);
System.out.println("id:"+ids[1]+",name:"+names[1]);
System.out.println("id:"+ids[2]+",name:"+names[2]);
System.out.println("id:"+ids[3]+",name:"+names[3]);

2.3 獲取數組的長度

通過length屬性獲取

System.out.println(ids.length); //4
System.out.println(names.length); //4

2.4 遍歷數組元素

2.4.1 使用for循環遍歷

for (int i=0;i<ids.length;i++){
    System.out.println(ids[i]);
}

2.4.2 使用foreach循環遍歷

for (String name:names) {
    System.out.println(name);
}

2.5 數組元素的默認初始化值在這裏插入圖片描述 2.5.1 對於基本數據類型而言，默認初始化值各有不同

//數組元素是整型(int short long byte)：0
int[] arr1=new int[4];
for (int i=0;i<arr1.length;i++){
    System.out.println(arr1[i]);
}

System.out.println("-------------------");

short[] arr2=new short[4];
for (int i=0;i<arr2.length;i++){
    System.out.println(arr2[i]);
}

System.out.println("-------------------");

long[] arr3=new long[4];
for (int i=0;i<arr3.length;i++){
    System.out.println(arr3[i]);
}

System.out.println("-------------------");

byte[] arr4=new byte[4];
for (int i=0;i<arr4.length;i++){
    System.out.println(arr4[i]);
}

運行結果：
在這裏插入圖片描述

//數組元素是浮點型(double float)：0.0
double[] arr5=new double[4];
for (int i=0;i<arr5.length;i++){
    System.out.println(arr5[i]);
}

System.out.println("-------------------");

float[] arr6=new float[4];
for (int i=0;i<arr6.length;i++){
    System.out.println(arr6[i]);
}

運行結果：
在這裏插入圖片描述

//數組元素是char型：0(表現爲空)
char[] arr7=new char[4];
for (int i=0;i<arr7.length;i++){
    System.out.println(arr7[i]);
}

運行結果：
在這裏插入圖片描述

//數組元素是boolean型：false
boolean[] arr8=new boolean[4];
for (int i=0;i<arr8.length;i++){
    System.out.println(arr8[i]);
}

運行結果：
在這裏插入圖片描述

//數組元素是引用數據類型：null
String[] arr9=new String[4];
for (int i=0;i<arr9.length;i++){
    System.out.println(arr9[i]);
}

運行結果：
在這裏插入圖片描述

2.6 數組的內存解析

new出來的對象、數組都存放在堆中；
局部變量都存放在棧中。

1. int[] arr = new int[4];
2. arr1[1] = 1;
   arr1[2] = 2;
3. arr1 = new int[5];
4. System.out.println(arr1[1]);//0

當執行第1步時，會先在堆中開闢出數組所需要的內存空間，初始化值爲0，如下圖所示：
在這裏插入圖片描述
當執行第2步，爲數組元素賦值時，如下圖所示：
在這裏插入圖片描述
當執行第3步，會在堆中重新開闢新的內存空間，然後改變arr1的首地址指向，如下圖所示：在這裏插入圖片描述
當執行第4步，會輸出新的內存空間的默認值，所以輸出結果爲0。

三、二維數組的使用

二維數組是以數組作爲數組元素的數組，即“數組的數組”。
對於二維數組的理解，我們可以看成是一維數組array1又作爲另一個一維數組array2的元素而存在。

3.1 數組的聲明和初始化

3.1.1 靜態初始化

靜態初始化是指：數組的初始化和數組元素的賦值操作同時進行

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

3.1.2 動態初始化

動態初始化是指：數組的初始化和數組元素的賦值操作分開進行

//動態初始化1
int[][] arr2=new int[2][2];
arr2[0][0]=1;
arr2[0][1]=2;
arr2[1][0]=3;
arr2[1][1]=4;

//動態初始化2
int[][] arr3=new int[2][];
//爲數組中第一個元素賦值
arr3[0]=new int[2];
//爲數組中第一個元素中的元素賦值
arr3[0][0]=1;
arr3[0][1]=2;
//爲數組中第二個元素賦值
arr3[1]=new int[3];
//爲數組中第二個元素中的元素賦值
arr3[1][0]=3;
arr3[1][1]=4;
arr3[1][2]=5;

3.2 調用數組指定位置的元素(通過下標調用)

System.out.println(arr2[1][0]);//3
//注意：使用動態初始化方式2時，必須先賦值才能調用，否則會報空指針異常
System.out.println(arr3[1][2]);//5

3.3 獲取數組的長度

通過length屬性獲取

int[][] arr1=new int[][]{{1,2,3},{4,5},{6,7,8}};
//獲取外層數組的長度
System.out.println(arr1.length);//3
//獲取內層數組的長度
System.out.println(arr1[0].length);//3
System.out.println(arr1[1].length);//2
System.out.println(arr1[2].length);//3

3.4 遍歷數組元素

使用嵌套for循環遍歷

int[][] arr1=new int[][]{{1,2,3},{4,5},{6,7,8}};
for (int i=0;i<arr1.length;i++){
    for (int j=0;j<arr1[i].length;j++){
        System.out.print(arr1[i][j]+" ");
    }
    System.out.println();
}

遍歷結果
在這裏插入圖片描述

3.5 二維數組元素的默認初始化值

規定:二維數組分爲外層數組的元素，內層數組的元素
int[][] arr = new int[4][3];
外層元素: arr[0],arr[1],arr[2],arr[3]
內層元素: arr[0][0],arr[1][2]等


針對於動態初始化方式一:比如: int[][] arr = new int[4][3];
外層元素的初始化值爲:地址值
內層元素的初始化值爲:與一維數組初始化情況相同


針對於初始化方式二:比如: int[][] arr = new int[4][];
外層元素的初始化值爲: null (因爲數組是引用類型，默認值爲null)
內層元素的初始化值爲:不能調用，否則會報空指針異常。

//動態初始化方式一
int[][] arr4= new int[3][2];
System.out.println(arr4[0]);//[I@4554617c  [表示一維數組 I表示int類型 @4554617c表示首地址值
System.out.println(arr4[0][0]);//0

System.out.println("-------------------");

String[][] arr5= new String[3][2];
System.out.println(arr5[0]);//[Ljava.lang.String;@74a14482
System.out.println(arr5[0][0]);//null

運行結果：
在這裏插入圖片描述

//動態初始化方式二
int[][] arr6= new int[3][];
System.out.println(arr6[0]);//null (因爲數組是引用類型，默認值爲null)
System.out.println(arr6[0][0]);//Exception in thread "main" java.lang.NullPointerException

運行結果：
在這裏插入圖片描述

3.6 二維數組的內存解析

1. int[][] arr1 = new int[4][];
2. arr1[1] = new int[]{1,2,3};
3. arr1[2] = new int[4];
4. arr1[2][1] = 30;

當執行第1步時，會先在堆中開闢出數組所需要的內存空間，初始化值爲null，如下圖所示：
在這裏插入圖片描述
當執行第2步，爲數組元素arr1[1]賦值時，如下圖所示：
在這裏插入圖片描述
當執行第3步，爲數組元素arr1[2]賦值時，如下圖所示：
在這裏插入圖片描述
當執行第4步，爲數組元素arr1[2][1]賦值時，如下圖所示：
在這裏插入圖片描述

四、數組中常見的算法

4.1 數組的複製

public class ArrayTest {
    public static void main(String[] args) {
        //數組的複製
        String[] arr1=new String[]{"A","B","C","D","E"};
        String[] arr2=new String[arr1.length];
        for (int i=0;i<arr1.length;i++){
            arr2[i]=arr1[i];
        }
        //打印出複製後的數組
        for (int i=0;i<arr2.length;i++){
           System.out.println(arr2[i]);
        }
    }
}

運行結果：
在這裏插入圖片描述

4.2 數組的反轉

public class ArrayTest2 {
    public static void main(String[] args) {
        //數組元素的反轉
        String[] arr=new String[]{"A","B","C","D","E"};
        for (int i=0;i<arr.length/2;i++){ //相當於把A和E、B和D的位置顛倒一下
            String temp=arr[i];
            arr[i]=arr[arr.length-i-1];
            arr[arr.length-i-1]=temp;
        }
        //打印出反轉後的數組
        for (int i=0;i<arr.length;i++){
           System.out.println(arr[i]);
        }
    }
}

運行結果：
在這裏插入圖片描述

4.3 數組的查找

4.3.1 線性查找

線性查找又稱順序查找，是一種最簡單的查找方法，它的基本思想是從第一個記錄開始，逐個比較記錄的關鍵字，直到和給定的K值相等，則查找成功；若比較結果與文件中n個記錄的關鍵字都不等，則查找失敗。

public class ArrayTest3 {
    public static void main(String[] args) {
        //線性查找
        String[] arr=new String[]{"A","B","C","D","E"};
        String target="C"; //要查找的目標元素
        //定義一個標識符，用來表示是否查到了目標 false:沒找到 true：查找到了
        boolean flag=false;
        for (int i=0;i<arr.length;i++){
            if(target.equals(arr[i])){
                System.out.println("查找到了目標元素，位置爲："+i);
                flag=true;
                break;
            }
        }
        if(flag=false){
            System.out.println("未查找到目標元素！");
        }
    }
}

運行結果：
在這裏插入圖片描述

4.3.2 二分法查找

二分法查找又稱折半查找，二分法查找的基本思想是設數組中的元素從小到大有序地存放在數組中（注：二分法查找的關鍵，首先數組元素必須從小到大有序排列）

  1. 首先將給定值target與數組中間位置上元素的值(key)比較，如果相等，則查找成功；
  2. 否則，若target小，則在數組前半部分中繼續進行二分法查找；
  3. 若target大，則在數組後半部分中繼續進行二分法查找。

這樣，經過一次比較就縮小一半的查找區間，如此進行下去，直到查找成功或查找失敗。

public class ArrayTest4 {
    public static void main(String[] args) {
        //二分法查找
        int[] arr =new int[]{1,3,5,6,7,10,12,36,66,88};
        int target=12; //要查找的目標
        int head=0; //首索引
        int end=arr.length-1; //末索引
        //定義一個標識符，用來表示是否查到了目標 false:沒找到 true：查找到
        boolean flag=false;
        while (head<=end){
            int middle=(head+end)/2; //中間位置的索引
            if(target==arr[middle]){
                System.out.println("查找到了目標元素，位置爲："+middle);
                flag=true;
                break;
            }else if(target<arr[middle]){
                end=middle-1;
            }else { //target>arr[middle]
                head=middle+1;
            }
        }

        if(flag=false){
            System.out.println("未查找到目標元素！");
        }
    }
}

運行結果：
在這裏插入圖片描述

4.4 數組的排序

4.4.1 冒泡排序

排序思想：

  1. 比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。
  2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
  3. 針對所有的元素重複以上的步驟，除了最後一個。
  4. 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較爲止。

排序方法演示
在這裏插入圖片描述
代碼實現

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr =new int[]{3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
        //冒泡排序
        for (int i=0;i<arr.length-1;i++){ //外循環爲排序趟數，n個數進行n-1趟
            //內循環爲每趟比較的次數，第i趟比較n-i次
            for (int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){ //相鄰元素比較，如果前一個元素比後一個大，則交換兩者的位置
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        //輸出排序後的數組
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

運行結果：
在這裏插入圖片描述

4.4.2 快速排序

快速排序是迄今爲止所有內排序算法中速度最快的一種。它的基本思想是:任取待排序序列中的某個元素作爲標準(也稱爲支點、界點一般取第一個元素)，通過一次劃分，將待排元素分爲左右兩個子序列，左子序列元素的排序碼均小於基準元素的排序碼，右子序列的排序碼則大於或等於基準元素的排序碼，然後分別對兩個子序列繼續進行劃分，直至每一個序列只有一個元素爲止。最後得到的序列便是有序序列。

排序方法演示
在這裏插入圖片描述
代碼實現

public class QuickSort {
        public static void quickSort(int[] arr,int low,int high){
            int i,j,base;
            if(low>high){
                return;
            }
            i=low;
            j=high;
            //temp就是基準位
            base = arr[low];
            
            while (i<j) {
                //先看右邊，依次往左遞減
                while (base<=arr[j]&&i<j) {
                    j--;
                }
                //再看左邊，依次往右遞增
                while (base>=arr[i]&&i<j) {
                    i++;
                }
                //如果滿足條件則交換
                if (i<j) {
                    int t = arr[j];
                    arr[j] = arr[i];
                    arr[i] = t;
                }
            }
            //最後將基準爲與i和j相等位置的數字交換
            arr[low] = arr[i];
            arr[i] = base;
            //遞歸調用左半數組
            quickSort(arr, low, j-1);
            //遞歸調用右半數組
            quickSort(arr, j+1, high);
        }
        
        public static void main(String[] args){
            int[] arr = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
            quickSort(arr, 0, arr.length-1);
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+" ");
            }
        }
}

運行結果：
在這裏插入圖片描述

4.5 Arrays工具類的使用

java.util.Arrays類即爲操作數組的工具類，包含了用來操作數組（比如排序和搜索）的各種方法。
在這裏插入圖片描述

4.5.1 boolean equals(int[] a,int[] b) 判斷兩個數組是否相等

//boolean equals(int[] a,int[] b) 判斷兩個數組是否相等
int[] arr1=new int[]{1,2,3,4,5};
int[] arr2=new int[]{1,3,5,7,9};
int[] arr3=new int[]{1,3,5,7,9};
boolean isEquals=Arrays.equals(arr1, arr2);
boolean isEquals2=Arrays.equals(arr2, arr3);
System.out.println(isEquals); //false
System.out.println(isEquals2); //true

運行結果：
在這裏插入圖片描述

4.5.2 String toString(int[] a) 輸出數組信息

// String toString(int[] a) 輸出數組信息
int[] arr1=new int[]{1,2,3,4,5};
System.out.println(Arrays.toString(arr1));

運行結果：
在這裏插入圖片描述

4.5.3 void fill(int[] a,int val) 將指定值填充到數組之中

int[] arr1=new int[]{1,2,3,4,5};
System.out.println(Arrays.toString(arr1)); //輸出原數組
Arrays.fill(arr1,6); //將指定值填充到數組之中
System.out.println(Arrays.toString(arr1)); //輸出用指定值填充過的數組

運行結果：
在這裏插入圖片描述

4.5.4 void sort(int[] a) 對數組進行排序

int[] arr1=new int[]{6,2,5,3,1,8};
Arrays.sort(arr1); //對數組進行排序
System.out.println(Arrays.toString(arr1)); //輸出排序後的數組

運行結果：
在這裏插入圖片描述

4.5.5 int binarySearch(int[] a,int key) 對排序後的數組使用二分法檢索指定的值

int[] arr1=new int[]{1,2,5,7,13,28,36};
int index=Arrays.binarySearch(arr1,7); //使用二分法檢索指定的值，返回值爲正數時，則爲查找值的索引位置；返回值爲負數，表示未查找到
System.out.println(index);

運行結果：
在這裏插入圖片描述

4.6 數組中常見的異常在這裏插入圖片描述

數組也是Java中一個非常重要的知識點，無論是在日常開發還是面試和筆試中都經常用到。希望本篇文章能夠對你有所幫助。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Java開發必讀，談談對Spring IOC與AOP的理解

本文分享自華爲雲社區《超詳細的Java後臺開發面試題之Spring IOC與AOP》，作者：GaussDB 數據庫。 一、前言 IOC和AOP是Spring中的兩個核心的概念，下面談談對這兩個概念的理解。 二、IOC（Inverse o

原創 2024-06-07 22:57:21

一文搞懂 Spring 循環依賴

這個其實是一個特別高頻的面試題，松哥也一直很想和大家仔細來聊一聊這個話題，網上關於這塊的文章很多，但是我一直覺得要把這個問題講清楚還有點難度，今天我來試一試，看能不能和小夥伴們把這個問題梳理清楚，當然，如果小夥伴們覺得看文章不過癮，松哥也有

原創 2024-06-06 13:11:47

營銷系統黑名單優化：位圖的應用解析

背景 營銷系統中，客戶投訴是業務發展的一大阻礙，一般會過濾掉黑名單高風險賬號，並配合頻控策略，來減少客訴，進而增加營銷效率，減少營銷成本，提升營銷質量。 營銷系統一般是通過大數據分析建模，在CDP（客戶數據平臺，以客戶爲核心，圍繞數據融

京東雲開發者 2024-06-06 11:54:12

JeecgBoot 企業級開源低代碼平臺，v3.7.0 里程碑大版本發佈

項目介紹 JeecgBoot是一款企業級的低代碼平臺！前後端分離架構 SpringBoot2.x，SpringCloud，Ant Design&Vue3，Mybatis-plus，Shiro，JWT 支持微服務。強大的代碼生成器讓前後端代

原創 2024-06-13 13:12:19

Java生成PDF文件，並將PDF轉爲圖片

引入依賴 <dependency> <groupId>com.itextpdf</groupId> <artifactId>itextpdf</artifactId>

原創 2024-06-12 23:21:32

SonarQube代碼質量檢測線上配置指南

SonarQube 是一個開源的代碼質量管理平臺，用於自動審查代碼，檢測潛在的錯誤、漏洞和不良實踐，以提高軟件質量。本文檔旨在指導您完成SonarQube在生產環境中的配置，確保您的項目代碼得到持續且有效的質量監控。 1. 環境準備 1.1

原創 2024-06-12 01:12:57

雲原生週刊：Kubernetes 十週年 ｜ 2024.6.11

開源項目推薦 Kubernetes Goat Kubernetes Goat 是一個故意設計成有漏洞的 Kubernetes 集羣環境，旨在通過交互式實踐場地來學習並練習 Kubernetes 安全性。 kube-state-metrics

原創 2024-06-11 23:16:00

「Java開發指南」如何使用Spring註釋器實現Spring控制器？（一）

本教程將引導您使用Spring Annotator實現Spring控制器，標準Java類被添加到搭建項目中，Spring Annotator Spring啓用Java類。 雖然本教程的重點是Spring控制器，但是Spring Annota

原創 2024-06-11 12:18:10

奇怪！應用的日誌呢？？

1. 問題回顧     問題背景是在進行中臺應用中間件遷移過程中，發現存在項目啓動失敗或者項目正常啓動（jsf正常掛載並正常運行，mq正常發送和消費）但是無任何日誌打印現象。更奇怪的是不打印日誌竟然是偶發的，在測試環境中多次部

原創 2024-06-11 11:55:14

華爲雲短信服務教你用C++實現Smgp協議

本文分享自華爲雲社區《華爲雲短信服務教你用C++實現Smgp協議》，作者：張儉。 引言&協議概述 中國聯合網絡通信有限公司短消息網關係統接口協議（SGIP）是中國網通爲實現短信業務而制定的一種通信協議，全稱叫做Short Message

原創 2024-06-11 10:57:30

從缺陷到創新：質量保障的新視角

1.背景： 最近一段時間研發大佬們在積極的治理告警，經過一段時間的治理，現在告警情況已經有了很大的改觀，但難免還有漏網之魚；具體我們可以以下邊一個例子來看： 這是一個生產的UMP告警，通過這個告警我們發現XXX這個應用的堆內存使用率

原創 2024-06-07 23:55:01

CI+GPT雙引擎驅動，開啓AI代碼評審新紀元

一. 現狀問題 代碼評審 Code Review 是提高代碼質量、促進團隊合作、知識間共享的關鍵環節，對於系統代碼質量和穩定性都至關重要。 【人爲代碼評審（Code Review）】存在很多弊端 時間消耗大：代碼評審是一

京東雲開發者 2024-06-07 23:54:54

Junit4遇上chatGPT

這是一篇適合Java工程師體質的AI開發教程。 本教程會教你寫一個簡單的junit4的Rule，該Rule在基於junit4的測試方法失敗後，自動向GPT發送錯誤信息並通過GPT分析得出代碼修改建議。 首先向AI問好 簡單的通過AI，讓它

原創 2024-06-06 23:55:13

基於阿里雲服務網格流量泳道的全鏈路流量管理（三）：無侵入式的寬鬆模式泳道

作者：尹航 在前文《基於阿里雲服務網格流量泳道的全鏈路流量管理（一）：嚴格模式流量泳道》、《基於阿里雲服務網格流量泳道的全鏈路流量管理（二）：寬鬆模式流量泳道》中，我們介紹了流量泳道的概念、使用流量泳道進行全鏈路灰度管理的方案，以及阿里雲服

原創 2024-06-05 21:13:51

導入地址表鉤取技術解析

前置知識 導入表 在一個可執行文件需要用到其餘DLL文件中的函數時，就需要用到導入表，用於記錄需要引用的函數。例如我們編寫的可執行文件需要用到CreateProcess函數，就需要用到kernel32.dll文件並且將其中的Create

原創 2024-06-06 11:14:53