Java入门教程七(数组)

数组是最常见的一种数据结构，它是相同类型的用一个标识符封装到一起的基本类型数据序列或者对象序列。数组使用一个统一的数组名和不同的下标来唯一确定数组中的元素。实质上，数组是一个简单的线性序列，因此访问速度很快

一维数组

一组相同类型数据的线性集合,一旦声明了数组的大小，就不能再修改。

创建

数据类型[] 数组名; 数据类型既可以是基本数据类型，也可以是引用数据类型

String[] name;
Person[] persons;

分配空间

分配空间就是要告诉计算机在内存中为它分配几个连续的位置来存储数据。在 Java 中可以使用 new 关键字来给数组分配空间

name =new String[10];
persons =new Person[30];

创建并分配空间

int arr=new int[5];

初始化一维数组

数组可以进行初始化操作，在初始化数组的同时，可以指定数组的大小，也可以分别初始化数组中的每一个元素

int[] number=new int[5];
number[0]=1;
number[1]=2;
number[2]=3;
number[3]=5;
number[4]=8;
//或
int[] number=new int[]{1, 2, 3, 4, 5};
//或
int[] number={1,2,3,5,8};

获取元素

指定元素所在数组的下标获取

int[] number={1,2,3,4,5};
System.out.println(number[0]);//输出1

遍历

利用 for 循环语句遍历 number 数组中的全部元素

int[] number={1,2,3,4,5};
for (int i=0;i<number.length;i++)
{
    System.out.println(number[i]);//依次输出1,2,3,4,5
}

二维数组

以第一个下标表示元素所在的行，第二个下标表示元素所在的列,二维数组被看作数组的数组

创建

type 表示二维数组的类型，array 表示数组名称，第一个中括号表示行，第二个中括号表示列

type[][] array;//例：int[][] age;

初始化

array=new type[][]{值 1,值 2,值 3,…,值 n};
array=new type[][]{new 构造方法(参数列),…};
type[][] array={{第1行第1列的值,第1行第2列的值,…},{第2行第1列的值,第2行第2列的值,…},…};

一个二行二列的二维数组 temp，并对数组中的元素进行了初始化

//方式一
int[][] temp;
temp =new int[][]
{
    {1,2},{3,4}
};
//方式二
int[][] temp;
temp=new int [][]
{
    {new int(1),new int(2)},{new int(3),new int(4)}
};
//方式三
int[][] temp={{1,2},{3,4}};

获取元素

使用下标来获取

array[i][j];
int[][] temp={{1,2},{3,4},{5,6}};
System.out.println(temp[1][1]);//输出1

遍历

在一维数组中直接使用数组的 length 属性获取数组元素的个数。而在二维数组中，直接使用 length 属性获取的是数组的行数，在指定的索引后加上 length（如 array[0].length）表示的是该行拥有多少个元素，使用嵌套循环来遍历二维数组

public static void main(String[] args)
{
    double[][] temp={{1,2},{3,4},{5,6}};
    for(int i=0;i<temp.length;i++)
    {
        for(int j=0;j<temp[i].length;j++)
        {
            System.out.println("temp["+i+"]["+j+"]");
        }
    }
}

多维数组

除了一维数组和二维数组外，Java 中还支持更多维的数组，如三维数组、四维数组和五维数组等，它们都属于多维数组

以三维数组为例来介绍多维数组，三维数组有三个层次，可以将三维数组理解为一个一维数组，其内容的每个元素都是二维数组。依此类推，可以获取任意维数的数组。

多维数组的声明、初始化和使用都与二维数组相似。

array[i][j][r];
int[][][] temp={{1,2,1},{3,4,3},{5,6,5}};
System.out.println(temp[1][1][1]);//输出1

其他与二维数组基本相似

数组比较

数组相等的条件不仅要求数组元素的个数必须相等，而且要求对应位置的元素也相等。Arrays 类提供了 equals() 方法比较整个数组，arrayA 是用于比较的第一个数组，arrayB 是用于比较的第二个数组

Arrays.equals(arrayA, arrayB);
int[] arr1={1,2,3};
int[] arr2={1,2,3};
int[] arr3={1,2,3,4};
Arrays.equals(arr1, arr2);//ture
Arrays.equals(arr1, arr3);//false

数组查找

查找数组是指从数组中查询指定位置的元素，或者查询某元素在指定数组中的位置。使用 Arrays 类的 binarySearch() 方法可以实现数组的查找，该方法可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值，binarySearch() 方法有多种重载形式来满足不同类型数组的查找需要，常用的重载形式有两种。

在进行数组查询之前，必须对数组进行排序（可以使用 sort() 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法确认找到的是哪一个

binarySearch(Object[] a,Object key);

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

int[] arr={1,2,3};
Arrays.binarySearch(arr,1);//查到，位置0
Arrays.binarySearch(arr,4);//查不到，返回-1

binarySearch(Object[] a,int fromIndex,int toIndex,Object key);

a 表示要进行查找的数组，fromIndex 指定范围的开始处索引（包含开始处），toIndex 指定范围的结束处索引（不包含结束处），key 表示要搜索的元素

int[] arr={1,2,3};
Arrays.binarySearch(arr,0,2,1);//查到，位置0
Arrays.binarySearch(arr,0,1,3);//查不到，返回-1

数组复制

实现数组复制有 4 种方法，分别为使用 Arrays 类的 copyOf() 方法和 copyOfRange() 方法、System 类的 arraycopy() 方法和 Object 类的 clone() 方法

copyOf()、copyOfRange()

copyOf() 方法是复制数组至指定长度

Arrays.copyOf(dataType[] srcArray,int length);

srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度，使用这种方法复制数组时，默认从源数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。如果 length 大于 srcArray.length，则目标数组中采用默认值填充（如：int类型数组默认值为0）；如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。

int arr[]=new int[]{1,2,3};
int[] newArr=(int[])Arrays.copyOf(arr,4);//新数组1,2,3,0

copyOfRange() 方法则将指定数组的指定长度复制到一个新数组中

Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)

srcArray 表示源数组；startIndex 表示开始复制的起始索引，目标数组中将包含起始索引对应的元素，另外，startIndex 必须在 0 到 srcArray.length 之间；endIndex 表示终止索引，目标数组中将不包含终止索引对应的元素，endIndex 必须大于等于 startIndex，可以大于 srcArray.length，如果大于 srcArray.length，则目标数组中使用默认值填充

int arr[]=new int[]{1,2,3};
int[] newArr=(int[])Arrays.copyOf(arr,1，4);//新数组2,3,0

arraycopy()

arraycopy() 方法位于 java.lang.System 类中

System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)

srcArray 表示源数组；srcIndex 表示源数组中的起始索引；destArray 表示目标数组；destIndex 表示目标数组中的起始索引；length 表示要复制的数组长度，length+srcIndex 必须小于等于 srcArray.length，同时 length+destIndex 必须小于等于 destArray.length

int arr[]=new int[]{1,2,3};
int newArr[]==new int[]{4,5,6};
System.arraycopy(arr,0, newArr,2,3);//新数组4,2,6

clone()

clone() 方法也可以实现复制数组。该方法是类 Object 中的方法，可以创建一个有单独内存空间的对象。因为数组也是一个 Object 类，因此也可以使用数组对象的 clone() 方法来复制数组

array_name.clone()
int[] targetArray=(int[])sourceArray.clone();

数组排序

java.util.Arrays 类中的 sort() 方法对数组进行排序分为以下两步：导入 java.util.Arrays 包。使用 Armys.sort(数组名) 语法对数组进行排序，排序规则是从小到大，即升序。

int[] arr=new int[]{1,5,4,3,6,2};
Arrays.sort(scores);//输出 1,2,3,4,5,6

冒泡排序

冒泡排序（Bubble Sort）是常用的数组排序算法之一，冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

int[] arr={6,3,8,2,9,1};
for(int i=0;i<arr.length-1;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;
　　　　　　　　}
　　　　　　}
　　　　}

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进，快速排序的基本思想是：通过一趟排序，将要排序的数据分隔成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。

int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
public static void quickSort(int[] arr,int low,int high){
    int i,j,temp,t;
    if(low>high){
        return;
    }
    i=low;
    j=high;
    temp = arr[low];//temp就是基准位
    while (i<j) {//先看右边，依次往左递减
        while (temp<=arr[j]&&i<j) {
            j--;
        }
        while (temp>=arr[i]&&i<j) {//再看左边，依次往右递增
                i++;
        }
        if (i<j) {//如果满足条件则交换
            t = arr[j];
            arr[j] = arr[i];
            arr[i] = t;
         }
    }
    //最后将基准为与i和j相等位置的数字交换
    arr[low] = arr[i];
    arr[i] = temp;
    //递归调用左半数组
    quickSort(arr, low, j-1);
    //递归调用右半数组
    quickSort(arr, j+1, high);
}
quickSort(arr, 0, arr.length-1);

选择排序

选择排序法也可以对上述数组中的元素进行排序，但是它与冒泡排序不同。选择排序是指每一趟从待排序的数据元素中选出最大（或最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完

int[] number={13,15,24,99,4,1};
int index;
for(int i=1;i<number.length;i++)
{
    index=0;
    for(int j=1;j<=number.length-i;j++)
    {
        if(number[j]>number[index])
        {
            index=j;    //查找最大值
        }
    }
    int temp=number[number.length-i];
    number[number.length-1]=number[index];
    number[index]=temp;
}