数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

● 数组名
● 元素
● 角标、下标、索引
● 数组的长度：元素的个数

? 数组是有序排列的。
? 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
? 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
? 数组的长度一旦确定，就不能修改。
? Java语言中声明数组时不能指定其长度(数组中元素的数)。
例如： int a[5]; //非法

（1）按照维度：一维数组、二维数组、三维数组、…
（2）按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

格式：type var[]; 或 type[] var；
例如：int a[]; int[] a1; double b[]; String[] c; //引用类型变量数组

（1）静态初始化（指定内容）：在定义数组的同时就为数组元素分配空间并赋值。

//例1： int arr[] = new int[]{ 3, 9, 8}; 或 int[] arr = {3,9,8};

//例2： String names[] = {“李四光”,“茅以升”,“华罗庚” }

（2）动态初始化（指定长度）：数组声明且为数组元素分配空间与赋值的操作分开进行。

//例1： int[] arr = new int[3]; arr[0] = 3; arr[1] = 9; arr[2] = 8;

//例2： String names[]; names = new String[3]; names[0] = “钱学森”; names[1] = “邓稼先”; names[2] = “袁隆平”;

//变量的声明和初始化 int num; //声明 num = 10; //初始化 int id = 1001; //声明 + 初始化//一维数组的声明和初始化 int[] ids; //声明 //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行 ids = new int[]{1001,1002,1003,1004}; //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行 String[] names = new String[5]; //错误的写法： //int[] arr1 = new int[]; //int[5] arr2 = new int[5]; //int[] arr3 = new int[3]{1,2, 3}; //也是正确的写法： int[] arr4 = {1,2,3,4,5}; //类型推断 //总结：数组一旦初始化完成，其长度就确定了。

? 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素。

? 数组元素的引用方式：数组名 [ 数组元素下标 ]
● 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
● 数组元素下标从0开始；长度为n的数组合法下标取值范围（整数）: [ 0, n-1 ]。
如int a[] = new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]。

? 每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数) ，且数组一旦初始化，其长度是不可变的。

//调用数组的指定位置的元素:通过角标的方式调用。 //数组的角标（或索引）从0开始的，到数组的长度-1结束。 String[] names = new String[5]; names[0] = "王铭"; names[1] = "王赫"; names[2] = "张学良"; names[3] = "孙居龙"; names[4] = "王宏志"; //charAt(0) names[5] = "周扬"; //错误的

//属性:length String[] names = new String[5]; System.out.println(names.length); //5

String[] names = new String[5];

? 方式一（不采取）：

System.out.println(names[0]); System.out.println(names[1]); System.out.println(names[2]); System.out.println(names[3]); System.out.println(names[4]);

? 方式二（推荐）：

for(int i = 0; i < names.length; i++){ System.out.println(names[i]); }

? 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：

public class Test { public static void main(String argv[]){ int a[]= new int[5]; System.out.println(a[3]); //a[3]的默认值为0 } }

? 对于基本数据类型而言，默认初始化值各有不同；对于引用数据类型而言，默认初始化值为null（注意与0不同）。

(1) 数组元素是整型：0

int[] arr = new int[4]; for(int i = 0; i < arr.length; i++){ System.out.print(arr[i]+"/t"); }//output：0000short[] arr1 = new short[4]; for(int i = 0; i < arr1.length; i++){ System.out.println(arr1[i]+"\t"); } //output：0000

(2) 数组元素是浮点型：0.0

float[] arr2 = new float[5]; for(int i = 0; i < arr2.length; i++){ System.out.println(arr2[i]+"\t"); } //out:0.00.00.00.0

(3) 数组元素是char型：0或’\u0000’，而非’0’

char[] arr3 = new char[4]; for(int i = 0; i < arr3.length; i++){ System.out.println("----" + arr3[i] + "****"); }if(arr3[0] == 0){ System.out.println("你好！"); } /*output: ---- **** ---- **** ---- **** ---- **** 你好! */

(4) 数组元素是boolean型：false

boolean[] arr4 = new boolean[5]; System.out.println(arr4[0]); //output:false

(5) 数组元素是引用数据类型：null

String[] arr5 = new String[5]; System.out.println(arr5[0]); if(arr5[0] == null){ System.out.println("北京天气不错！"); } /*output: null 北京天气不错！ */

● Java中使用关键字new来创 建数组
● 如下是创建基本数据类型元素的一维数组

public class Test{ public static void main(String args[]){ int[] s; s = new int[10]; for ( int i=0; i<10; i++ ) { s[i] =2*i+1; System.out.println(s[i]); } } }

public class Test{ public static void main(String args[]){ int[] s; s = new int[10]; //int[] s=new int[10]; //基本数据类型数组在显式赋值之前， //Java会自动给他们赋默认值。 for ( int i=0; i<10; i++ ) { s[i] =2*i+1; System.out.println(s[i]); } } }

public class Test{ public static void main(String args[]){ int[] s; s = new int[10]; for ( int i=0; i<10; i++ ) { s[i] =2*i+1; System.out.println(s[i]); } } }

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。从数组底层的运行机制来看，其实没有多维数组。

格式1：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
解析：

1. 定义一个名称为arr的二维数组，二维数组中有三个一维数组。
2. 每一个一维数组中具体元素也都已初始化 。
3. 第一个一维数组 arr[0] = {3,8,2};
4. 第二个一维数组 arr[1] = {2,7};
5. 第三个一维数组 arr[2] = {9,0,1,6};
6. 第三个一维数组的长度表示方式：arr[2].length;
7. 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
8. Java中多维数组不必都是规则矩阵形式

格式2：int[ ][ ] arr = new int[3][2];
解析：

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

格式3：int[][] arr = new int[3][];
解析

1. 二维数组中有3个一维数组。
2. 每个一维数组都是默认初始化值null (注意：区别于格式1）
3. 可以对这个三个一维数组分别进行初始化
   arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
4. 注： int[][]arr = new int[][3]; //非法

int[] arr = new int[]{1,2,3}; //一维数组//静态初始化 int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}}; //动态初始化1 String[][] arr2 = new String[3][2]; //动态初始化2 String[][] arr3 = new String[3][]; //错误的情况 //String[][] arr4 = new String[][4]; //String[4][3] arr5 = new String[][]; //int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}}; //也是正确的写法： int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}}; int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}}; String[][] arr2 = new String[3][2]; System.out.println(arr1[0][1]); //2 System.out.println(arr2[1][1]); //nullString[][] arr3 = new String[3][]; arr3[1] = new String[4]; System.out.println(arr3[1][0]); //null

int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}}; System.out.println(arr4.length); //3 System.out.println(arr4[0].length); //3 System.out.println(arr4[1].length); //4

int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}}; for(int i = 0; i < arr4.length; i++){ for(int j = 0; j < arr4[i].length; j++){ System.out.print(arr4[i][j] + ""); } }

规定：二维数组分为外层数组的元素，内层数组的元素
例：int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等

（1）针对于初始化格式2：比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同。

（2）针对于初始化格式3：比如：int[][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。

int[][] arr = new int[4][3]; System.out.println(arr); //[[I@6d06d69c System.out.println(arr[0]); //[I@15db9742 System.out.println(arr[0][0]); //0float[][] arr1 = new float[4][3]; System.out.println(arr1[0]); //[F@4554617c System.out.println(arr1[0][0]); //0.0String[][] arr2 = new String[4][2]; System.out.println(arr2[1]); //[Ljava.lang.String; @74a14482 System.out.println(arr2[1][1]); //nulldouble[][] arr3 = new double[4][]; System.out.println(arr3[1]); //null //System.out.println(arr3[1][0]); //报错

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

java.util.Arrays类的sort()方法提供了数组元素排序功能

import java.util.Arrays; public class SortTest { public static void main(String[] args) { int [] numbers = {5,900,1,5,77,30,64,700}; Arrays.sort(numbers); for(int i = 0; i < numbers.length; i++){ System.out.println(numbers[i]); } } }

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

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

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

//情况一： int[] arr1 = new int[]{1,2,3}; arr1 = null; //System.out.println(arr1[0]); //情况二： int[][] arr2 = new int[4][]; //System.out.println(arr2[0][0]); //情况三： String[] arr3 = new String[]{"AA","BB","CC"}; arr3[0] = null; //System.out.println(arr3[0].toString());

以上两种异常，在编译时均不报错！