50 个最热门的数组面试问题及答案（2025 年）

蕾妮亚历山大By蕾妮亚历山大 营业时间 最后更新于

以下是面向新手和有经验的求职者的数组面试问题和答案，可帮助您获得理想的工作。数组是编程不可或缺的一部分，C、C++、Python、Java 和 Perl 等各种编码语言都使用数组。

1）数组是什么意思？

  • 数组是一组相似的数据类型。
  • 数组对象存储具有相同类型的多个变量。
  • 它可以保存原始类型和对象引用。
  • 数组始终是固定的

免费 PDF 下载：数组面试问题与答案

2）如何创建数组？

数组的声明与变量的声明类似，但需要在类型后添加 []。 计费示例： int [] intArray; 我们可以像其他变量一样将 Java 数组声明为字段、静态字段、局部变量或参数。数组是该类型变量的集合。以下是更多 Java 数组声明示例：

String [] stringArray;
MyClass [] myClassArray;

其他编程语言也是如此。

不要错过：

3）Array 的优点和缺点？

优点：

  • 我们可以在数组中放置其他数据结构，如堆栈、队列、链表、树、图等。
  • 数组可以一次对多个元素进行排序。
  • 我们可以使用索引访问数组的元素。

缺点：

  • 我们必须提前声明数组的大小。然而，在声明数组时，我们可能不知道我们需要多大的大小。
  • 数组是静态结构。这意味着数组大小始终是固定的，因此我们无法增加或减少内存分配。

4）我们可以在运行时改变数组的大小吗？

不，我们不能改变数组大小。尽管有类似的数据类型允许改变大小。

阵列面试题
阵列面试题

5）可以声明一个数组而不指定其大小吗？

不，我们不能声明一个数组而不指定其大小。如果我们声明一个没有指定大小的数组，它会抛出编译时错误。 计费示例： marks = new int []; //编译器错误

6）Array 的默认值是什么？

任何新数组始终使用默认值进行初始化，如下所示

  • 对于字节、短整型、整数、长整型 - 默认值为零 (0)。
  • 对于浮点数、双精度数 - 默认值为 0.0。
  • 对于布尔值 - 默认值为 false。
  • 对于对象 — — 默认值为空。

7）如何打印数组的元素？

这是打印数组元素的代码。

int schoolmarks [] = {25, 30, 50, 10, 5 };

System.out.println (Arrays.toString (schoolmarks));

输出为： [25、30、50、10、5]

数组元素

8）如何比较两个数组？

如果两个数组的大小和数据类型相同，则可以使用“Arrays.equal ()”进行比较

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

int[] num2 = { 4, 5, 6 };

System.out.println (Arrays. Equals (num1, num2)); //false

Int [] num3 = {1, 2, 3};

System.out.println (Arrays.equals (num1, num3)); //true

9）如何对数组进行排序？

可以使用内置的静态方法 Arrays.sort()。

Int Marks [] = {12, 5, 7, 9};

Arrays.sort(Marks);

System.out.println(Arrays.toString(Marks));//[5, 7, 9, 12]

10）我们可以将数组大小声明为负数吗？

不可以。我们不能将负整数声明为数组大小。如果声明，则不会出现编译时错误。但是，运行时会抛出 NegativeArraySizeException 异常。

11）什么时候会得到ArrayStoreException？

这是一个运行时异常。例如，我们只能在字符串数组中存储字符串元素。如果有人试图在此字符串数组中插入整数元素，那么我们将在运行时获得 ArrayStoreException。

12）分配数组后可以添加或删除元素吗？

不，这是不可能的。

13）匿名数组的含义是什么？请举例说明？

匿名数组，就是没有任何引用的数组。 例子：-

//Creating anonymous arrays

System.out.println(new int[]{11, 12, 13, 14, 15}.length); //Output : 5

System.out.println(new int[]{31, 94, 75, 64, 41}[1]); //Output : 94 }}

14）int[] a 和 int a[] 有什么区别？

没有区别两者都是 法律 语句。

15) 有 2 个 int 类型数组数据类型。一个包含 50 个元素，另一个包含 30 个元素。我们可以将 50 个元素的数组分配给 30 个元素的数组吗？

是的，只要它们属于同一类型，我们就可以分配。编译器将只检查数组的类型，而不是大小。

int[] ab = new int[30];

int[] cd = new int[50];

a = b; //Compiler checks only type, not the size

16) int a[] = new int[3]{1, 2, 3} – 这是在 java 中声明数组的正确方法吗？

不。我们在提供数组元素时不应该提及数组的大小。

17) 如何将一个数组复制到另一个数组？

Java 中有以下四个技巧可以复制数组。

  1. 使用“For 循环”
  2. 使用“Arrays.copyOf()”方法
  3. 使用“System.arraycopy()”方法
  4. 使用“clone()”方法

18）Java 中的“锯齿状”数组是什么？

交错数组是包含不同长度的数组。交错数组也称为多维数组。

19）什么时候发生ArrayIndexOutOfBoundsException？

这是一个运行时异常。当程序尝试访问数组的无效索引时，就会发生这种情况。索引大于数组的大小或为负数。

20) 你能解释一下 Java 中声明多维数组的不同步骤吗？

//2D Arrays

int[][] twoArray1;

int twoArray2[][];

int[] twoArray3[];

//3D Arrays

int[][][] threeArray1;

int threeArray2[][][];

int[] threeArray3[][];

int[][] threeArray4[];

//4D Arrays

int[][][][] fourArray1;

int fourArray2[][][][];

int[] fourArray3[][][];

int[][] fourArray4[][];

int[][][] fourArray5[];

21) 如何在数组中搜索特定元素？

我们可以使用 Arrays.binarySearch() 方法。此方法使用二分搜索算法。

22) 如果不初始化数组会发生什么？

数组将具有默认值。

23）如何找到数组中的重复元素？

使用蛮力方法： 在这个方法中，我们将数组中的每个元素与其他元素进行比较。如果发现任何两个元素相等或相同，则声明它们为重复项。请参阅以下代码，了解相同的方法。

public class DuplicatesInArray {

public static void main(String[] args) {

String[] strArray1 = {"abc1", "def1", "mno1", "xyz1", "pqr1", "xyz1", "def1"};

for (int i = 0; i < strArray1.length-1; i++) {

for (int j = i+1; j < strArray1.length; j++) {

if( (strArray1[i].equals(strArray1[j])) && (i != j) ) {

System.out.println("Duplicates : "+strArray1[j]);

}}}} }

输出：重复元素为：def1 重复元素为：xyz1

24)我们可以将泛型与数组一起使用吗？

不，我们不能将泛型与数组一起使用。

25）如何在 java 中迭代数组？

1）使用普通 for 循环

public class MainClass1

{

public static void main(String[] args)

{

int[] a1 = new int[]{45, 12, 78, 34, 89, 21};

//Iterating over an array using normal for loop

for (int i = 0; i < a1.length; i++)

{

System.out.println(a1[i]);

}}}

2）使用扩展的新 for 循环

public class MainClass1

{

public static void main(String[] args)
{
int[] a2 = new int[]{45, 12, 78, 34, 89, 21};

//Iterating over an array using extended for loop

for (int i: a2){

System.out.println(i);

}}}

26)Java 中数组的内存分配在哪里？

在 Java 中，数组的内存总是分配在堆上，因为 Java 中的数组是对象。

27) 你能告诉我 Java 中数组的类名吗？

数组是一个对象。要获取类名，我们可以对对象使用 getClass().getName() 方法。

28）“int a[] = new int[3]{1, 2, 3}”——这是定义数组的合法方式吗？

不。我们在提供数组元素时不应该声明数组的大小。

29）什么是二维数组？

Java 中的数组的数组。我们可以像这样声明它们

int[][] p = new int[3][3]

这是一个 3×3 的矩阵。

30）Java 中有三维数组吗？

是的，Java 支持 N 维数组。Java 中的多维数组只不过是数组的数组，例如：二维数组是一维数组的数组。

31) 我们可以在 Java 中将数组变为 volatile 吗？

是的，我们可以在 Java 中将数组变为 volatile，但我们只能将指向数组的变量变为 volatile。

32）下面的代码输出什么？

int myArr[] = new int [7];

System.out.print(myArr);

答：输出将是垃圾值。myArr 是一个数组变量，如果是整数，则 myArr 指向一个数组。打印 myArr 将会打印垃圾值。这与打印 myArr[0] 不同。

33) Java 中访问数组元素的步骤是什么？

我们可以使用“索引”进行访问。索引从零（0）开始，因此第一个元素存储在位置零，最后一个元素为 Array.length - 1。 例子：- String strArr[] = new String []{“A”, “B”, “C”, “D”, “E”}; strArr[0] 表示“A”，strArr[2] 表示“C”。

34) 你能告诉我 Array 和 ArrayList 之间的区别吗？

排列 数组列表
该数组是静态的，具有固定大小，一旦声明就无法更改。 ArrayList 的大小不是静态的，而是动态的。随着元素添加到 ArrayList，其容量或大小会自动增加。
它既包含原始数据类型，也包含类的对象。 ArrayList 不包含原始数据类型但包含对象条目。
数组不具备泛型特性。 ArrayList 具有泛型特性。

35) 我们知道数组是对象，那么为什么我们不能写 strArray.length()？

数组是对象引用，就像 Java 中的类一样。我们可以使用 Object 的方法，如 toString() 和另一个针对数组的 hashCode()。Length 是数组的数据项，因此它不是方法。这就是我们使用 strArray.length 的原因。

36) 如何在 1 到 7 的整数数组中找到缺失的元素？

解决这个问题的方法是计算数组中所有数字的总和并与预期总和进行比较，差值就是缺失的数字。

int ar [] = new int[]{1,2,3,5,6,7};
  • 获取数字之和
  • 总计 = n*(n+1)/2
  • 从总和中减去所有数字，然后
  • 您将获得缺失的数字。
  • 根据以下逻辑，sumOfNnumberss 为 7*(7+1)/2=28

sumOfElements = 1+2+3+5+6+7=24 缺失元素为 = 28-24=4

int n = ar.length+1;

int total = n*(n+1)/2;

for(int i =0;i<ar.length;i++){

total -=ar[i];}

System.out.println(total);

37) 如何找出数组中的重复项？

String str = "HI RAHUL I AM FINE RAHUL"; // String with a duplicate word.

String[] words = str.split(" "); // Splitting and converting to Array .

for(int i = 0; i < words.length; i++){ //iterating array inside for loop

for(int j = i+1; j < words.length; j++){ //iterating same array inside another for loop

if (words[i].equals(words[j])){ // Using equal method i am verifying which word is repeating . System.out.println( words[i]); // here it will print duplicate .

}}}

38) 如何检查数组是否包含值？

这是一个带有值的 String[]

public static final String[] myNames = new String[] {"B","A","K","C"};

如果 myNames 包含该值，则返回 true，否则返回 false。这里有两个方法 isExists() 和 contains()，如果值可用，则返回 true，否则返回 false。 第一种方法 它将一个数组转换为 ArrayList。之后，它将测试数组是否包含任何值，如果包含则返回 true，否则返回 false。

public static <T> boolean isExists(final T[] array, final T object) {

return Arrays.asList(array).contains(object); }

第二种方法 此方法循环遍历数组并使用 equals() 方法搜索元素。这实际上是在 Java 中对数组执行线性搜索。如果数组包含指定值，则返回 true。

public static <T> boolean contains(final T[] array, final T v) {

for (final T e : array) { if (e == v || v != null && v.equals(e)) {

return true;

} }

return false;

} }

39）如何获取数组中的最大数和最小数？

答：本题逻辑：

  • 我们使用两个变量来存储最大数字和最小数字。
  • 首先，我们用 Integer.MIN_VALUE 初始化最大值，
  • 接下来，我们用 Integer.MAX_VALUE 初始化最小值。
  • 在 for 循环的每次迭代中，我们将比较当前数字与最大数字和最小数字，然后更新
  • 如果一个数字大于最大值，那么它就不能小于最小值。这意味着不需要检查第一个条件是否为真，
  • 我们将使用 if-else 代码块，其中 else 部分仅当第一个条件为假（即不真）时才会执行。
import java.util.Arrays;

public class MaximumMinimumArrayExample{

public static void largestAndSmallest(int[] numbers) {

int largest = Integer.MIN_VALUE;

int smallest = Integer.MAX_VALUE;

for (int number : numbers) {

if (number > largest) {

largest = number;

}

else if (number < smallest) {

smallest = number;

} }
System.out.println("Largest is : " + largest);

System.out.println("Smallest is : " + smallest); } }

40）如何对两个已排序数组进行交集？

答案：逻辑：如果元素存在或在两个数组中可用，则打印该元素。

  • 使用两个索引变量 i 和 j，之后初始值 i = 0，j = 0
  • 如果 arr01 [i] 小于 arr02 [j] 则增加 i。
  • 如果 arr01 [i] 大于 arr02 [j] 则增加 j。
  • 如果两者相同，则打印其中任何一个并增加 i 和 j。
public static void getIntersection(int arr01[], int arr02[], int m, int n){

int i = 0, j = 0;

while (i < m && j < n){

if (arr01[i] < arr02[j])

i++;

else if (arr02[j] < arr01[i])

j++;

else{

System.out.print(arr02[j++]+" ");

i++;

}

}

}

public static void main(String args[]){

int arr01[] = {1, 2, 4, 5, 6};

int arr02[] = {2, 3, 5, 7};

int m = arr01.length;

int n = arr02.length;

getIntersection(arr01, arr02, m, n);

}

41）如何从数组中获取前两个数字？

答：逻辑是：

  • 我们将用 Integer.MIN_VALUE 分配第一个变量 max01

此外，第二个变量max02与max01相同，即Integer.MIN_VALUE。

  • 我们将迭代此数组并将每个数字与 max01 和 max02 进行比较，
  • 如果当前数字大于 max1，则分配 max01 = 数字和 max02 = max1。
  • 否则，如果它仅大于 max02，那么我们将仅使用当前数字更新 max02。
  • 在迭代结束时，max01 和 max02 指向给定数组的前两个数字。
import java.util.Arrays;

public class TopTwoMaximumNumbers{

public static void main(String args[]) {

topTwoNumbers(new int[]{20, 34, 21, 87, 92, Integer.MAX_VALUE});

topTwoNumbers(new int[]{0, Integer.MIN_VALUE, -2});

topTwoNumbers(new int[]{Integer.MAX_VALUE, 0, Integer.MAX_VALUE});

topTwoNumbers(new int[]{1, 1, 0}); }

public static void topTwoNumbers(int[] numbers) {

int max01 = Integer.MIN_VALUE;

int max02 = Integer.MIN_VALUE; for (int number : numbers) {

if (number > max01) { max02 = max01; max01 = number; }

else if (number > max02) { max02 = number; } }

System.out.println("First largest number is : " + max01);

System.out.println("Second largest number is : " + max02); } }

42) 如何从数组中剪切或删除一个元素？

答：逻辑是：我们可以使用 Apache Commons ArrayUtils 根据索引删除或剪切元素。ArrayUtils 有几种重载的 remove() 方法。

import java.util.Arrays;

import org.apache.commons.lang.ArrayUtils;

public class RemoveFromArray{

public static void main(String args[]) {

//let's create an array for demonstration purpose

int[] testArr = new int[] { 10, 102, 13, 14, 105};

System.out.println("Array size : " + testArr.length );

System.out.println("Find Contents : " + Arrays.toString(testArr));

//let's remove or delete an element from Array using Apache Commons ArrayUtils

testArr = ArrayUtils.remove(testArr, 2); //removing element at index 2

//Size of array must be 1 less than original array after deleting an element

System.out.println("Size of array after removing : " + testArr.length);

System.out.println("Content of Array : "+ Arrays.toString(testArr));

} }

43）反转数组的逻辑是什么？

答：逻辑：以相反的顺序打印元素。

  • 声明一个
String Array String[] s = new String[]{"My","Leg","is","cut"};
  • 使用 for 循环进行迭代，以相反的顺序获取所有元素，即从终点到起点。
public static void main(String[] args)

{String[] s = new String[]{"My","Leg","is","cut"};

for(int i=s.length-1; i>=0; i--){

System.out.println("reverse "+s[i]);}}

44) 如何找到整数数组中第二大元素？

答：逻辑是：

  • 使用 for 循环迭代给定的数组。
  • （第一个 if 条件 arr[i] > 最大）：
  • 如果当前数组值大于最大值，则
  • 将最大值移动到第二大值，并使当前值成为最大值
  • （第二个 if 条件 arr[i] > secondLargest ）
  • 如果当前值小于最大值，并且

大于 secondLargest 则当前值变为

public static void main(String[] args) {

int myArr[] = { 14, 46, 47, 86, 92, 52, 48, 36, 66, 85 };

int largest = myArr[0];

int secondLargest = myArr[0];

System.out.println("The given array is:" );

for (int i = 0; i < myArr.length; i++) {

System.out.print(myArr[i]+"\t");

}

for (int i = 0; i < myArr.length; i++) {

if (myArr[i] > largest) {

secondLargest = largest;

largest = myArr[i];

} else if (myArr[i] > secondLargest) {secondLargest = myArr[i];

}}

System.out.println("\nSecond largest number is:" + secondLargest);

}

45）编写一个程序来对给定数组的值进行求和。

答：逻辑是：

  • 声明并分配 int 变量，即 sum =0。
  • 使用 for 循环迭代给定的数组。
  • 将所有数组元素相加并将其保存在此变量中，即为总和。
Public static void main(String[] args) {

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

int sum = 0;

for (int i: my_array)

sum += i;

System.out.println("The sum is " + sum);

}

46) 如何区分数组中的零和非零？

答：逻辑是：

  • 将计数器初始化为 0
  • 从左到右遍历 inputArray
  • 如果 inputArray[i] 非零
  • 将 inputArray[i] 分配给 inputArray[counter]
  • 将计数器加 1
  • 将剩余元素赋值为零
Public class SeparateZerosFromNonZeros

{ static void moveZerosToEnd(int inputArray[]) { int counter = 0;

for (int i = 0; i < inputArray.length; i++)

{

if(inputArray[i] != 0) {

inputArray[counter] = inputArray[i];

counter++;

} }

while (counter < inputArray.length) {

inputArray[counter] = 0;

counter++; }

System.out.println(Arrays.toString(inputArray));

}

public static void main(String[] args) {

moveZerosToEnd(new int[] {12, 0, 7, 0, 8, 0, 3});

moveZerosToEnd(new int[] {1, -5, 0, 0, 8, 0, 1});

moveZerosToEnd(new int[] {0, 1, 0, 1, -5, 0, 4});

moveZerosToEnd(new int[] {-4, 1, 0, 0, 2, 21, 4});

} }

47) 编写一个程序，在数组中的特定位置插入一个元素？

答：逻辑是：

  • 在数组的第 3 个位置插入一个元素 (索引->2，值->5)
  • 使用 for 循环以相反的顺序迭代给定的数组。
  • 现在在 for 循环后插入给定的位置和值。
Public static void main(String[] args) {

int[] my_array = {25, 14, 56, 15, 36, 56, 77, 18, 29, 49};

int Index_position = 2;

int newValue = 5;

System.out.println("Original Array : "+Arrays.toString(my_array));

for(int i=my_array.length-1; i > Index_position; i--){

my_array[i] = my_array[i-1];
}my_array[Index_position] = newValue;

System.out.println("New Array: "+Arrays.toString(my_array));

}

48) 如何获取数组元素的索引？

答：逻辑是：

  • 在每个步骤中，它会将输入的键值与数组中间元素的值进行检查。
  • 如果键匹配，则返回位置。在另一种情况下，如果键小于中间元素的键，
  • 然后它将重复 while 循环。如果搜索剩余数组并将其减少到零，它将返回 -1 表示未找到
public static int findIndex (int[] my_array, int t) {

int startPoint = 0;

int endPoint = my_array.length - 1;

while (startPoint <= endPoint) {

int mid = (startPoint + end) / 2;

if (key == my_array[mid]) {

return mid;

}

if (key < my_array[mid]) {

endPoint = mid - 1;
} else {

startPoint = mid + 1;

}

}

return -1;

}

Public static void main(String[] args) {

int[] arr = {2, 4, 6, 8, 10, 12, 14, 16};

System.out.println("Key 14's position: "findIndex(arr, 14));

int[] arr1 = {6,34,78,123,432,900};

System.out.println("Key 432's position: "+findIndex(arr1, 432));

}

49) 初始化后可以扩展数组吗？

答：逻辑是：我们可以在初始化数组后通过添加新数组来扩展它。请参阅以下示例。

Public static void main(String[] args) {

String [] names = new String[] { "A", "B", "C" };

String [] extended = new String[5];

extended [3] = "D";

extended [4] = "E";

System.arraycopy(names, 0, extended, 0, names.length);

//here we are extending with new array extended[3] and extended[4].

for (String str: extended){

System.out.println(str);

}

}

输出为 A,B,C,D,E。

50) 如何填充数组中的元素（立即初始化）？

回答：此示例使用 Java Util 类的 Array.fill(数组名称，值) 方法和 Array.fill(数组名称，起始索引，结束索引，值) 方法填充（一次性初始化数组的所有元素）数组。

import java.util.*;

public class FillTest {

public static void main(String args[]) {

int array[] = new int[6];

Arrays.fill(array, 100);

for (int i = 0, n = array.length; i < n; i++) {

System.out.println(array[i]);

}

System.out.println();

Arrays.fill(array, 3, 6, 50);

for (int i = 0, n = array.length; i< n; i++) {

System.out.println(array[i]);}}}

输出是

100,100,100,100,100,100

100,100,100,50,50,50
分享

你可能会喜欢：

2条评论

  1. 头像 什雷扬什 说：

    那么将数组作为参数传递给函数怎么样

    回复
  2. 头像 阿里马努·辛格 说：

    Q14 a[] 和 []a 之间的区别

    在第一个类型声明之后，您不能创建另一个（相同数据类型）数组。
    但您可以在第二种类型声明之后。
    int []a，b，c = new int[size]

    回复

发表评论

您的电邮地址不会被公开。 必填项 *