数组

数组是具有相同数据类型的一组数据的集合，在Java中数组同样可看做是一个对象。根据维度的不同，分为一维数组，二维数组，多维数组

一、一维数组的创建与使用

1. 创建一维数组

数组作为对象允许使用new关键字进行内存分配。使用数组之前，要首先定义数组变量所属的类型。创建数组有两种形式：

（1）先声明，在用new运算符进行内存分配

声明一维数组也有两种形式，分别为：

数组元素类型 数组名字[];

数组元素类型[] 数组名字[];

int arr[];
String[] arr;

通常使用第一种形式，声明数组后，还不能立即访问它的任何元素，还需要为数组分配内存。结构如下：

数组名字 = new 数组元素类型[数组元素的个数]

• 数组名字：被连接到数组变量的名称
• 数组元素个数：指定数组中变量的个数，即数组的长度 

arr = new int[5];

表示一个有五个元素的数组，数组名为arr。数组的索引是从0开始的。注意，分配内存后，整型数组是有初始值的为0.

（2）声明的同时为数组分配内存

数组元素类型 数组名 = new 数组元素类型[数组元素的个数];

int month[] = new int[12];

2. 初始化一维数组

数组的初始化有一下两种形式：

int arr[] = new int[]{1,2,3,4};     // 第一种初始化方式
int arr2[] = {3,4,5,6};             // 第二种初始化方式

数组的初始化就是包括在大括号之内用逗号分开的表达式列表。用逗号（，）分开。 

3. 使用一维数组

public class GetDay {
    public static void main(String[] args) {
        // 创建并初始化一维数组
        int day[] = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        for (int i = 0; i < 12; i++){
            System.out.println((i + 1) + "月有" + day[i] + "天");
        }
    }
}

1月有31天
2月有28天
3月有31天
4月有30天
5月有31天
6月有30天
7月有31天
8月有31天
9月有30天
10月有31天
11月有30天
12月有31天

二、二维数组的创建与使用

如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组，二维数组常用于表示表，表中的信息有行和列的形式。第一下标代表元素所在的行，第二个下标代表元素所在的列。

1. 二维数组的创建

二维数组的可以看做特殊的一维数组，声明方式也有两种。

（1）先声明，在用new运算符进行内存分配

数组元素类型 数组名字[][];

数组元素类型[][] 数组名字;

int myarr[][];

然后对数组进行分配内存，有两种不同的形式，一种是直接为每一维分配内存，一种分别为每一维分配内存

// 第一种
a = new int[2][4];

// 第二种
a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];

2. 二维数组初始化

二维数组的初始化和一维数组类似，都是使用大括号，不同的是大括号中的元素是多个大括号。

int myarr[][] = {{12,3},{45,4}};

3. 使用二维数组

public class Matrix {
    public static void main(String[] args) {
        int a[][] = new int[3][4];
        for (int i = 0; i < a.length; i++){
            for (int j = 0; j < a[i].length; j++){
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
}

0000
0000
0000

三、数组的基本操作

1. 遍历数组

数组的遍历就是获取数组中的每一个元素，通常使用for循环实现，我们使用for循环来遍历二维数组。

public class Trap {
    public static void main(String[] args) {
        int b[][] = new int[][]{{1},{2,3},{4,5,6}}; // 创建二维数组
        for (int k = 0; k < b.length; k++){
            for (int c = 0; c < b[k].length; c++){
                System.out.print(b[k][c]);
            }
            System.out.println();
        }
    }
}

在使用foreach语句遍历二维数组。

public class Taulog {
    public static void main(String[] args) {
        int arr2[][] = {{4, 3}, {1, 2}};
        System.out.println("数组中的元素是：");
        for (int x[] : arr2){
            for (int e : x){
                if(e == x.length) {
                    System.out.print(e);
                }else {
                    System.out.print(e + " 、");
                }
            }
        }
    }
}


数组中的元素是：
4 、3 、1 、2

2. 填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法可以通过重载的形式完成任意类型的数组元素的替换。

（1）fill(int[] a, int value)：将指定的int值分配给int型数组的每个元素

import java.util.Arrays;
public class Swap {
    public static void main(String[] args) {
        int arr[] = new int[5];
        Arrays.fill(arr, 8);
        for (int i = 0; i < arr.length; i++){
            System.out.println("第" + i + "个元素是：" + arr[i]);
        }
    }
}

第0个元素是：8
第1个元素是：8
第2个元素是：8
第3个元素是：8
第4个元素是：8

（2）fill(int[] a, int fromIndex, int toIndex, int value)：将指定的int值分配给int型数组指定范围中的每个元素，填充的范围从索引fromIndex(包括)一直到索引toIndex(不包括)。如果formIndex == toIndex,则填充范围为空。

import java.util.Arrays;
public class Displace {
    public static void main(String[] args) {
        int arr[] = new int[]{45, 12, 2, 10};
        Arrays.fill(arr, 1, 2, 8);
        for (int i = 0; i < arr.length; i++){
            System.out.println("第" + i + "个元素是：" + arr[i]);
        }
    }
}

第0个元素是：45
第1个元素是：8
第2个元素是：2
第3个元素是：10

3. 对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序，可对任意类型的数组进行升序排序。

import java.util.Arrays;

public class Taxis {
    public static void main(String[] args) {
        int arr[] = new int[]{23, 42, 12, 8};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

8
12
23
42

Java中的String类型数组的排序算法是根据字典编排顺序排序的，，因此数字排在字母前面，大写字母排在小写字母前面。 

4. 复制数组

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法时复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

（1）copyOf()方法：满足不同类型数组的复制

语法：copyOf(arr, int newlength)

• arr：要进行复制的数组

newlength：int 型常量，指复制后的新数组的长度，如果新数组的长度大于数组arr的长度，则用0填充。如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。

import java.util.Arrays;
public class Cope {
    public static void main(String[] args) {
        int arr[] = new int[]{23, 42, 12};
        int newarr[] = Arrays.copyOf(arr, 5);
        for (int i = 0; i < newarr.length; i++){
            System.out.println(newarr[i]);
        }
    }
}

23
42
12
0
0

（2）copyOfRange()方法

语法：copyOfRange(arr, int formIndex, int tolndex)

• arr：要进行复制的数组对象
• formIndex：指定开始复制数组的索引位置，新数组包括索引是formIndex的元素

toIndex：要复制范围的最后索引位置，新数组不包括索引是toIndex的元素

import java.util.Arrays;
public class Repeat {
    public static void main(String[] args) {
        int arr[] = new int[]{23, 42, 12, 84, 10};
        int newarr[] = Arrays.copyOfRange(arr, 0, 2);
        for (int i = 0; i < newarr.length; i++){
            System.out.println(newarr[i]);
        }
    }
}

23
42

5. 数组查询

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组。以获取指定对象。返回搜索元素的索引值。

（1）binarySearch(Object[] a, Object key)

• a：要搜索的数组
• key：要搜索的值

如果key包含在数组中，则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。

import java.util.Arrays;
public class Example {
    public static void main(String[] args) {
        int ia[] = new int[]{1, 8, 9, 4, 5};
        Arrays.sort(ia);
        int index = Arrays.binarySearch(ia, 4);
        System.out.println("4的索引位置是：" + index);
    }
}

4的索引位置是：1

（2）binarySearch(Object[], int fromIndex, int toIndex, Object key)

• a：要进行检索的数组
• fromIndex：指定范围的开始索引（包含）
• toIndex：指定范围的结束处索引（不包含）
• key：要搜索的元素 

import java.util.Arrays;
public class Rakel {
    public static void main(String[] args) {
        String str[] = new String[]{"ab", "cd", "er", "yz"};
        Arrays.sort(str);
        // 在指定的范围内搜索元素“cd”的索引位置
        int index = Arrays.binarySearch(str, 0, 2, "cd");
        System.out.println("cd的索引位置是：" + index);
    }
}

cd的索引位置是：1