Java数组

发表于 | 分类于 | 阅读次数：

声明与初始化数组

    java数组为引用类型，因此需要声明和初始化。 一个数组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据 一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。

type[] arrayName = new type[size]
若只指定数组的长度，那么系统将负责为这些数组元素分配初始值。指定初始值时，系统按如下规则分配初始值。

  • 数组元素的类型是基本类型中的整数类型（byte、short、int 和 long），则数组元素的值是 0。
  • 数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的值是 0.0。
  • 数组元素的类型是基本类型中的字符类型（char），则数组元素的值是‘\u0000’。
  • 数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的值是 false。
  • 数组元素的类型是引用类型（类、接口和数组），则数组元素的值是 null。

二维数组

    Java不直接支持二维数组，“二维数组”是特殊的一维数组，其在内存中存取结构如下图所示。
twoArray
    java不能按照一维数组扩展成二维数组一样扩展成三维或多维数组，因为Java是强类型语言，定义arr数组时已经确定了arr数组的数组元素为int[]型，则arr[0]的数组的数组元素只能是int类型，故不能将其扩展到三维或多维。 如果想在 Java 语言中实现这种可无限扩展的数组，则可以定义一个Object[] 类型的数组，这个数组的元素是Object类型，因此可以再次指向一个Object[]类型的数组，这样就可以从一维数组扩展到二维数组、三维数组……
二维数组是一维数组，其数组元素是一维数组。三维数组也是一维数组，其数组元素是二维数组…… 从这个角度来看，Java 语言里没有多维数组。

Arrays 工具类

    Arrays 类处于 java.util 包下，为了在程序中使用 Arrays 类，必须在程序中导入 java.util.Arrays 类。 Arrays 类里均为 static 修饰的方法（static 修饰的方法可以直接通过类名调用）
1）int binarySearch(type[] a, type target)
使用二分法查询target 在a数组中出现的索引，如果a数组不包含target ，则返回负值。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

2) int binarySearch(type[] a, int fromIndex, int toIndex, type target)
只从a数组中 fromIndex到 toIndex索引的元素中查找target。

3) type[] copyOf(type[] original, int length)
把 original 数组复制成一个新数组，其中length是新数组的长度。如果 length小于 original数组的长度，则新数组就是原数组的前面 length个元素，如果 length大于 original数组的长度，则新数组的前面元索就是原数组的所有元素，后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。

4) type[] copyOfRange(type[] original, int from, int to)
只复制 original数组的 from索引到 to索引的元素。

5) boolean equals(type[] a, type[] a2)
如果 a 数组和 a2数组的长度相等并且数组元素也一一相同，该方法将返回 true，否则返回false。

6) void fill(type[] a, type val)
把a 数组的所有元素都赋值为 val。

7) void fill(type[] a, int fromIndex, int toIndex, type val)
仅将 a数组的 fromIndex 到 toIndex索引的数组元素赋值为 val。

8) void sort(type[] a)
对 a数组的数组元素进行排序。 Java对Primitive（int，float等基本数据类型）数组采用 调优的快速排序，对Object对象数组采用改进的归并排序。
排序优化：实现中快排和归并都采用递归方式，而在递归的底层，也就是待排序的数组长度小于7时，直接使用冒泡排序，而不再递归下去。
分析：长度为6的数组冒泡排序总比较次数最多也就1+2+3+4+5+6=21次，最好情况下只有6次比较。而快排或归并涉及到递归调用等的开销，其时间效率在n较小时劣势就凸显了，因此这里采用了冒泡排序，这也是对快速排序极重要的优化。

9) void sort(type[] a, int fromIndex, int toIndex)
仅对 fromIndex到 toIndex 索引的元素进行排序。

10) String toString(type[] a)
将一个数组转换成一个字符串。按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。作用是用来很方便地输出数组，而不用一个一个地输出数组中的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static String toString(byte[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";
    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(a[i]);
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

11) List<T> asList(type[] a)
将数组转换为List

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.Arrays;

public class ArraysInstance {
    public static void main(String[] args) {
        int[] a = {1, 5, 8, 3, 5};
        int[] a2 = {1, 3, 5, 9, 10};
        System.out.println(Arrays.binarySearch(a2, 9)); // 3
        System.out.println(Arrays.binarySearch(a2, 0, 2, 9)); // -3
        int[] a3 = Arrays.copyOf(a, 3);
        System.out.println(Arrays.toString(a3)); //[1, 5, 8]
        int[] a4 = Arrays.copyOf(a, 7);
        System.out.println(Arrays.toString(a4)); //[1, 5, 8, 3, 5, 0, 0]
        int[] a5 = Arrays.copyOfRange(a, 2, 4);
        System.out.println(Arrays.toString(a5)); //[8, 3]
        System.out.println(Arrays.equals(a, a2)); //false
        int[] a6 = new int[5];
        Arrays.fill(a6, 2);
        System.out.println(Arrays.toString(a6)); //[2, 2, 2, 2, 2]
        Arrays.sort(a2);
        String str = Arrays.toString(a2);
        System.out.println(str); //[1, 3, 5, 9, 10]
        System.out.println(str.charAt(0)); //[
    }
}

字符数组转换为字符串

1
2
3
4
char[] b = {'a','b','c','d'};
System.out.println(Arrays.toString(b)); //[a, b, c, d]
String string = String.copyValueOf(b);
System.out.println(string); // abcd