引用类型——Java数组

数组：

一组相关数据的集合，实际上就是一连串的变量，可以分为：一维数组、二维数组、多维数组

默认值为null，暂时还没有任何指向的内存空间

Java中的数组必须先初始化，然后才可以使用。
所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。

一、数组初始化

1，静态初始化

静态初始化：初始化时由程序员显式指定每个数组元素的初始值，由系统决定需要的数组长度。

静态初始化语法格式：

arrayName=new type[]{element1,element2,element3,element4...};

type:数组元素的数据类型，此处的type必须与定义数组变量时所使用的type相同，也可以是定义数组时所使用的type的子类；并使用花括号把所有的数组元素括起来，多个元素之间以逗号（，）隔开，定义初始化值的花括号紧跟[]之后。

代码示例：

//定义一个int数组类型的变量，变量名为intArr

int[] intArr;    //声明一维数组

//使用静态初始化，初始化数组时只指定数组元素的初始值，不指定数组长度。

intArr=new int[]{5,6,8,20};

//定义一个Object数组类型的变量，变量名为objArr

Object[] objArr;

//使用静态初始化，初始化数组时数组元素的类型是定义数组时数组元素类型的子类

objArr=new String[]{"Java","李钢"};

Object[] objArr2;

//使用静态初始化

objArr2=new Object[]{"java"，"鲤鱼"};

arrayName={element1,element2,element3,element4...}

代码示例：

int scorep[]={23,56,89,75,68};        //数组声明并附初值

2，动态初始化

动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值

动态初始化语法格式：

arrayName=new type[length];   //分配内存给数组

length指定了数组的长度，也就是可以容纳数组元素的个数。

代码示例：

//数组的定义和初始化同时完成，使用动态初始化语法

int[] prices=new int[5];

//数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类。

Object[] books=new String[4];

指定初始值时，系统按如下规则分配初始值：

（1）数组元素的类型是基本类型中的整数类型（byte、short、int和long），则数组元素的值是0.

（2）数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的值是0.0.

（3）数组元素的类型是基本类型中的字符类型（char），则数组元素的值是'\u0000'.

（4）数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的值是false.

（5）数组元素的类型是引用类型（类、接口和数组），则数组元素的值是null.

注意：

不要静态初始化和动态初始化同时使用。

数组初始化完成后就可以使用数组了。

二、使用数组

数组最常用的用法就是访问数组元素，包括对数组元素进行赋值和访问数组元素的值。

Java语言的数组索引是从0开始的，第一个数组元素的索引值为0，最后一个数组元素的索引为数组长度减1.

代码如下：

//输出objArr数组的第二个元素，将输出字符串“李钢”

System.out.println(objArr[1]);

//为objArr2的第一个数组元素赋值

objArr[0]="Spring";

如果访问数组元素时指定的索引小于0，或者大于等于数组的长度，编译程序不会出现任何错误，将运行时出现异常：java.lang.ArrayIndexOutOfBoundsException:2(数组索引越界异常)，这个异常提示信息后的一个int整数，就是程序员视图访问的数组索引。

代码示例：

//访问数组元素指定的索引等于数组长度，所以下面代码将在运行时出现异常

System.out.println(objArr2[2]);

遍历数组：

//使用循环输出pricese数组的每个数组元素的值

for(int i=0;i<prices.length[i];i++)

{

    System.out.println(prices[i]);

}

三、foreach循环

从JDK1.5之后，Java提供了一种更简单的循环：foreach循环，这种循环遍历数组和集合更加简洁。

foreach循环的语法格式：

for(type variableName : array | collection)

{

    //variableName自动迭代访问每个元素...

}

type 数组元素或集合元素的类型

variableName 形参名，foreach循环将自动将数组元素、集合元素依次赋给该变量。

代码示例：

String[] books={"轻量级J2EE","权威指南","Ajax宝典"};

//使用foreach循环来遍历数组元素，其中book将会自动迭代每个数组元素

for(String book:books)

{

    //使用foreach循环来迭代输出数组元素或集合元素时，通常不要对循环变量进行赋值

    //book="Ruby On Rails敏捷开发最佳实践";    

    System.out.println(book);

}

注意：

使用foreach循环迭代数组元素时，并不能改变数组元素的值，因此不要对foreach的循环变量进行赋值。

四、数组在内存中的运行机制

1，数组的运行介质
数组是一种引用数据类型，数组饮用变量只是一个引用，数组元素和数组变量在内存里是分开的。

实际的数组元素被存储在堆（heap）内存中；数组引用变量是一个引用类型的变量，被存储在栈（stack）内存中。

为什么有栈内存和堆内存之分？

       当一个方法执行时，每个方法都会建立自己的内存栈，在这个方法内定义的变量将会逐个放入这块栈内存里，随着方法的执行结束，这个方法的内存栈随之销毁。因此，所有在方法中定义的变量都是放在栈内存中的；当我们在程序中创建一个对象时，这个对象将被保存在运行时数据区中，以便反复利用（因为对象的创建成本通常较大），这个运行时数据区就是堆内存。堆内存的独享不会随方法的结束而销毁，即使方法结束后，这个对象还可能被另一个引用变量引用，则这个对象依然不会被销毁。只有当一个对象没有任何引用变量引用它时，系统的垃圾回收机制才会在合适的时候回收它。

代码示例：

//定义并初始化数组，使用静态初始化

int[] a={5,7,20};

//定义并初始化数组，使用动态初始化

int[] b=new int[4];

//输出b数组的长度

System.out.println("b数组的长度为："b.length);

//循环输出a数组的元素

for(int i=0;i<a.length;i++)

{

    System.out.println(a[i]);

}

//循环输出b数组的元素

for(int i=0;i<b.length;i++)

{

    System.out.println(b[i]);

}

//因为a是int[]类型，b是int[]类型，所以可以将a的值赋给b

//也就是让b引用指向a引用指向的数组

b=a;

//再次输出b数组的长度

System.out.println("b数组的长度为："b.length);

运行结果：

b数组的长度为：4

5

7

20

0

0

0

0

b数组的长度为：3

       定义并初始化一个数组后，在内存里分配了两个空间，一个用于存放数组的引用变量，一个用于存放数组本身。

当程序定义并初始化了a、b两个数组时，系统内存中实际产生了4块内存区，其中栈内存中有两个引用变量：a和b；堆内存中也有两块内存区，分别用于存储a和b引用所指向的数组本身。

内存的存储示意图如下图所示：

当b=a代码时，系统将会把a的值赋给b，a和b都是引用类型变量，存储的是地址。因此把a的值赋给b后，就是让b指向a所指向的地址。此时计算机内存的存储示意图如下所示：

当执行了b=a之后，堆内存中第一个数组中具有了两个引用：a变量和b便来那个都指向了第一个数组。
此时第二个数组失去了作用，变成垃圾，只有等待垃圾回收来回收它——但它的长度依然不会改变，直到它彻底消失。

2，基本类型数组的初始化

对于基本类型数组而言，数组元素的值直接存储在对应的数组元素中，因此，初始化数组时，先为该数组分配内存控件，然后直接将数组元素的值存入对应数组元素中。

代码示例如下：

//定义一个int[]类型的数组常量

int[] iArr;  //仅定义一个数组变量此时内存示意图如下：

//动态初始化数组，数组长度为5

iArr=new int[5];  //动态初始化后，系统将负责为该数组分配内存空间，并分配默认的初始值：所有数组元素都被赋为0，此时内存中的存储示意图为：

//采用循环方式为每个数组元素赋值

for(int i=0;i<iArr.length;i++) 

{

    iArr[i]=i+10;

}

//当循环为该数组的每个数组元素依次赋值后，此时每个数组元素的值都变成程序制定的值。显式制定数组元素值后存储示意图如下所示：

从上图中可以看到基本类型数组的存储示意图，每个数组元素的值直接存储在对应的内存里。
操作基本数据类型数组的数组元素时，实际上就是操作基本类型的变量。

3，引用类型数组的初始化
引用类型数组的数组元素是引用：每个数组元素里存储还是引用，它指向另一块内存，这块内存里存储了有效数据。

class Person

{

    //年龄

    public int age;

    //身高

    public double height;

    //定义一个info方法

    public void info()

    {

        System.out.println("我的年龄是："+age+" 我的身高是："+height);

    }

}

//定义一个students数组变量，其类型是Person[]

Person[] students;   //这行代码仅仅在栈内存中定义了一个引用变量，也就是一个指针，这个指针并未指向任何有效的内存区。此时内存中存储示意图如下所示：

//执行动态初始化

students =new Person[2]; //

//创建一个Person示例，并将这个Person示例赋给zhang变量

Person zhang=new Person();

//为zhang所引用的Person对象的属性赋值

zhang.age=15;

zhang.height=158;

//创建一个Person示例，并将这个Person实例赋值给lee变量

Perosn lee=new Person();

//为lee所引用的Person对象的属性赋值

lee.age=16;

lee.height=161;

//定义两个Person实例，定义这两个实例实际上分配了4块内存，在栈内存中存储了zhang和lee两个引用变量，还在堆内存中存储了两个Person实例。此时的内存存储示意图如下所示：

//将zhang变量的值赋给第一个数组元素

students[0]=zhang;

//将lee变量的值赋给第二个数组元素

students[1]=lee;

//当程序把张赋给students数组的第一个元素，把lee赋给students数组的第二个元素，students数组的两个数组元素将会指向有效的内存区。此时的内存存储示意图如下所示：

从上面图可以看出：此时zhang和students[0]指向同一个内存区，而且它们都是引用类型变量，因此通过zhang和student[0]来访问Person实例的属性和方法的效果完全一样，不论修改students[0]所指向的Person实例的属性，还是修改zhang变量所指向的Person实例的属性，所修改的其实是同一个内存区，所以必然互相影响。同理，lee和students[1]也有相同的效果。

//下面两行代码的结果完全一样，因为lee和students[1]指向的是同一个Person实例

lee.info();

students[1].info();

运行结果：

我的年龄是：16 我的身高是：161.0

我的年龄是：16 我的身高是：161.0

五、操作数组的工具类

java.util.Arrays

Java提供的Arrays类里包含了一些static修饰的方法可以直接操作数组，这个Arrays类里包含了如下几个static修饰的方法（static修饰的方法可以直接通过类名调用）。

binarySearch(type[] a,type key):

使用二分法查询key元素值在a数组中出现的索引；如果a数组不包含key元素值，则返回负数。
调用该方法时要求数组中元素已经按生序排列，这样才能得到正确结果。

binarySearch(type[] array, int fromIndex, int toIndex, type value)：

与前面的方法类似，但它只搜索a数组中fromIndex到toIndex索引的元素。
调用该方法时要求数组中元素已经按生序排列，这样才能得到正确结果。

copyOf(type[] original, int newLength)：

这个方法会把original数组复制成一个新数组，其中length是新数组的长度。
如果length小于original数组的长度，则新数组就是原数组的前面length个元素；如果length大于original数组的长度，
则新数组的前面元素就是原数组的所有元素，后面补充0（数值型）、false（布尔型）或者null（引用型）。

 copyOfRange(type[] original, int from, int to)：

这个方法与前面方法类似，但这个方法只复制original数组的from索引到to索引的元素。

equals(type[] array1, type[] array2):

如果把array1数组和array2数组的长度相等，而array1数组和array2数组的数组元素一一相同，该方法返回true。

fill(type[] array, type value)：

该方法将会把a数组所有元素值都赋值为value。

fill(type[] array, int fromIndex, int toIndex, type value)：

这个方法与前面方法类似，区别是该方法仅仅对fromIndex到toIndex索引的数组元素赋值为value。

sort(type[] array)：

该方法对数组array的数组元素进行排序。

sort(type[] array, int fromIndex, int toindex)：

这个方法与前面方法类似，区别是该方法仅仅对fromIndex到toIndex索引的元素进行排序。

toString(type[] array)：

该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，
多个数组元素使用英文逗号（,）和空格隔开。

代码示例：

//定义一个a数组

int[] a=new int[]{3,4,5,6};

//定义一个a2数组

int[] a2=new int[]{3,4,5,6};

//a数组和a2数组的长度相等，每个元素依次相等，将输出true

System.out.println("a数组和a2数组是否相等："+Arrays.equals(a,a2));

//通过赋值a数组，生成一个新的b数组

int[] b=Arrays.copyOf(a,6);

System.out.println("a数组和a2数组是否相等："+Arrays.equals(a,b));

//输出b数组的元素，将输出{3,4,5,6,0,0}

System.out.println("b数组的元素为：："+Arrays.toString(b));

//将b数组的第3个元素（包括）到第五个元素（不包括）赋为1

Arrays.fill(b,2,4,1);

//输出b数组的元素，将输出{3,4,1,1,0,0}

System.out.println("b数组的元素为：："+Arrays.toString(b));

//对b数组进行排序

Arrays.sort(b);

//输出b数组的元素，将输出{0,0,1,1,3,4}

System.out.println("b数组的元素为：："+Arrays.toString(b));

运行结果：

a数组和a2数组是否相等：true

a数组和a2数组是否相等：false

b数组的元素为：：[3, 4, 5, 6, 0, 0]

b数组的元素为：：[3, 4, 1, 1, 0, 0]

b数组的元素为：：[0, 0, 1, 1, 3, 4]

为了在程序中使用Arrays类，必须在程序中导入java.util.Arrays类。

System类的一个方法：

static void arraycopy(Object arc,int srcPos,Object dest,int destPos,int length):

该方法可以将src数组里的元素值赋给dest数组的元素，其中srcPos指定从src数组的第几个元素开始复制，
length参数指定将src数组的多少个元素赋给dest数组的元素。

六、其他

二维数组

    数据类型 数组名[]=null;        //声明一维数组

    数组名=new 数据类型[行的个数][列的个数]；    //分配内存给数组

多维数组

    int a[][][][]=new int[][][][];

代码实例：

public class JavaArray {

    public static void main(String args[])

    {

        //一维数组

        int score[]={52,1,26,89,75,5,6,78,90,23};

        int max=0;

        int min=0;

        max=min=score[0];

        for (int i = 0; i < score.length; i++) {

            if(score[i]>max)

            {

                max=score[i];

            }

            if(score[i]<min)

            {

                min=score[i];

            }

        }

        System.out.println("最大数值："+max);

        System.out.println("最小数值："+min);

        //动态定义

        int a[]=new int[3];

        a[0]=3;

        a[1]=3;

        a[2]=3;

        for (int i = 0; i < a.length; i++) {

            System.out.print(score[i]+"\t");

        }

        System.out.println();

        //给数组进行排序

        for (int i = 1; i < score.length; i++) {

            for (int j = 0; j < score.length; j++) {

                if(score[i]<score[j])

                {

                    int temp=score[i];

                    score[i]=score[j];

                    score[j]=temp;

                }

            }

        }

        for (int i = 0; i < score.length; i++) {

            System.out.print(score[i]+"\t");

        }

        //二维数组

        int aEr[][]=new int[4][3]; 

        aEr[0][0]=30;

        aEr[1][1]=28;

        aEr[0][2]=45;

        aEr[2][0]=28;

        aEr[3][2]=8;

        for (int i = 0; i < aEr.length; i++) {

            for (int j = 0; j < aEr[i].length; j++) {

                System.out.print(aEr[i][j]+"\t");

            }

            System.out.println("");

        }

    }

}