数组

概述

数组(Array)， 是多个相同类型数据按一定顺序排列的集合， 并使用一个名字命名， 并通过编号的方式对这些数据进行统一管理。
数组本身是引用数据类型， 而数组中的元素可以是任何数据类型， 包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间， 而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定， 就不能修改。

一维数组的使用

声明

type var[], type[] var
Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

初始化

默认初始化值：

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
对于基本数据类型而言，默认初始化值各有不同
对于引用数据类型而言，默认初始化值为null(注意与0不同！ )

动态初始化：

数组元素分配空间与赋值的操作分开进行

int arr[] = new int[3];    //声明并分配空间
arr[0] = 1;                //动态初始化
arr[1] = 2;
arr[2] = 3;
String names[];            //声明
names = new String[2];    //动态初始化
names[0] = "钱学森";
names[1] = "邓稼先";

静态初始化

数组的初始化和数组元素的赋值操作同时进行。

int arr[] = {1, 2, 3};
int arr[];
arr = new int[]{1,2,3};
String names[] = {"钱学森", "邓稼先"};

数组元素的使用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
引用方式 数组名[index] index可以是整型常量或者整型表达式
每个数组都有一个属性length指明它的长度，例如： a.length 指明数组a的长度(元素个数)
数组一旦初始化，其长度是不可变的

多维数组的使用

从数组底层的运行机制来看，其实没有多维数组。
多维数组实际上是一维数组的每个元素又是一个数组而已。

声明

type[][] var 或 type var[][]

初始化

动态初始化

两种方式

1. 标准形状 ```java int[][] arr; //声明 arr = new int[3][2]; //分配空间（标准） arr[0][0] = 78; //初始化

2. 不规则形状
```java
int arr[][];    //声明
arr = new int[3][];        //分配空间（只说了一维空间长度，高维还未定义）
arr[0] = new int[3];
arr[1] = new int[2];
arr[2] = new int[4];    //分配高维空间
arr[0][0] = 78;            //初始化

先分配低维才能分配高维

静态初始化

int arr[][] = {{1,2,3}, {4,5}, {6,7,8,9}};    //声明并分配存储空间并初始化
int arr1[][];    //声明
arr1 = new int[3][];    //分配一维存储空间
arr1[0] = new int[]{1,2,3};    //分配二维空间并初始化
arr1[1] = new int[]{4,5};
arr1[2] = new int[]{6,7,8,9};

注意特殊写法情况： int[] x,y[]; x是一维数组， y是二维数组。 Java中多维数组不必都是规则矩阵形式

数组中常见算法

1. 数组元素的赋值(杨辉三角、回形数等)
   2. 求数值型数组中元素的最大值、最小值、平均数、总和等
   3. 数组的复制（vs赋值）、反转、查找(线性查找、二分法查找)

   //反转
   public class PracticeTest4 {
    public static void main(String[] args) {
        String array[] = {"AA", "BB", "cc", "DD", "EE", "FF"};
        for(int i = 0; i < array.length/2; i++)
        {
            String temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length-1-i] = temp;
        }
        for(int i=0;i<array.length;i++)
            System.out.print(array[i] + ' ');
        System.out.println();
    }
   }
   //另一种写法
   public class PracticeTest4 {
    public static void main(String[] args) {
        String array[] = {"AA", "BB", "cc", "DD", "EE", "FF"};
        for(int i = 0, j=array.length-1; i < j; i++,j--)
        {
            String temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
        for(int i=0;i<array.length;i++)
            System.out.print(array[i] + ' ');
        System.out.println();
    }
   }

   //二分查找
   public class PracticeTest5 {
    public static void main(String[] args) {
        int arr[] = { -15, -7, 0, 23, 45, 67, 100 };
        int dest = 0;
        int begin = 0;
        int end = arr.length-1;
        int mid;
        boolean flag = true;
        while(begin<=end)
        {
            mid = (end + begin) / 2;
            if(arr[mid] == dest)
            {
                System.out.printf("找到值为%d的元素, 位置为%d\n", dest, mid);
                flag = false;
                break;
            }
            else if(dest < arr[mid])
            {
                end = mid - 1;
            }
            else
                begin = mid + 1;
        }
        if(flag)
            System.out.println("很遗憾没有找到！");
    }
   }

2. 数组元素的排序算法
   选择排序
   直接选择排序、 堆排序
   交换排序
   冒泡排序、 快速排序
   插入排序
   直接插入排序、 折半插入排序、 Shell排序
   归并排序
   桶式排序
   基数排序
   **

   //冒泡排序
   public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {-34, 23, 45, 12, -4, 56, 98, -45, 9};
        //排序
        for(int i=0; i<arr.length-1;i++)
            for(int j=0; j < arr.length-i-1; j++)
            {
                if(arr[j] > arr[j+1])
                {
                    arr[j] = arr[j] ^ arr[j+1];
                    arr[j+1] = arr[j] ^ arr[j+1];
                    arr[j] = arr[j] ^ arr[j+1];
                }
            }
        //打印
        for(int i=0; i<arr.length;i++)
            System.out.print(arr[i] + " ");
        System.out.println();
    }
   }

   
   排序算法的选择
   (1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
   当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
   (2)若文件初始状态基本有序(指正序)，则应选用直接插入、 冒泡或随机的快速排序为宜；
   (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法： 快速排序、 堆排序或归并排序。

   Arrays工具类

   java.util.Arrays类即为操作数组的工具类， 包含了用来操作数组（比如排序和搜索） 的各种方法。

数组使用中常见异常