数组

数组是一种数据结构，用以存储同类型数据的集合，以序号区分并指定每个数据。

数组的定义：

数组是相同类型数据的有序集合
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们（注意：数组的下标是从0开始的，所以第10个数的话，下标就是 9，a(0)=1）

基本特点：

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

1.声明创建

数组必须声明才能在程序中使用

//datatype[] arrayname;  首选的声明方法
//datatype arrayname[];  效果相同，但不是首选方法
int arr[];
double[] arr2;
//建议使用首选的格式，为了方便 c/c++ 程序员能够快速理解java语言

使用 new 操作符来创建数组

//datatype[] arrayname = new datatype[arraysize];
int[] myIntList = new int[10];
double[] myDouList = new double[6];

通过arrayname.length获取数组长度。数组的元素是通过索引访问的，索引从 0 开始，到 arrayRefVar.length-1结束

int[] myIntList = null;
myIntList = new int[5];
myIntList[0] = 1;
myIntList[1] = 2;
myIntList[2] = 3;
myIntList[3] = 4;
myIntList[4] = 5;
double total = 0;
//arrayName.length 代表数组的长度，长度从 1 开始
for(int i = 0;i < myIntList.length; i++){
    total = myIntlist[i] + total;
}
System.out.println(total);

1.1JVM内存机制

根据 JVM 规范，JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分，用于存放不同的数据

堆，保存对象实例，所有对象实例（包括数组）都要在堆上分配，通过new创建的对象和数组；堆里的数据可以被所有线程共享，不会存放别的对象引用，生命周期与虚拟机相同，可以不使用连续的内存地址
栈，保存“栈帧”的东西，每个方法会创建一个栈帧，栈帧中存放了局部变量表、操作数栈、动态链接、方法出口等信息，如数组的内存地址(指针)；每个线程有一个私有的栈，生命周期与线程相同
方法区，用于存储虚拟机加载的类信息（类的版本、字段、方法、接口），常量，静态变量，即时编译器编译后的代码等数据；方法区也是线程共享区

1.2初始化

静态初始化，可以直接在定义数组的同时就为数组元素分配空间并赋值
```
int[] a = {1, 2, 12};
double b = {1.2, 2.1, 3.2};
```
动态初始化，数组定义、为数组元素分配空间、赋值的操作分开进行。
```
int[] a;
a = new int[2];
a[0] = 1;
a[1] = 2;
```

数组的默认初始化，元素相当于类的实例变量，每个元素也被按照实例变量同样的方式被隐式初始化

int[] a = new int[2];
boolean[] b = new boolean[2];
String[] s = new String[2];
System.out.println(a[0]+";"+a[1]);//0;0
System.out.println(b[0]+";"+b[1]);//false;false
System.out.println(s[0]+";"+s[1]);//null;null

1.3数组边界

下标的合法区间：[0, length-1]，如果越界就会报错；

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: x

数组下标越界异常！

2.数组使用

数组的元素类型和数组的大小都是确定的，当处理数组元素时，可以使用循环

double[] myArr = { 5.5, 2.3, 9.4, 1.0, 1.9};
for(int i=0; i<mtArr.length; i++){
    System.out.print(myArr[i]+" ");
}
System.out.println();
double max = myArr[0];
for(int i=0; i<myArr.length; i++){
    if(myArr[i] > max){
        max = myArr[i];
    }
}
System.out.println(max);

2.1For-Each循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组

/*
for(type element: array){
    System.out.println(element);
}
*/
double[] myArr = { 5.5, 2.3, 9.4, 1.0, 1.9};
for(double a : myArr){
    System.out.print(a+" ");
}

2.2数组作方法的参数与返回值

数组可以作为参数传递给方法，是传递数组的内存地址

数组可以作为返回值传递给方法，也是传递数组的内存地址

public static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
}

public static int[] reverse(int[] list){
    int[] result = new int[list.length];
    //倒序数组
    for(int i=0,int j=list.length-1;i<length;i++,j--){
        result[j] = list[i];
    }
}

多维数组

数组的数组，一个特殊的一维数组，其每一个元素都是一个一维数组

//二维数组 type[][] typeName = new type[length1][length2]
int[][] myList = new type[2][2]{{1,2}, {5,4}};

type 可以为基本数据类型和复合数据类型，alenght1 和 lenght2 必须为正整数， arraylenght1 为行数，arraylenght2 为列数。

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

int[][] myList = new type[2][2]{{1,2}, {5,4}};
myList[0][1] = 8;//{{1,8}, {5,4}}
myList[1][0] = 6;//{{1,8}, {6,4}}

原来的数组就是一条线，我们知道一个位置就好

二维就是一个面，两点确定一个位置

三维呢，就需要三个点来确定，以此类推

myList.length获取的二维数组第一维数组的长度，myList[0].length才是获取第二维第一个数组长度

Arrays 类

java.util.Arrays是数组的工具类

由于数组对象本身并没有什么方法可以供我们调用,但 API 中提供了一个工具类 Arrays 供我们使用,从而可以对数据对象进行一些基本的操作，使用之前需要导包

Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用（也可以用对象来调用，但没必要）

具有以下常用功能：

给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

方法	说明
`public static int binarySearch(Object[] a, Object key)`	用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)
`public static boolean equals(long[] a, long[] a2)`	如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
`public static void fill(int[] a, int val)`	将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
`public static void sort(Object[] a)`	对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
`public static String toString(Object[] a)`	返回指定数组内容的字符串表示形式。如果数组包含作为元素的其他数组，则通过从 Object 中继承的 Object.toString() 方法将它们转换为字符串，这描述了它们的标识，而不是它们的内容。此方法返回的值等于 Arrays.asList(a).toString() 返回的值，除非 a 为 null，在这种情况下返回 "null"。

int[] a = {1,2,323,23,543,12,59};
//Arrays.toString
System.out.println(Arrays.toString(a));//1,2,323,23,543,12,59
//Arrays.sort
Arrays.sort(a);
System.out.println(Arrays.toString(a));//1,2,12,23,59,323,543
//Arrays.fill
Arrays.fill(a,2,4,100);//将2到4(不包含4)索引的元素替换为100
System.out.println(Arrays.toString(a));//1,2,100,100,59,323,543
//Arrays.asList
List<int[]> list = Arrays.asList(a);

二分法查找

在数组中查找指定元素并返回其下标

注意：使用二分搜索法来搜索指定的数组，以获得指定的值。必须在进行此调用之前对数组进行排序(通过sort方法等)。如果没有对数组进行排序，则结果是不确定的。

如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

算法的原理

对有序数组取中间数
把中间数与要查找的数作比较
如果比较结果是中间数较大，则在较小的一侧再取中间数，否则反之
重复第二、三步，直到找到数组与之对应的数，返回索引

int[] a = {1,2,323,23,543,12,59};
Arrays.sort(a);//必须对数组进行排序，才能用二分查找
System.out.println(Arrays.binarySearch(a, 12));//返回索引：2

注：用二分查找法前，数组必须是有序的。

冒泡排序

一种计算机科学领域的较简单的排序算法

重复地走访过要排序的元素列，依次比较两个相邻的元素。如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成

冒泡排序算法的原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数
针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

int[] arr = {21,54,12,5,55,34,81};
int temp = 0;
//提取每个元素
for(int i = 0; i<arr.length-1; i++){
    //如果数组是有序的，减少无谓的比较，退出循环
    boolean flag = true;
    //arr.length-i-1 排除掉已经作比较的数
    //让每个元素与未比较过的元素作比较
    for(int j=0; j<arr.length-i-1;j++){
        if(arr[j+1]<arr[j]){
            temp = arr[j+1];
            arr[j+1] = arr[j];
            arr[j] = temp;
            flag = false;
        }
    }
    if(flag)
        break;
}