五、数组

1. 数组概述
数组可以看成是多个相同类型数据组合，对这些数据的统一管理。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
一维数组的声明：type var[]； 或 type[] var；Java语言中声明数组时不能指定其长度(数组中元素的个数)，例如：int a[5]; //非法
Java中使用关键字 new 创建数组对象，格式为：数组名 ＝ new 数组元素的类型 [数组元素的个数]
注意：元素为引用数据类型的数组中的每一个元素都需要实例化。
数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化，如：

public class Test {
    public static void main(String args[]) {
        int a[] = new int[5];
        Date[] days = new Date[3];
        System.out.println(a[3]);
        System.out.println(days[2]); 
    }
}
class Date {
    int year,month,day;
    Date(int y, int m, int d) {
        year = y; month = m; day = d;
    }
}

2. 数组元素的引用
定义并用运算符new为之分配空间后后，才可以引用数组中的每个元素，数组元素的引用方式为：arrayName[index] index为数组元素下标，可以是整型常量或整型表达式。如：a[3], b[i], c[6*i] 。数组元素下标从0开始；长度为n的数组的合法下标取值范围为0 ～ n-1 。每个数组都有一个属性length指明它的长度，例如：a.length的值为数组a的长度(元素个数)。
3. 二维数组
二维数组可以看成以数组为元素的数组。例如：int a[][] = {{1,2},{3,4,5,6},{7,8,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]; //非法

4. 二维数组初始化

 静态初始化：
      int intA[][] = {{1,2},{2,3},{3,4,5}};
      int intB[3][2] = {{1,2},{2,3},{4,5}};//非法
  动态初始化：
       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];

5. 数组的拷贝
使用java.lang.System类的静态方法
public static void arraycopy(Object src,int srcPos,Object dest, int destPos,int length)
可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置。
如果源数据数目超过目标数组边界会抛出 ndexOutOfBoundsException 异常。

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();
    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();
    }
  }
}

6. 排序

//选择排序
//java NumSort 3 5 7 1 2 8 9 4 6
//读程序的方法:1,画图2,打印测试信息
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);
		selectionSort(a);
		print(a);
	}
	//每一次外层循环,最多交换一次
	public static void selectionSort(int[] a) {
		int temp;
		for (int i = 0; i < a.length; i++) {
			//System.out.println(i);
			for (int j = i + 1; j < a.length; j++) {
				//System.out.println("  "+j);
				if (a[i] > a[j]) {
					temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				//System.out.print("    " + i +" <-->"+j +"  ");
				//print(a);

				}
			}
		}
		//for (int i = 0; i < a.length; i++) {
		//	System.out.print(a[i] + " ");
		//}
	}
	//每一次外层循环,可能交换多次
	public static void selectionSort1(int[] a) {
		int k, temp;
		for (int i = 0; i < a.length; i++) {
			k = i;
			for (int j = k + 1; j < a.length; j++) {
				if(a[j] < a[k]) {
					k = j;
				}
			}

			if(k != i) {
				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();
	}


}