Java中的数组（初始化及在内存中的变化）

概述

• 数组可以看成是多个相同类型数据组合，对这些数据的统一管理；
• 数组遍历属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量；
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型；
• java中使用关键字new创建数组对象，格式为：数组名=new 数组元素的类型[数组元素的个数]；
• java中除了基本数据类型外，其他所有的都是引用类型；

实例代码：

public class Testarr{
	public static void main(String args[]){
		int[] s;
		s = new int[5];
		for (int i =0; i < 5; i++){
			s[i] = i;
		}
	}
}

 内存分析：

引用数据类型数组

元素为引用数据类型的数组中的每一个元素都需要实例化

实例代码：

public class TestArray{
	public static void main(String args[]){
		Date[] days;
		days = new Date[3];
		for(int i = 0; i < 3; i++){
			days[i] = new Date(2020,2,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 TestArry{
	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,2,2020);
		days[1] = new Date(2,2,2020);
		days[2] = new Date(3,2,2020);
	}
}
class Date{
	int year;
	int month;
	int day;
	Date(int y,int m,int d){
		year = y;
		month = m;
		day = d;
	}
}

默认初始化

数组是引用类型，他的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化

实例代码：

public class TestAaa{
	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;
	int month;
	int day;
	Date(int y,int m,int d){
		year = y;
		month = m;
		day = d;
	}
}

数组元素的引用

• 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的引用方式为：arrayName[intdex];index为数组下标可以是整型常量或整型表达式；
• 每个数组都有一个属性length指明他的长度，a.length的值为数组a的长度（元素个数）。

二维数组

• 二位数组可以看成是以数组为元素的数组；
• java中多维数组的声明和初始化应按照从高维到低维的顺序进行。

数组的拷贝

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

如果想把一个字符串转化成一个基础的数据类型，使用他们的基础类型的包装类

实例代码：(args的认识和应用)

public class NumSort{
	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);
	}
	
	private static void selectionSort(int[] a){
		for(int i = 0;i < a.length;i++){
			for(int j = i + 1;j < a.length;j++){
				if(a[j] < a[i]){
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
	}
	
	private static void print (int[] a){
		for(int i = 0;i < a.length;i++){
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
}

输出结果：

 代码示例（更优）：

public class NumSort{
	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);
	}
	
	private static void selectionSort(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();
	}
}

输出结果：

 

示例代码：

任意初始化days数组，然后对days的元素排序，再用折半查找法查找特定的Date对象day

public class TestDateSort{
	public static void main (String[] args){
		Date[] days = new Date[5];
		days[0] = new Date(2019,7,8);
		days[1] = new Date(2020,2,13);
		days[2] = new Date(2020,2,12);
		days[3] = new Date(2018,8,8);
		days[4] = new Date(2019,8,8);
		
		bubbleSort(days);
		for(int i = 0;i < days.length;i++){
			System.out.println(days[i]);
		}
	}
	
	public static Date[] bubbleSort(Date[] a){
		int len = a.length;
		for(int i = len-1;i>=1;i--){
			for(int j = 0;j<=i-1;j++){
				if(a[j].compare(a[j+1])>0){
					Date temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
		return a;
	}
}

class Date{
	int year,month,day;
	Date(int y, int m, int d){
		year = y;
		month = m;
		day = d;
	}
	
	public int compare(Date date){
		return year > date.year ? 1
		: year < date.year ? -1
		: month > date.month ? 1
		: month < date.month ? -1
		: day > date.day ? 1
		: day < date.day ? -1
		: 0;
		
	}
	
	public String toString(){
		return "Year:Month:Day -- " + year + "-" + month + "-" + day;
	}
}

输出结果：

 二维数组示例代码：

public class TestTwoSort{
	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();
		}
	}
}

输出结果：

内存分析：

二维数组拷贝实例代码：

public class TestArrayCopy{
	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();
		}
	}
}

输出结果：

内存分析：