参考资料：

1.《java jdk5.0 学习笔记》良葛格 第五章数组

2.如何理解数组的length?

http://blog.csdn.net/treeroot/archive/2005/01/22/264001.aspx

3.关于java数组的深度思考

http://dev.csdn.net/author/DeepNightTwo/afb7e220bdf5423ba656f84b6a183b44.html



一.为什么需要数组？（《java jdk5.0 学习笔记》良葛格）

例如，现在要整理全班的Java小考成绩，您希望写个小程序，全班共有40名学生，所以必须有40个变量来存储学生的成绩。现在问题来了，根据第3章学过的变量定义方式，难道要定义40个名称不同的变量来存储学生的成绩数据吗？


当然不必这么麻烦，Java提供“数组”(Array)让您可以定义一个以“索引”(Index)作为识别的数据结构。在Java中，可以这么定义一个数组并初始数组内容：


int[] score = {90, 85, 55, 94, 77};


二.什么是数组？

java语言中，数组是一种最简单的复合数据类型。数组是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。

（http://www.linux8.net/html/java/2006-3/29/21_59_23_560.html）


array的定义和使用：使用“[]”做为索引运算符（indexing operator).(《TIJ》）


三.java中数组到底是什么？


1）不管在其他语言中是什么，数组在Java中可得看作一个对象，它有一些值得探讨的特性。

（《java jdk5.0 学习笔记》良葛格）


这就意味着与C++中的数组的根本不同，相反，Java中的数组与C++中的STL或Java中的容器类反而更相像一些（只是作为对象，它的方法要比STL中的容器类或者Collection类少很多）。


Java中的数组其实是一个对象，但是确实是一个特殊的对象，实在是太特殊了，以致我们都不好把它多做对象处理。


刚刚开始接触java数组的人都会听到一句类似的话：java是纯面向对象的语言，他的数组也是一个对象。

于是乎，我就按照一个对象的方式来使用数组，心安理得。直到我接触到C的数组后，才发现将数组作为一个类来使用在实现上是多么的“不自然”。

首先我们看一下表面现象，数组创建的时候采用的是如下语句：

MyClass[] arr = new MyClass[9];

而普通类采用的是如下语句：

MyClass obj = new MyClass();

就是说，创建数组的时候不使用小括号传参。使得数组和普通类看起来就有很多不同，因为小括号里的参数是传递给构造方法的，进而让人感觉数组类是没有构造方法的。

（http://dev.csdn.net/author/DeepNightTwo/afb7e220bdf5423ba656f84b6a183b44.html）


2）java中数组是对象的依据：


a）来源：（http://blog.csdn.net/treeroot/archive/2005/01/22/264001.aspx）


我们确定数组的父类是Object，

  new Object[0].getClass().getSuperClass()  是Object.class


数组没有对应的类文件，String对应String.class.但是数组却没有，而且他们的

  类名字很古怪，可以这样获得 new int[2].getClass().getName();

  这是和其他对象最大的不同点，因为数组类是在运行时生成的。


java.lang.reflect.Array是final的，所以数组肯定不是它的子类

  这个类用来动态生成数组或者操作数组(获得长度等).




b）来源：（http://dev.csdn.net/author/DeepNightTwo/afb7e220bdf5423ba656f84b6a183b44.html）


再往深了想，还有很多让人感觉不自然的东西。可以肯定的是，java确实将数组作为了一个类来处理。还是用上面的例子说明：

可以通过以下方法得到MyClass[]的Class实例：arr.getClass()或MyClass[].class。这样，我就可以向数组类里面“窥探”了。

Class clazz = MyClass[].class;

System.out.println(clazz.getConstructors().length);

打印出来的结果是0；证明数组类确实没有构造方法。



再看看数组类的“庐山真面目”：

System.out.println(clazz);

输出是：

[Larraytest.MyClass


对Java Class文件结构稍有了结就知道，这个字符串的意思就是一个元素类型为arraytest.MyClass的一维数组。也就是说，数组类型不是和普通类一样，以一个全限定路径名+类名来作为自己的唯一标示的，而是以[+一个或者多个L+数组元素类全限定路径+类来最为唯一标示的。这个()也是数组和普通类的区别。而这个区别似乎在某种程度上说明数组和普通java类在实现上有很大区别。因为java虚拟机(java指令集)在处理数组类和普通类的时候，肯定会做出区分。我猜想，可能会有专门的java虚拟机指令来处理数组。


分析到这里，我基本上可以肯定：java对数组对象化的操作的支持是指令级的，也就是说java虚拟机有专门针对数组的指令。数组的Class类实例是java虚拟机动态创建动态加载的，其结构与普通java类的Class实例有一些不同。


JDK API中有一个java.lang.reflect.Array类，这个类提供了很多方法(绝大多数是native方法，这在另一个方面证明了java对数组的支持是专用指令支持的，否则用本地方法干嘛^_^)，用来弥补我们对数组操作的局限性。

下面这句话用来创建一个一维的、长度为10的、类型为arraytest.MyClass的数组：

arraytest.MyClass[] arr = (arraytest.MyClass[]) Array.newInstance(arraytest.MyClass, 10);


下面这句话用来创建一个二维的、3乘5的、类型为arraytest.MyClass的数组：

int[] arrModel = new int[]{3,5};

Object arrObj = Array.newInstance(Sub.class, arrModel);

当然你可以用一个数组的引用指向上面的二维数组，这里我们用一个Object的引用指向他。

使用的时候，我们也是可以利用Array类提供的方法来实现：


System.out.println(Array.getLength(arrObj);//第一维长度为3

System.out.println(Array.getLength(Array.get(arrObj, 2)));//第二维长度为5，这里如果写3，就会得到你意想之中的java.lang.ArrayIndexOutOfBoundsException


打印结果是如我所想的：

3

5


对于数组的Class类实例，还有一些奇怪的现象：

在运行代码 java.lang.reflect.Field fieldarr = clazz.getField("length");的时候，会抛出异常：java.lang.NoSuchFieldException: length，这似乎在说数组类没有length这个域，而这个域其实是我们用的最多的一个（也就是说这个域是肯定存在的）。我想关于数组的Class类实例、数组的实现等，还有很多“猫腻”在里面。


顺便说一句，java数组最多只能是255维的。这个让人看到了C的影子，嘿嘿。


“Java把数组当作一个java类来处理”说起来容易，用起来自然，但是细细想来，还是有很多不简单的地方呀。 




c）来源：《java jdk5.0 学习笔记》良葛格 第五章数组


从对数组对象的进一步探讨，可以稍微了解Java对对象处理的一些方法。首先来看看一维数组的引用名称的定义：


int[] arr = null;


在这个定义中，arr表示一个可以参考引用自一维数组对象的变量名称，但是目前将这个名称参考引用自null，表示还没有指定这个名称参考引用自实际的对象。在Java中，=运算用于基本数据类型时，是将值复制给变量，但当它用于对象时，则是将对象指定给参考引用名称来参考引用。也可以将同一个对象指定给两个参考引用名称，当对象的值由其中一个参考引用名称进行操作而变更时，另一个参考引用名称所参考引用到的值也会变动。下面来看看范例5.8的示范。


ü 范例5.8  AdvancedArray.java


public class AdvancedArray {


    public static void main(String[] args) {


        int[] arr1 = {1, 2, 3, 4, 5};


        int[] tmp1 = arr1;


        int[] tmp2 = arr1;


 


        System.out.print("通过tmp1取出数组值：");


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


            System.out.print(tmp1[i] + " ");


 


        System.out.print("\n通过tmp2取出数组值：");


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


            System.out.print(tmp2[i] + " ");


 


        tmp1[2] = 9;


        System.out.print("\n\n通过tmp1取出数组值：");


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


            System.out.print(tmp1[i] + " ");


 


        System.out.print("\n通过tmp2取出数组值：");


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


            System.out.print(tmp2[i] + " ");


        System.out.println();


    }


}


执行结果：


 


通过tmp1取出数组值：1 2 3 4 5


通过tmp2取出数组值：1 2 3 4 5


 


通过tmp1取出数组值：1 2 9 4 5


通过tmp2取出数组值：1 2 9 4 5


 


在这个范例中，通过tmp1名称改变了索引2的元素值，由于tmp2也引用自同一数组对象，所以tmp2取出索引2的元素值是改变后的值。事实上在范例5.8中，有三个引用名称引用自同一个数组对象，也就是arr1、tmp1与tmp2，所以，如果取出arr1索引2的元素，元素值也会是9。



了解到在Java中数组是一个对象，而使用=指定时是将对象指定给数组名来引用，而不是将数组进行复制。如果想将整个数组的值复制给另一个数组该如何作呢？可以使用循环，将整个数组的元素值遍历一遍，并指定给另一个数组相对应的索引位置。范例5.10示范了进行数组复制的方法。

Ü范例5.10  ArrayCopy.java

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[5];
 
        for(int i = 0; i < arr1.length; i++)
            arr2[i] = arr1[i];
 
        for(int i = 0; i < arr2.length; i++)
            System.out.print(arr2[i] + " ");
        System.out.println();

    }
}

执行结果：
 

1 2 3 4 5

另一个进行数组复制的方法是使用System类提供的arraycopy()方法。其语法如下：
System.arraycopy(来源, 起始索引, 目的, 起始索引, 复制长度);
范例5.11改写了范例5.10，使用System.arraycopy()进行数组复制，执行结果与范例5.10是相同的。

Ü范例5.11  ArrayCopy2.java

public class ArrayCopy2 {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[5];
 
        System.arraycopy(arr1, 0, arr2, 0, arr1.length);
 
        for(int i = 0; i < arr2.length; i++)
            System.out.print(arr2[i] + " ");
        System.out.println();
    }
}



四、 Java中的数组作为对象带来的好处

1）越界检查


2）length field：与传统的C++中的数组相比，length字段可以方便的得到数组的大小；但要注意，仅仅可以得到数组的大小，不能得到数组中实际包含多少个元素，因为length 只会告诉我们最多可将多少元素置入那个数组。


3） 初始化：对象数组在创建之初会自动初始化成null，由原始数据类型构成的数组会自动初始化成零（针对数值类型），(Char)0 （针对字符类型）或者false （针对布尔类型）。


4） 数组作为返回值：首先，既然数组是对象，那么就可以把这个对象作为返回值；而且，不必担心那个数组的是否可用只要需要它就会自动存在而且垃圾收集器会在我们完成后自动将其清除

参考资料：
1.《java jdk5.0 学习笔记》良葛格 第五章数组
2.如何理解数组的length?
http://blog.csdn.net/treeroot/archive/2005/01/22/264001.aspx
3.关于java数组的深度思考
http://dev.csdn.net/author/DeepNightTwo/afb7e220bdf5423ba656f84b6a183b44.html
一.为什么需要数组？(《java jdk5.0 学习笔记》良葛格)
例如，现在要整理全班的Java小考成绩，您希望写个小程序，全班共有40名学生，所以必须有40个变量来存储学生的成绩。现在问题来了，根据第3章学过的变量定义方式，难道要定义40个名称不同的变量来存储学生的成绩数据吗？
当然不必这么麻烦，Java提供“数组”(Array)让您可以定义一个以“索引”(Index)作为识别的数据结构。在Java中，可以这么定义一个数组并初始数组内容：
int[] score = {90, 85, 55, 94, 77};
二.什么是数组？
java语言中，数组是一种最简单的复合数据类型。数组是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。
(http://www.linux8.net/html/java/2006-3/29/21_59_23_560.html)
array的定义和使用：使用“[]”做为索引运算符(indexing operator).(《TIJ》)
三.java中数组到底是什么？
1)不管在其他语言中是什么，数组在Java中可得看作一个对象，它有一些值得探讨的特性。
(《java jdk5.0 学习笔记》良葛格)
这就意味着与C++中的数组的根本不同，相反，Java中的数组与C++中的STL或Java中的容器类反而更相像一些(只是作为对象，它的方法要比STL中的容器类或者Collection类少很多)。
Java中的数组其实是一个对象，但是确实是一个特殊的对象，实在是太特殊了，以致我们都不好把它多做对象处理。
刚刚开始接触java数组的人都会听到一句类似的话：java是纯面向对象的语言，他的数组也是一个对象。
于是乎，我就按照一个对象的方式来使用数组，心安理得。直到我接触到C的数组后，才发现将数组作为一个类来使用在实现上是多么的“不自然”。
首先我们看一下表面现象，数组创建的时候采用的是如下语句：
MyClass[] arr = new MyClass[9];
而普通类采用的是如下语句：
MyClass obj = new MyClass();
就是说，创建数组的时候不使用小括号传参。使得数组和普通类看起来就有很多不同，因为小括号里的参数是传递给构造方法的，进而让人感觉数组类是没有构造方法的。
(http://dev.csdn.net/author/DeepNightTwo/afb7e220bdf5423ba656f84b6a183b44.html)
2)java中数组是对象的依据：
a)来源：(http://blog.csdn.net/treeroot/archive/2005/01/22/264001.aspx)
我们确定数组的父类是Object，
new Object[0].getClass().getSuperClass()  是Object.class
数组没有对应的类文件，String对应String.class.但是数组却没有，而且他们的
类名字很古怪，可以这样获得 new int[2].getClass().getName();
这是和其他对象最大的不同点，因为数组类是在运行时生成的。
java.lang.reflect.Array是final的，所以数组肯定不是它的子类
这个类用来动态生成数组或者操作数组(获得长度等).
b)来源：(http://dev.csdn.net/author/DeepNightTwo/afb7e220bdf5423ba656f84b6a183b44.html)
再往深了想，还有很多让人感觉不自然的东西。可以肯定的是，java确实将数组作为了一个类来处理。还是用上面的例子说明：
可以通过以下方法得到MyClass[]的Class实例：arr.getClass()或MyClass[].class。这样，我就可以向数组类里面“窥探”了。
Class clazz = MyClass[].class;
System.out.println(clazz.getConstructors().length);
打印出来的结果是0；证明数组类确实没有构造方法。
再看看数组类的“庐山真面目”：
System.out.println(clazz);
输出是：
[Larraytest.MyClass
对Java Class文件结构稍有了结就知道，这个字符串的意思就是一个元素类型为arraytest.MyClass的一维数组。也就是说，数组类型不是和普通类一样，以一个全限定路径名+类名来作为自己的唯一标示的，而是以[+一个或者多个L+数组元素类全限定路径+类来最为唯一标示的。这个()也是数组和普通类的区别。而这个区别似乎在某种程度上说明数组和普通java类在实现上有很大区别。因为java虚拟机(java指令集)在处理数组类和普通类的时候，肯定会做出区分。我猜想，可能会有专门的java虚拟机指令来处理数组。
分析到这里，我基本上可以肯定：java对数组对象化的操作的支持是指令级的，也就是说java虚拟机有专门针对数组的指令。数组的Class类实例是java虚拟机动态创建动态加载的，其结构与普通java类的Class实例有一些不同。
JDK API中有一个java.lang.reflect.Array类，这个类提供了很多方法(绝大多数是native方法，这在另一个方面证明了java对数组的支持是专用指令支持的，否则用本地方法干嘛^_^)，用来弥补我们对数组操作的局限性。
下面这句话用来创建一个一维的、长度为10的、类型为arraytest.MyClass的数组：
arraytest.MyClass[] arr = (arraytest.MyClass[]) Array.newInstance(arraytest.MyClass, 10);
下面这句话用来创建一个二维的、3乘5的、类型为arraytest.MyClass的数组：
int[] arrModel = new int[]{3,5};
Object arrObj = Array.newInstance(Sub.class, arrModel);
当然你可以用一个数组的引用指向上面的二维数组，这里我们用一个Object的引用指向他。
使用的时候，我们也是可以利用Array类提供的方法来实现：
System.out.println(Array.getLength(arrObj);//第一维长度为3
System.out.println(Array.getLength(Array.get(arrObj, 2)));//第二维长度为5，这里如果写3，就会得到你意想之中的java.lang.ArrayIndexOutOfBoundsException
打印结果是如我所想的：
3
5
对于数组的Class类实例，还有一些奇怪的现象：
在运行代码 java.lang.reflect.Field fieldarr = clazz.getField("length");的时候，会抛出异常：java.lang.NoSuchFieldException: length，这似乎在说数组类没有length这个域，而这个域其实是我们用的最多的一个(也就是说这个域是肯定存在的)。我想关于数组的Class类实例、数组的实现等，还有很多“猫腻”在里面。
顺便说一句，java数组最多只能是255维的。这个让人看到了C的影子，嘿嘿。
“Java把数组当作一个java类来处理”说起来容易，用起来自然，但是细细想来，还是有很多不简单的地方呀。
c)来源：《java jdk5.0 学习笔记》良葛格 第五章数组
从对数组对象的进一步探讨，可以稍微了解Java对对象处理的一些方法。首先来看看一维数组的引用名称的定义：
int[] arr = null;
在这个定义中，arr表示一个可以参考引用自一维数组对象的变量名称，但是目前将这个名称参考引用自null，表示还没有指定这个名称参考引用自实际的对象。在Java中，=运算用于基本数据类型时，是将值复制给变量，但当它用于对象时，则是将对象指定给参考引用名称来参考引用。也可以将同一个对象指定给两个参考引用名称，当对象的值由其中一个参考引用名称进行操作而变更时，另一个参考引用名称所参考引用到的值也会变动。下面来看看范例5.8的示范。
ü 范例5.8  AdvancedArray.java
public class AdvancedArray {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] tmp1 = arr1;
int[] tmp2 = arr1;
System.out.print("通过tmp1取出数组值：");
for(int i = 0; i < tmp1.length; i++)
System.out.print(tmp1[i] + " ");
System.out.print("\n通过tmp2取出数组值：");
for(int i = 0; i < tmp2.length; i++)
System.out.print(tmp2[i] + " ");
tmp1[2] = 9;
System.out.print("\n\n通过tmp1取出数组值：");
for(int i = 0; i < tmp1.length; i++)
System.out.print(tmp1[i] + " ");
System.out.print("\n通过tmp2取出数组值：");
for(int i = 0; i < tmp2.length; i++)
System.out.print(tmp2[i] + " ");
System.out.println();
}
}
执行结果：
通过tmp1取出数组值：1 2 3 4 5
通过tmp2取出数组值：1 2 3 4 5
通过tmp1取出数组值：1 2 9 4 5
通过tmp2取出数组值：1 2 9 4 5
在这个范例中，通过tmp1名称改变了索引2的元素值，由于tmp2也引用自同一数组对象，所以tmp2取出索引2的元素值是改变后的值。事实上在范例5.8中，有三个引用名称引用自同一个数组对象，也就是arr1、tmp1与tmp2，所以，如果取出arr1索引2的元素，元素值也会是9。
了解到在Java中数组是一个对象，而使用=指定时是将对象指定给数组名来引用，而不是将数组进行复制。如果想将整个数组的值复制给另一个数组该如何作呢？可以使用循环，将整个数组的元素值遍历一遍，并指定给另一个数组相对应的索引位置。范例5.10示范了进行数组复制的方法。
Ü范例5.10  ArrayCopy.java
public class ArrayCopy {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = new int[5];
for(int i = 0; i < arr1.length; i++)
arr2[i] = arr1[i];
for(int i = 0; i < arr2.length; i++)
System.out.print(arr2[i] + " ");
System.out.println();
}
}
执行结果：
1 2 3 4 5
另一个进行数组复制的方法是使用System类提供的arraycopy()方法。其语法如下：
System.arraycopy(来源, 起始索引, 目的, 起始索引, 复制长度);
范例5.11改写了范例5.10，使用System.arraycopy()进行数组复制，执行结果与范例5.10是相同的。
Ü范例5.11  ArrayCopy2.java
public class ArrayCopy2 {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = new int[5];
System.arraycopy(arr1, 0, arr2, 0, arr1.length);
for(int i = 0; i < arr2.length; i++)
System.out.print(arr2[i] + " ");
System.out.println();
}
}
四、 Java中的数组作为对象带来的好处
1)越界检查
2)length field：与传统的C++中的数组相比，length字段可以方便的得到数组的大小；但要注意，仅仅可以得到数组的大小，不能得到数组中实际包含多少个元素，因为length 只会告诉我们最多可将多少元素置入那个数组。
3) 初始化：对象数组在创建之初会自动初始化成null，由原始数据类型构成的数组会自动初始化成零(针对数值类型)，(Char)0 (针对字符类型)或者false (针对布尔类型)。
4) 数组作为返回值：首先，既然数组是对象，那么就可以把这个对象作为返回值；而且，不必担心那个数组的是否可用只要需要它就会自动存在而且垃圾收集器会在我们完成后自动将其清除
原文：http://www.blogjava.net/flysky19/articles/92763.html?opt=admin

数组也是对象
数组是放置相同类型的数据
数组里面放置的每一个变量都是有下标的。
数组的长度是确定的
数组的元素类型必须是相同的
数组类型可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
引用数据类型的理解: 
https://www.cnblogs.com/hetaoyuan/p/10582553.html
一、基本数据类型：
byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0
short：短整型，在内存中占16位，即2个字节，取值范围-32768~32767，默认值0
int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0
long：长整型，在内存中占64位，即8个字节-263~263-1，默认值0L
float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0
double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0
char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空
boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false二、引用数据类型：
类、接口类型、数组类型、枚举类型、注解类型。区别：
基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上。
引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。
声明完数组的时候这个时候它是空的 
然后需要给这个数组做初始化工作
用数组的时候我们必须要给它指明一个长度
超过索引下标赋值运行会报错
数组下标的范围是从0，length-1
刚才用的断点我们发现去不掉了，如何去掉呢
数组使用引用数据类型
https://www.zhihu.com/video/1219645035756924928
https://www.zhihu.com/video/1219645062876966912
https://www.zhihu.com/video/1219645097937305600

第一节 什么是数组
数组可以理解为是一个巨大的“盒子”，里面可以按顺序存放多个类型相同的数据，比如可以定义 int 型的数组 scores 存储 4 名学生的成绩，int[] scores={76,93,87,55};数组中的元素下标从0开始 0123；那么我们该如何使用java中的数组呢？
1.声明数组，语法：数据类型[] 数组名；或者  数据类型 数组名[]；其中数组名是任意合法的变量名
2.分配空间，简单地说，就是指定数组中最多可存储多少个元素。语法：  数组名 = new  数据类型 [ 数组长度 ];其中，数组长度就是数组中能存放元素的个数。
我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：
3.赋值，分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的。
在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成。
它等价于：
第二节 使用循环操作 Java 中的数组
数组名.length  用于获取数组的长度
注意：
1、 数组下标从 0 开始。因此 scores[3] ，表示数组中的第 4 个元素，而并非第 3 个元素
2、 数组下标的范围是 0 至 数组长度-1 ，如果越界访问，就会报错。
第三节 使用 Arrays 类操作 Java 中的数组
Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。
import java.util.Arrays;
Arrays 中常用的方法：
1、 排序 Arrays.sort(数组名)
可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序(按升序排列)
2、转换为字符串 Arrays.toString(数组名)
可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开
第四节 使用 foreach 操作数组
foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。
语法 for(元素类型 元素变量：遍历对象){执行的代码}
第五节 Java 中的二维数组
所谓二维数组，可以简单的理解为是一种“特殊”的一维数组，它的每个数组空间中保存的是一个一维数组。
那么如何使用二维数组呢，步骤如下：
1、 声明数组并分配空间
数据类型[][] 数组名=new 数据类型[行的个数][列的个数];
或者 数据类型[][] 数组名；数组名=new 数据类型[行的个数][列的个数];
2、赋值
二维数组的赋值和一维数组类似，可以通过下标来逐个赋值，注意索引从 0 开始
数组名[行索引][列索引]=值；
也可以在声明时为其赋值
数据类型[][] 数组名={{值1，值2...}，{值11，值12...}，{值21，值22...}};
3、处理数组
二维数组的访问和输出同一维数组一样，只是多了一个下标而已。在循环输出时，需要里面再内嵌一个循环，即使用二重循环来输出二维数组中的每一个元素。例：
//定义一个两行三列的二维数组并赋值
int[][] num={{1,2,3},{4,5,6}};
//定位行
for(int i=0;i
//定位每行的元素
for(int j=0;j
//遍历输出每个元素
System.out.print(num[i][j])
}
//实现换行
System.out.println();
}
//num.length 表示为这个二维数组有多少个子集，即多少行
//num[i].length 表示为这个二维数组第i行有多少个元素
需要了解的：在定义二维数组时也可以只指定行的个数，然后再为每一行分别指定列的个数。如果每行的列数不同，则创建的是不规则的二维数组，如下所示：