Java之数组

数组作为一种成熟的数据结构，在Java中也有着大量的运用

数组的定义

概念

同一种类型数据的集合。其实数组就是一个容器
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素
数组也是一种类型，所有元素具有相同的类型
数组一旦完成初始化其长度就固定了

格式

格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];

格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，···};
示例：
int[] arr = new int[]{3,5,1,7};
int[] arr = {3, 5, 1, 7};

type [] arrayName;
type arrayName[];

数组初始化：
静态初始化：显式指定每个元素的初始化值，系统决定其长度
arrayName = new type[]{element1,element2,element···}
type[] arrayName = {element1,element2,element···}
动态初始化：指定数组长度，系统分配初始化值
arrayName = new type[lenght]

类型	分配的默认值
整型（`byte`，`short`，`int`，`long`）	`0`
浮点型（`float`，`double`）	`0.0`
字符型	`'\u0000'`
布尔型	`false`
引用类型	`null`

数组长度：
int i = arrayName.length;

foreach循环，遍历数组和集合

for ( type variableName : array | collection )
{
	//variableName自动迭代访问的每个元素
}

数组的内存分配及特点

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式

栈内存：

用于存储局部变量，当数据使用完，所占空间会自动释放

堆内存：

数组和对象，通过new建立的实例都存放在堆内存中
每一个实体都有内存地址值
实体中的变量都有默认初始化值
实体不在被使用，会在不确定的时间内被垃圾回收器回收

方法区，本地方法区，寄存器

数组操作常见问题

数组脚标越界异常(ArrayIndexOutOfBoundsException)

1 2	int[] arr = new int[2]; System.out.println(arr[3]);

访问到了数组中的不存在的脚标时发生

空指针异常(NullPointerException)

1 2	int[] arr = null; System.out.println(arr[0]);

arr引用没有指向实体，却在操作实体中的元素时

数组常见操作

遍历

int[] arr = {3,6,5,1,8,9,67};
for(int x = 0; x < arr.length; x++){
    System.out.println("arr[" + x + "]=" + arr[x]);
}

获取最值(最大值，最小值)

public int getMax(int[] arr){
    int max = arr[0];
    for(int x = 1; x < arr.length; x++){
        if(arr[x] > max)
            max = arr[x];
    }
    return max;
}

排序（选择排序，冒泡排序）

选择排序：

public void selectSort(int[] arr){
    for (int x = 0; x < arr.length - 1 ; x++){
        for(int y = x + 1; y < arr.length; y++){
            if(arr[x] > arr[y]){
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y]= temp;
            }
        }
    }
}

冒泡排序

public void bubbleSort(int[] arr){
    for(int x = 0; x < arr.length - 1; x++){									
        for(int y = 0; y < arr.length - x - 1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。{
            if(arr[y] < arr[y + 1]){
                int temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y +  1] = temp;
            }
        }
    }
}

折半查找(二分查找)

public static int halfSearch(int[] arr,int key){
    int min,max,mid;
    min = 0;
    max = arr.length - 1;
    mid = (max + min) / 2;

    while(arr[mid] != key){
        if(key > arr[mid])
            min = mid + 1;
        else if(key < arr[mid])
            max = mid - 1;

        if(min > max)
            return -1;
        mid = (max + min) / 2;
    }
    return mid;
}

进制转换的java实现

/* 十进制 -> 二进制 */
public void toBin(int num){
    trans(num, 1, 1);
}

/* 十进制 -> 八进制 */
public void toOct(int num){
    trans(num, 7, 3);
}

/* 十进制 -> 十六进制 */
public void toHex(int num){
    trans(num, 15, 4);
}

public void trans(int num,int base,int offset){
    if(num == 0){
        System.out.println(0);
        return ;
    }
    char[] chs = {'0','1','2','3'
                ,'4','5','6','7'
                ,'8','9','A','B'
                ,'C','D','E','F'};

    char[] arr = new char[32];
    int pos = arr.length;

    while(num != 0){
        int temp = num & base;
        arr[--pos] = chs[temp];
        num = num >>> offset;
    }

    for(int x = pos; x < arr.length; x++){
        System.out.print(arr[x]);
    }

    return ;
}

数组中的数组

二维数组[][]
格式1：

1	int[][] arr = new int[3][2];

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2：

1	int[][] arr = new int[3][];

二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化

1
2
3

arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];

格式3：

1	int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组arr[0] = {3,8,2};
第二个一维数组arr[1] = {2,7};
第三个一维数组arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

获取arr数组中所有元素的和。使用for的嵌套循环即可

注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组

type[][] arrayName;
理解：type[]为一种类型。拓展出了Java原本没有的二维数组。其本质依旧是一维数组，数组元素为数组，也就是一种引用。
arrayName = new type[length][];
第一个长度必须指定，否则无法分配内存大小

Arrays类的使用

Arrays类位于java.util包下。
static方法：
int binarySearch ( type[] a , type key )：使用二分法查询key元素值在a数组中出现的索引

int binarySearch ( type[] a , int fromIndex , int toIndex , type key )：搜索a数组中fromIndex到toIndex索引的元素

type[] copyOf ( type[] original , int length )：将original数组复制成一个长度为的新数组。如果大于length则用默认初始化值填充，如果小于length则从length处截断

type[] copyOfRange ( type[] original , int from , int to )：复制original数组从from到to的元素

boolean qeuals ( type[] a , type a2 )：对比a和a2数组的长度和元素是否相同，相同则返回true

void fill ( type[] a , type val )：将数组a中的所有元素赋值为val

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

void sort ( type[] a )：对数组a的元素进行排序

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

String toString ( type[] a )：将数组转化成一个字符串，将多个元素连缀在一起，用逗号和空格隔开

工具方法（parallel利用CPU并行，xxx代表数据类型）：
void parallelPrefix （ xxx[] array , XxxBinaryOperator op )：使用op参数指定的计算公式计算得到的结果作为新元素。（op：left/right）

void parallelPrefix （ xxx[] array , int fromIndex , int toIndex , XxxBinaryOperator op )：与上一个方法的区别在于仅重新计算fromIndex到toIndex索引元素

void setAll ( xxx[] array , IntToXxxFunction generator )：使用指定生成器（generator）为所有数组元素设置值，该生成器控制数组元素的值的生成算法

void parallelSetAll ( xxx[] array , IntToXxxFunction generator )：与上述方法相同，增加了并行能力，利用多CPU并行提高性能

void parallelSort ( xxx[] a )：与sort()方法类似，增加了并行能力

void parallelSort ( xxx[] a ， int fromIndex ， int toIndex)：对从fromIndex到toIndex的元素进行排序

Spliterator.OfXxx spliterator ( xxx[] array )：将该数组的所有元素转化成对应的Spliterator对象

Spliterator.OfXxx spliterator ( xxx[] array ， int startInclusive ， int endExclusive)：与上述方法类似，转换从startInclusive到endExclusive索引的元素

XxxStream stream ( xxx[] array )：将数组转化成Stream（流式编程的API）

XxxStream stream ( xxx[] array ， int startInclusive ， int endExclusive)：与上述方法类似，转化从startInclusive到endExclusive索引的元素