标签：
数组可以堪称是多个相同类型数据组合，对这些数据的统一管理
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
数组中的元素可以是任何数据类型，包括基本类型和引用类型
type var [ ] ; 或 type [ ] var ;
例如：
int a1[]; int[] a2; double b[]; Person [] p1; String s1[];
java语言中声明数组时不能指定其长度（数组中的元素个数）因为java数组分配的空间是在堆上面，例如：
int a[5]; //非法
java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素个数]，例如：
public class Test { public static void main(String[] args){ int[] s; s = new int[5]; for (int i=0;i<5;i++){ s[i] = 2 * i + 1; } } }
注意：元素为引用数据类型的数组中的每一个元素都需要实例化
例如：
public class Test { public static void main(String[] args){ Date[] days; days = new Date[3]; for (int i=0;i<3;i++){ days[i] = new Date(2004,4,i+1); } } } class Date { int year; int month; int day; Date(int y,int m,int d) { year = y; month = m; day = d; } }
数组定义与为数组元素分配空间和赋值的操作分开进行，先分配空间再赋值；例如：
public class Test { public static void main(String[] args){ int a[]; a = new int[3]; a[0] = 3; a[1] = 9; a[2] = 8; Date days[]; days =new Date[3]; days[0] = new Date(1, 4, 2004); days[1] = new Date(2, 4, 2004); days[2] = new Date(3, 4, 2004); } } class Date { int year; int month; int day; Date(int y,int m,int d) { year = y; month = m; day = d; } }
在定义数组的同时就为数组元素分配空间并赋值，例如：
public class Test { public static void main(String[] args){ int a[] = {3,9,8}; Date days[] = {new Date(1, 4, 2004),new Date(2, 4, 2004),new Date(3, 4, 2004)}; } } class Date { int year; int month; int day; Date(int y,int m,int d) { year = y; month = m; day = d; } }
数组是引用类型，他的元素相当于类的成员变量，因此，数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化，例如：
public class Test { public static void main(String[] args){ int a[] = new int[3]; Date[] days = new Date[3]; System.out.println("a[3] = "+a[2]); System.out.println("days[3] = "+days[2]); } } class Date { int year; int month; int day; Date(int y,int m,int d) { year = y; month = m; day = d; } }
输出结果：
a[3] = 0 days[3] = null
定义并用运算符new为数组分配空间后，才可以引用数组中的每个元素，数组元素的饮用方式为：
arrayName[index]
其中index为数组元素的下标，可以是整型常量或整型表达式。如：a[3],b[i],c[6*i]等
数组元素下表从0开始；长度为n的数组的合法下标取值范围为：0—（n-1）
每个数组都由一个属性length指明它的长度，例如：a.length的值为数组a的长度（也就是元素个数）
二维数组可以看成是以数组为元素的数组，例如：
int a[] [] = { {1,2}, {3,4,5,6}, {7,9}};
java中多维数组的声明和初始化应从高纬到低纬的顺序进行，例如：
int a[][] = new int [3][]; a[0] = new int [2]; a[1] = new int [4]; a[2] = new int [3]; //非法 int t1[][] = new int [][4];
如上的示例可以参考下面的图来理解：
以二维数组为例，其实二维数组就相当于数组中包含数组，所以在声明的时候要先声明第一纬度，如上：、
a[0] = new int [2]; 相当于给第一个包含在内的数组声明了两个小格的内存，
a[1] = new int [4]; 相当于给第二个包含在内的数组声明了四个小格的内存，
a[2] = new int [3]; 相当于给第三个包含在内的数组声明了三个小格的内存，
理解了二维数组的概念应该就能理解多维的概念
int intA[][] = {{1,2},{3,4},{7,8,9}}; int intB[3][2] = {{1,2},{3,4},{7,8,}};//非法
int a[][] = new int [3] [5]; int b[][] = new int [3][]; b[0] = new int [2]; b[1] = new int [3]; b[2] = new int [5];
//测试类 public class Test { public static void main(String[] args){ int a[][] = {{1,2},{3,4,5,6},{7,8,9}}; for(int i=0;i<a.length;i++) { for (int j=0;j<a[i].length;j++) { System.out.print("a["+i+"]["+j+"]="+a[i][j]+" "); } System.out.println(); } } } //输出结果 a[0][0]=1 a[0][1]=2 a[1][0]=3 a[1][1]=4 a[1][2]=5 a[1][3]=6 a[2][0]=7 a[2][1]=8 a[2][2]=9
//测试类 public class Test { public static void main(String[] args){ String[][] s; s = new String[3][]; s[0] = new String[2]; s[1] = new String[3]; s[2] = new String[2]; for(int i=0;i<s.length;i++) { for(int j=0;j<s[i].length;j++) { s[i][j] =new String("我的位置是： "+i+","+j); System.out.print(s[i][j]+" "); } System.out.println(); } } } //输出结果： 我的位置是： 0,0 我的位置是： 0,1 我的位置是： 1,0 我的位置是： 1,1 我的位置是： 1,2 我的位置是： 2,0 我的位置是： 2,1
使用java.lang.System类的静态方法：
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int lenth)
看一个例子：
//测试类 public class Test { public static void main(String[] args){ //一维数组的拷贝 String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"}; String[] sBak = new String[6]; System.arraycopy(s, 0, sBak, 0, s.length); for(int i=0;i<sBak.length;i++){ System.out.print(sBak[i]+" "); } System.out.println(); for(int i=0;i<s.length;i++){ System.out.print(s[i]+" "); } System.out.println(); //二维数组的拷贝 int [][] intArray = {{1,2},{1,2,3},{3,4}}; int [][] intArrayBak = new int[3][]; System.arraycopy(intArray, 0, intArrayBak, 0, intArray.length); intArrayBak[2][1] = 100; for(int i = 0;i<intArray.length;i++) { for(int j=0;j<intArray[i].length;j++) { System.out.print(intArray[i][j]+" "); } System.out.println(); } } }
public class Test { public static void main(String[] args){ int a[] = {1,3,5,7,9,11,13,15,17}; //打印数组中所有元素 for(int i=0;i<a.length;i++) { System.out.print(a[i]+" "); } } }
输出结果
1 3 5 7 9 11 13 15 17
这里要说一下main主方法中有一个（String[] args），main()方法是Java应用程序的入口方法，也就是说main()方法是程序运行的时候第一个执行方法，这个方法体是被固定的，比如方法名字必须是main，类型必须是public static void的，方法必须接受一个字符串数组的参数，这个参数主要是为程序使用者在命令行状态下与程序交互提供的一种手段
再简单点，其实main方法中的数组就是为了让使用者通过命令行传参来使用的一个数组。你也可以在自己的程序中利用for循环将main方法中的数组打印出来，但是在不传参的情况下打印出来的内容为空，但是如果在命令行下运行你的测试类，并在命令行传入参数，就会进行输出了，比如：
使用命令行传参的方式写了一个小的计算器，计算加减乘除
public class Test { public static void main(String[] args){ if(args.length<3){ //使用了转义符 System.out.println("Usage: java Test \"n1\" \"op\" \"n2\""); } else if(args.length==3) { //写了一个小计算 //将参数的字符串转换为基础类型
double d1 = Double.parseDouble(args[0]); double d2 = Double.parseDouble(args[2]); double d = Double.parseDouble(args[1]); if(args[1].equals("+")) { d = d1 + d2; }else if(args[1].equals("-")) { d = d1 - d2; }else if(args[1].equals("x")) { d = d1 * d2; }else { d = d1 / d2; } System.out.println(d); } else { System.out.println("Usage: java Test \"n1\" \"op\" \"n2\""); } } }
这是一段对命令行传参进行排序并输出的小程序，可以试着写一下调试一下，当然这不一定是最优算法，只是拿来测试用一下
public class Test { public static void main(String[] args){ int[] a = new int[args.length]; for(int i=0;i<args.length;i++) { a[i] = Integer.parseInt(args[i]) ; } print(a); sort(a); print(a); } private static void sort(int[] a) { for(int i=0;i<a.length;i++) { for(int k=i+1;k<a.length;k++){ if(a[k] < a[i]) { int temp =a[i]; a[i] = a[k]; a[k] = temp; } } } } private static void print(int[] a) { for(int i=0;i<a.length;i++) { System.out.print(a[i]+" "); } System.out.println(); } }
标签：
原文地址：http://www.cnblogs.com/JianXu/p/5625496.html
