Java 里的数组

​数组是一个固定长度的，包含了相同类型数据的无序排列的容器。

​在 Java 中，数组属于引用数据类型。访问时直接由下标访问。数组只有一个唯一的属性，length。length 可以用来获取数组中能存储的元素个数。用法为： 数组名.length。(注: length 的计数从1开始，数组下标的计数从0开始，所以索引值从 0 到 arrayRefVar.length - 1)

​在存储空间的分配上，数组名和数组的首地址被存放在内存的栈空间，而数组的内容被分配在堆空间。数组操作中，只开辟了栈内的空间，数组是无法使用的，必须有指向堆内存才可以使用，开辟堆内存空间需要使用new关键字，之后就是将对内存的使用权交给对应的栈内存，一个堆内存空间可以被多个栈内存指向。二维数组元素空间的分配有时会分配为一个大空间，有时会分配为多个小空间，视内存空间而定。二维数组根据定义方式的不同，就有可能变为并不规则的数组，行数乘列数就不一定等于数组长度。

声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

1
2
dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法

初始化数组

​Java 数组对象自动初始化为 null，范围检查保证了数组无法越界访问。数组元素中的基本数据类型值会自动初始化成空值(对于数字和字符，就是0;对于布尔型，是 false )。如果创建的是一个引用数组，需要先创建新的对象，并把对象赋值给引用，初始化才算结束。如果忘记了创建对象，并且试图使用数组中的空引用，就会在运行时产生异常。

使用 new 操作符来创建数组：

1
arrayRefVar = new dataType[arraySize];

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

1
2
3
dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};
dataType[] arrayRefVar = new dataType[]{value0, value1, ..., valuek};

静态初始化和动态初始化

​静态初始化和动态初始化开始都指定了数组大小，java也在栈空间分配了相应的大小，只是静态初始化开始就指定了值，而动态初始化是在后面指定数组的值，刚开始数组的值都是默认值。

​数组静态初始化，初始化为给定值：

1
int[] a={1,2,3,4};

​数组动态初始化，初始化为空值：

1
2
int[] intArray;//声明数组
intArray = new int[5];//为数组分配空间

处理数组

​数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 foreach 循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TestArray {
	public static void main(String[] args) {
        double[] myList = {1.9, 2.9, 3.4, 3.5};
        
        // 普通for语法打印所有数组元素
        for (int i = 0; i < myList.length; i++) {
        	System.out.println(myList[i]);
     	}
        
    	// foreach语法打印所有数组元素
    	for (double element: myList) {
        	System.out.println(element);
     	}
  	}	
}

foreach

​JDK 1.5 引进了一种新的循环类型，被称为 foreach 循环或者加强型循环，它能在不使用下标的情况下遍历数组。语法：

1
2
for(Type ATypeName : TheSameTypeArray) {
	statement; }

多维数组

​多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

1
String str[][] = new String[3][4];

​对二维数组中的每个元素，引用方式为 arrayName[index1][index2]。

复制数组

​System 提供了一个静态方法 arraycopy()，我们可以使用它来实现数组之间的复制。用法：

1
System.arraycopy(src, srcPos, dest, destPos, length)
  • src: 源数组
  • srcPos: 从源数组复制数据的起始位置
  • dest: 目标数组
  • destPos: 复制到目标数组的起始位置
  • length: 复制的长度

Arrays类

​java.util.Arrays 类能方便地操作数组，可以进行排序，查找，复制填充等功能，它提供的所有方法都是静态的。常用方法如下：

copyOfRange

  • 功能：数组复制
  • 说明：与 arraycopy() 类似的， Arrays提供了一个copyOfRange方法进行数组复制。不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。

  • 实例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import java.util.Arrays;
     
    public class HelloWorld {
        public static void main(String[] args) {
            int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
     
            // copyOfRange(int[] original, int from, int to)
            // 第一个参数表示源数组
            // 第二个参数表示开始位置(取得到)
            // 第三个参数表示结束位置(取不到)
            int[] b = Arrays.copyOfRange(a, 0, 3);
     
            for (int i = 0; i < b.length; i++) {
                System.out.print(b[i] + " ");
            }
        }
    }
    /*Output:
    18 62 68
    */

fill

  • 功能：使用同一个值，填充整个数组
  • 说明：将指定的值分配给指定类型数组指定范围中的每个元素。适用于所有的基本数据类型。

  • 实例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import java.util.Arrays;
      
    public class HelloWorld {
        public static void main(String[] args) {
            int a[] = new int[10];
      
            Arrays.fill(a, 5);
      
            System.out.println(Arrays.toString(a));
      
        }
    }
    /*Output：
    [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
    */

sort

  • 功能：对数组排序
  • 说明：将指定的值分配给指定类型数组指定范围中的每个元素。适用于所有的基本数据类型。

  • 实例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    import java.util.Arrays;
      
    public class HelloWorld {
        public static void main(String[] args) {
            int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
            System.out.println("排序之前 :");
            System.out.println(Arrays.toString(a));
            Arrays.sort(a);
            System.out.println("排序之后:");
            System.out.println(Arrays.toString(a));
      
        }
    }
    /*Output：
    排序之前：
    [18, 62, 68, 82, 65, 9]
    排序之后：
    [9, 18, 62, 65, 68, 82]
    */

toString()

  • 功能：转换为字符串
  • 说明：直接把一个数组转换为字符串，这样方便观察数组的内容。

  • 实例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    import java.util.Arrays;
      
    public class HelloWorld {
        public static void main(String[] args) {
            int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
            String content = Arrays.toString(a);
            System.out.println(content);
      
        }
    }
    /*Output:
    [18, 62, 68, 82, 65, 9]
    */

binarySearch

  • 功能：查找数组元素
  • 说明：用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。需要注意的是，使用 binarySearch 进行查找之前，必须使用 sort 进行排序。如果数组中有多个相同的元素，查找结果是不确定的。如果查找值包含在数组中，则返回搜索键的索引；否则返回-1或(-插入点)。插入点是索引键将要插入数组的那一点，即第一个大于该键的元素的索引。

  • 实例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import java.util.Arrays;
     
    public class HelloWorld {
        public static void main(String[] args) {
            int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
     
            Arrays.sort(a);
     
            System.out.println(Arrays.toString(a));
            //使用binarySearch之前，必须先使用sort进行排序
            System.out.println("数字 62出现的位置:"+Arrays.binarySearch(a, 62));
        }
    }
    /*Output:
    [9, 18, 62, 65, 68, 82]
    数字 62出现的位置:2
    */

equals

  • 功能：比较数组
  • 说明：如果两个指定的数组彼此相等，则返回 true。如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。适用于所有的基本数据类型。
  • 实例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import java.util.Arrays;
     
    public class HelloWorld {
        public static void main(String[] args) {
            int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
            int b[] = new int[] { 18, 62, 68, 82, 65, 8 };
     
            System.out.println(Arrays.equals(a, b));
        }
    }

一些常见数组实例

以下内容搬运自菜鸟教程

数组排序及元素查找

以下实例演示了如何使用sort()方法对Java数组进行排序，及如何使用 binarySearch() 方法来查找数组中的元素, 这边我们定义了 printArray() 方法来打印数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Arrays;
 
public class MainClass {
    public static void main(String args[]) throws Exception {
        int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
        Arrays.sort(array);
        printArray("数组排序结果为", array);
        int index = Arrays.binarySearch(array, 2);
        System.out.println("元素 2  在第 " + index + " 个位置");
    }
    private static void printArray(String message, int array[]) {
        System.out.println(message
        + ": [length: " + array.length + "]");
        for (int i = 0; i < array.length; i++) {
            if(i != 0){
                System.out.print(", ");
            }
            System.out.print(array[i]);
        }
        System.out.println();
    }
}
/*Output:
数组排序结果为: [length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8
元素 2 在第 5 个位置
*/

数组添加元素

以下实例演示了如何使用sort()方法对Java数组进行排序，及如何使用 insertElement () 方法向数组插入元素, 这边我们定义了 printArray() 方法来打印数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.util.Arrays;
 
public class MainClass {
   public static void main(String args[]) throws Exception {
      int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
      Arrays.sort(array);
      printArray("数组排序", array);
      int index = Arrays.binarySearch(array, 1);
      System.out.println("元素 1 所在位置（负数为不存在）："
      + index);  
      int newIndex = -index - 1;
      array = insertElement(array, 1, newIndex);
      printArray("数组添加元素 1", array);
   }
   private static void printArray(String message, int array[]) {
      System.out.println(message
      + ": [length: " + array.length + "]");
      for (int i = 0; i < array.length; i++) {
         if (i != 0){
            System.out.print(", ");
         }
         System.out.print(array[i]);         
      }
      System.out.println();
   }
   private static int[] insertElement(int original[],
   int element, int index) {
      int length = original.length;
      int destination[] = new int[length + 1];
      System.arraycopy(original, 0, destination, 0, index);
      destination[index] = element;
      System.arraycopy(original, index, destination, index
      + 1, length - index);
      return destination;
   }
}
/*Output:
数组排序: [length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8 
元素 1 所在位置（负数为不存在）：-6 
数组添加元素 1: [length: 11] -9, -7, -3, -2, 0, 1, 2, 4, 5, 6, 8
*/

获取数组长度

使用数组的属性 length 来获取数组的长度，以下实例中我们定义了二维数组，并获取数组的长度：

1
2
3
4
5
6
7
8
9
10
11
public class Main {
   public static void main(String args[]) {
      String[][] data = new String[2][5];
      System.out.println("第一维数组长度: " + data.length);
      System.out.println("第二维数组长度: " + data[0].length);
   }
}
/*Output:
第一维数组长度: 2 
第二维数组长度: 5
*/

数组反转

以下实例中我们使用 Collections.reverse ( ArrayList ) 将数组进行反转：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.ArrayList;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("C");
        arrayList.add("D");
        arrayList.add("E");
        System.out.println("反转前排序: " + arrayList);
        Collections.reverse(arrayList);
        System.out.println("反转后排序: " + arrayList);
    }
}
/*Output:
反转前排序: [A, B, C, D, E] 
反转后排序: [E, D, C, B, A] 
*/

数组输出

以下实例演示了如何通过循环输出数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.lang.*;
public class Main{ 
    public static void main(String args[]) {       
        String[] runoobs = new String[3];      
        runoobs[0] = "菜鸟教程";      
        runoobs[1] = "菜鸟工具";     
        runoobs[2] = "菜鸟笔记";      
        for (String obj:runoobs){        
            System.out.println(obj+"\n");      
        }   
    }
}
/*Output:
菜鸟教程
菜鸟工具
菜鸟笔记
*/

数组获取最大和最小值

以下实例演示了如何通过 Collections 类的 Collections.max() 和 Collections.min() 方法来查找数组中的最大和最小值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Arrays;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
        int min = (int) Collections.min(Arrays.asList(numbers));
        int max = (int) Collections.max(Arrays.asList(numbers));
        System.out.println("最小值: " + min);
        System.out.println("最大值: " + max);
    }
}
/*Output:
最小值: 1
最大值: 9
*/

数组合并

以下实例演示了如何通过 List 类的 Arrays.toString () 方法和 List 类的 list.Addall(array1.asList(array2) 方法将两个数组合并为一个数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
public class Main {
    public static void main(String args[]) {
        String a[] = { "A", "E", "I" };
        String b[] = { "O", "U" };
        List list = new ArrayList(Arrays.asList(a));
        list.addAll(Arrays.asList(b));
        Object[] c = list.toArray();
        System.out.println(Arrays.toString(c));
    }
}
/*Output:
[A, E, I, O, U]
*/

数组填充

以下实例我们通过 Java Util 类的 Arrays.fill(arrayname,value) 方法和Arrays.fill(arrayname ,starting index ,ending index ,value) 方法向数组中填充元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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]);
        }
    }
}
/*Output:
100
100
100
100
100
100

100
100
100
50
50
50
*/

数组扩容

以下实例演示了如何在数组初始化后对数组进行扩容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
    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);
        for (String str : extended){
            System.out.println(str);
        }
    }
}
/*Output:
A
B
C
D
E
*/

查找数组中的重复元素

以下实例演示了如何在 java 中找到重复的元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Arrays;
 
public class MainClass {
    public static void main(String[] args) 
    {
        int[] my_array = {1, 2, 5, 5, 6, 6, 7, 2};
 		for (int i = 0; i < my_array.length-1; i++)
        {
            for (int j = i+1; j < my_array.length; j++)
            {
                if ((my_array[i] == my_array[j]) && (i != j))
                {
                    System.out.println("重复元素 : "+my_array[j]);
                }
             }
        }
    }
}
/*Output:
重复元素 : 2
重复元素 : 5
重复元素 : 6
*/

删除数组元素

以下实例演示了如何使用 remove () 方法来删除数组元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args)  {
        ArrayList<String> objArray = new ArrayList<String>();
        objArray.clear();
        objArray.add(0,"第 0 个元素");
        objArray.add(1,"第 1 个元素");
        objArray.add(2,"第 2 个元素");
        System.out.println("数组删除元素前："+objArray);
        objArray.remove(1);
        objArray.remove("第 0 个元素");
        System.out.println("数组删除元素后："+objArray);
    }
}
/*Output:
数组删除元素前：[第 0 个元素, 第 1 个元素, 第 2 个元素]
数组删除元素后：[第 2 个元素]
*/

数组差集

以下实例演示了如何使用 removeAll () 方法来计算两个数组的差集：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args)  {
        ArrayList objArray = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        objArray.add(2,"notcommon2");
        System.out.println("array1 的元素" +objArray);
        System.out.println("array2 的元素" +objArray2);
        objArray.removeAll(objArray2);
        System.out.println("array1 与 array2 数组差集为："+objArray);
    }
}
/*Output:
array1 的元素[common1, common2, notcommon2]
array2 的元素[common1, common2, notcommon, notcommon1]
array1 与 array2 数组差集为：[notcommon2]
*/

数组交集

以下实例演示了如何使用 retainAll () 方法来计算两个数组的交集：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*Output:
array1 的元素[common1, common2, notcommon2]
array2 的元素[common1, common2, notcommon, notcommon1]
array1 与 array2 数组差集为：[notcommon2]
*/import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args)  {
        ArrayList objArray = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        objArray.add(2,"notcommon2");
        System.out.println("array1 数组元素："+objArray);
        System.out.println("array2 数组元素："+objArray2);
        objArray.retainAll(objArray2);
        System.out.println("array2 & array1 数组交集为："+objArray);
    }
}
/*Output:
array1 数组元素：[common1, common2, notcommon2]
array2 数组元素：[common1, common2, notcommon, notcommon1]
array2 & array1 数组交集为：[common1, common2]
*/

在数组中查找指定元素

以下实例演示了如何使用 contains () 方法来查找数组中的指定元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args)  {
        ArrayList<String> objArray = new ArrayList<String>();
        ArrayList<String> objArray2 = new ArrayList<String>();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        System.out.println("objArray 的数组元素："+objArray);
        System.out.println("objArray2 的数组元素："+objArray2);
        System.out.println("objArray 是否包含字符串common2? ： "
        +objArray.contains("common2"));
        System.out.println("objArray2 是否包含数组 objArray? ："
        +objArray2.contains(objArray) );
    }
}
/*Output:
objArray 的数组元素：[common1, common2]
objArray2 的数组元素：[common1, common2, notcommon, notcommon1]
objArray 是否包含字符串common2? ： true
objArray2 是否包含数组 objArray? ：false
*/

判断数组是否相等

以下实例演示了如何使用 equals ()方法来判断数组是否相等：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Arrays;
 
public class Main {
    public static void main(String[] args) throws Exception {
        int[] ary = {1,2,3,4,5,6};
        int[] ary1 = {1,2,3,4,5,6};
        int[] ary2 = {1,2,3,4};
        System.out.println("数组 ary 是否与数组 ary1相等? ："
        +Arrays.equals(ary, ary1));
        System.out.println("数组 ary 是否与数组 ary2相等? ："
        +Arrays.equals(ary, ary2));
    }
}
/*Output:
数组 ary 是否与数组 ary1相等? ：true
数组 ary 是否与数组 ary2相等? ：false
*/

数组并集

以下实例演示了如何使用 union ()方法来计算两个数组的并集：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) throws Exception {
        String[] arr1 = { "1", "2", "3" };
        String[] arr2 = { "4", "5", "6" };
        String[] result_union = union(arr1, arr2);
        System.out.println("并集的结果如下：");
        for (String str : result_union) {
            System.out.println(str);
        }
    }
    // 求两个字符串数组的并集，利用set的元素唯一性
    public static String[] union(String[] arr1, String[] arr2) {
        Set<String> set = new HashSet<String>();
 		for (String str : arr1) {
            set.add(str);
        }
        for (String str : arr2) {
            set.add(str);
        }
        String[] result = {  };
        return set.toArray(result);
    }
}
/*Output:
并集的结果如下：
3
2
1
6
5
4
*/