Java语言基础（七）—— 数组

数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。例如，如果a是一个整型数组，a[i]就是数组中下标为i的整数。
简单的给它一个定义吧：数组是存储同一种数据类型的多个元素的容器。
在声明数组时，我们如何去定义呢？下面给出两种定义数组的格式：
A:数据类型[] 数组名;（比如：int[] a）定义一个int类型的数组a变量
B:数据类型 数组名[];（比如：int a[]）定义一个int类型的a数组变量
需要注意的是：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。推荐使用第一种。

如何对数组进行初始化呢?

什么是初始化？就是为数组开辟内存空间，并为每个数组元素赋予值。
初始化有几种方式呢？
1、动态初始化 只指定长度，由系统给出初始化值
2、静态初始化 给出初始化值，由系统决定长度

动态初始化的格式：

数据类型[] 数组名 = new 数据类型[数组长度];
举例：
int[] arr = new int[3];
如何获取数组中的元素呢?
通过：
数组名[索引]，索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。
如下案例代码：

public class ArrayDemo01 {    public static void main(String[] args) {        //定义一个数组        //int[] a;        //可能尚未初始化变量a        //System.out.println(a);        int[] arr = new int[3];        /*            左边：                int:说明数组中的元素的数据类型是int类型                []:说明这是一个数组                arr:是数组的名称            右边：                new:为数组分配内存空间。                int:说明数组中的元素的数据类型是int类型                []:说明这是一个数组                3:数组长度，其实也就是数组中元素的个数        */        System.out.println(arr); //[I@175078b 地址值。        //我要地址值没有意义啊，我就要数据值，怎么办呢?        //不用担心，java为你考虑到了。        //其实数组中的每个元素都是有编号的，并且是从0开始。最大编号是数组的长度-1。        //用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引        //通过数组名访问数据的格式是：数组名[索引];        System.out.println(arr[0]);        System.out.println(arr[1]);        System.out.println(arr[2]);    }}

数组的静态初始化：

格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例：

        int[] arr = new int[]{1,2,3};        简化后：                    int[] arr = {1,2,3};

我们需要注意的是：不要同时动态和静态进行。
如下格式：
int[] arr = new int[3]{1,2,3}; //错误
如下案例代码：

public class ArrayDemo02 {    public static void main(String[] args) {        //定义数组        int[] arr = {1,2,3};        System.out.println(arr);        System.out.println(arr[0]);        System.out.println(arr[1]);        System.out.println(arr[2]);    }}

数组操作的两个常见小问题：

1、ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
2、NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
如下代码演示：

public class ArrayDemo03 {    public static void main(String[] args) {        //定义数组        int[] arr = {1,2,3};        //System.out.println(arr[3]);           //引用类型的常量：空常量 null        arr = null;        System.out.println(arr[0]);    }}

遍历数组(迭代数组)

利用循环处理数组中每个元素, 称为遍历数组。
如下案例代码：

int[] score = {88, 67, 95, 59, 66, 99};//             0   1    2   3   4   5//score[0]+score[1]+score[2]+int sum=0;//sum += score[0];//sum += score[1];//sum += score[2];//sum += score[3];//sum += score[4];for(int =0; i<score.length; i++){    sum += score[i];}

注意的是：数组的遍历是模式化写法, 要牢记！
如下案例：
数组获取最值(获取数组中的最大值最小值)

    分析：        A:定义一个数组，并对数组的元素进行静态初始化。        B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。        C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。        D:最后参照物里面保存的就是最大值。

---

如下代码：

public class ArrayDemo04 {    public static void main(String[] args) {        //定义一个数组        int[] arr = {34,98,10,25,67};               //请获取数组中的最大值        /*        //从数组中任意的找一个元素作为参照物        int max = arr[0];        //然后遍历其他的元素        for(int x=1; x<arr.length; x++) {            //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。            if(arr[x] > max) {                max = arr[x];            }        }        //最后参照物里面保存的就是最大值。        System.out.println("max:"+max);        */          //把这个代码用方法改进        //调用方法        int max = getMax(arr);        System.out.println("max:"+max);                 //请获取数组中的最小值        int min = getMin(arr);        System.out.println("min:"+min);    }       /*        需求：获取数组中的最大值        两个明确：            返回值类型：int            参数列表：int[] arr    */    public static 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 static int getMin(int[] arr) {        //从数组中任意的找一个元素作为参照物        int min = arr[0];        //然后遍历其他的元素        for(int x=1; x<arr.length; x++) {            //依次获取和参照物进行比较，如果小就留下来，如果大，就离开。            if(arr[x] < min) {                min = arr[x];            }        }        //最后参照物里面保存的就是最小值。        return min;    }}

复制数组

Java 提供了数组复制的API方法，使用System.arraycopy( )方法可以实现数组的复制。

public static void arraycopy(Object src, int srcPos,                            Object dest, int destPos, int length)src             – 源数组srcPos          – 源数组中的起始位置dest            – 目标数组destPos         – 目标数组中的起始位置length          – 要复制的数组元素的数量

如下案例代码：

/* * 复制数组 */int[] ary1 = {0,1,1,1,1,1,1,1,0};int[] ary2 = {1,1,1,1,1,1,1,1,1};//调用数组复制方法System.arraycopy(ary1, 0, ary2, 0, ary1.length);//输出结果for(int i=0;i<ary2.length; i++){    System.out.print(ary2[i]); }/* * 合并两个数组的内容 */int[] ary1={2,1,4,12,8};int[] ary2={3,1,5};int[] ary3=    new int[ary1.length+ary2.length];System.arraycopy(ary1, 0, ary3, 0, ary1.length);System.arraycopy(  ary2, 0, ary3,   ary1.length, ary2.length);for(int i=0; i<ary3.length; i++){    System.out.println(ary3[i]);}

Array.copyOf() 方法

使用java.util.Arrays类的copyOf方法可实现数组的复制。

类型[ ]  newArray  = Arrays.copyOf(类型[ ]  original , int newLength );newLength小于源数组，则进行截取newLength大于源数组，则用0或 null进行填充

特点是：生成的新数组是原始数组的副本
如下案例代码：

/* * 合并两个数组的内容 */int[] ary1={2,1,4,12,8};int[] ary2={3,1,5};int[] ary3= Arrays.copyOf(ary1, ary1.length+ary2.length);System.arraycopy(ary2, 0, ary3, ary1.length, ary2.length);for(int i=0; i<ary3.length; i++){    System.out.println(ary3[i]);}

数组扩容

数组的长度在创建后是不可改变的，所谓扩容是指创建一个更大的新数组并将原有数组的内容复制到其中。 可以通过Arrays.copyOf()方法，简便实现数组的扩展。
如下案例代码：

/* * 数组的扩容: 换一个更大的数组! */int[] ary = {4,5,6,1,2};ary=Arrays.copyOf(ary, ary.length+1);System.out.println(ary.length); // "[4, 5, 6, 1, 2...]"String s=Arrays.toString(ary);System.out.println(s); System.out.println(Arrays.toString(ary)); 

Arrays.sort()方法

JDK提供的Arrays.sort（）方法封装了数组的排序算法：
如下案例代码：

int[] ary = {3,1,2,32,23,56,98,2};/* * 利用Java提供的API方法进行排序 */Arrays.sort(ary); System.out.println(Arrays.toString(ary));