Java基础学习笔记十二 数组（补充）

数组

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

数组的三个基本特点：

• 1，长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
• 2，其元素必须是相同类型，不允许出现混合类型。
• 3，数组类型可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组的声明

type[] arr_name;//推荐使用
type arr_name[];

注意事项

• 1，声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
• 2，声明一个数组的时候并没有数组真正被创建
• 3，构造一个数组，必须指定长度。

示例：创建基本类型一维数组

public class Test {
	public static void main(String[] args) {
		int[] s = null; //声明数组
		s = new int[10]; //给数组分配空间
		for (int i=0;i<10;i++) {
			s[i] = 2 * i + 1;//给数组元素赋值
			System.out.println(s[i]);
 		}	
	}
}

基本类型数组内存分配图：

数组的初始化方式总共三种：静态初始化、动态初始化、默认初始化。
1，静态初始化数组

int[] a = {1,2,3};//静态初始化基本类型数组
Man[] mans = {new Man(1,1),new Man(2,2)};//静态初始化引用类型数组

2，动态初始化数组
数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] a1 = new int[2];//动态初始化数组，先分配空间
a1[0] = 1;//给数组元素赋值
a1[1] = 2;//给数组元素赋值

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

public class ArrayTest3 {
	public static void main(String args[]) {
		int a[] = new int[2];//默认给数组的元素进行赋值。赋值的规则和成员变量默认赋值规则一样，默认值0，0	
		boolean [] b = new boolean[2];//默认值：false，false
		String[] s = new String[2];//默认值：null,null
		for(int i = 0; i < 2; i++)
			System.out.println(a[i]);
		for(int i = 0; i < 2; i++)
			System.out.println(b[i]);
		for(int i = 0; i < 2; i++)
			System.out.println(s[i]);
	}
}

输出结果：

0
0
false
false
null
null

数组的遍历

数组元素下标的合法区间：[0,length-1]。
实例：使用循环遍历初始化和读取数组

public class Test {
	public static void main(String[] args) {
		int[] a = new int[4];
		//初始化数组元素的值
		for (int i=0;i<a.length;i++) {
			a[i] = 100*i;
		}
		//读取元素的值
		for (int i=0;i<a.length;i++) {
			System.out.println(a[i]);
		}
	}
}

for-each循环

增强for循环for-each是JDK1.5新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历
实例：增强for循环

public class Test {
	public static void main(String[] args) {
		String[] ss = {"aa","bbb","ccc","ddd"};
		for (String temp : ss) { //foreach循环：不能修改元素的值
			System.out.println(temp);
		}
	}
}

数组的拷贝

System类里也包含了一个static void arraycopy(object src,int srcpos,object dest,int destpos,int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。
示例：数组的拷贝

public class Test {
	public static void main(String[] args) {
		String[] s = {"A","B","C","D","E"};
		String[] sBak = new String[6];
		System.arraycopy(s,0,sBak,0,s.length);
		for (int i=0;i<sBak.length;i++) {
			System.out.println(sBak[i]+"\t");
		}
	}
}

数组中删除某个元素-------本质上还是数组的拷贝
示例：

public static void testBasicCopy() {
	String[] s1 = {"a","b","c","d","e"};
	System.arraycopy(s1,3,s1,3-1,s1.length-3);
	s1[s1.length-1] = null;
	for (int i=0;i<s1.length;i++) {
		System.out.println(i + "---" + s1[i]);
	}
}

内存分析图：

删除数组中指定索引位置的元素，并将原数组返回

public static String[] removeElment(String[] s,int index){
	System.arraycopy(s,index+1,s,index,s.length-index-1);
	s[s.length-1] = null;
	for (int i=0;i<s.length;i++){
		System.out.println(i + "---" + s[i]);
	}
	return s;
}

数组的扩容(本质上是：先定义一个更大的数组，然后将原数组内容原封不动拷贝到新数组中)

public static String extendRange(String[] s1){
	//String[] s1 = {"a","b","c"};
	String[] s2 = new String[s1.length+10];
	System.arraycopy(s1,0,s2,0s1.length);//将s1中所有的元素拷贝到s2
	for (String temp:s2){
		System.out.println(temp);
	}
	return s2;
}

多维数组

二维数组的声明

public class Test {
	public static void main(String[] args){
		//Java中多维数组的声明和初始化应按从低维到高维的顺序进行
		int[][] a = new int[3][];
		a[0] = new int[2];
		a[1] = new int[4];
		a[2] = new int[3];
		}
}

二维数组的静态初始化

public class Test {
	public static void main(String[] args){
		int[][] a = {{1,2,3}，{3,4}，{3,5,6,7}}；
		System.out.println(a[2][3]);
	}
}

数组存储表格数据。

public class TestArrayTableData {
	public static void main(String[] args) {
		Object[] emp1 = {1001,"Jsp",18,"A","2019.5.17"};
		Object[] emp2 = {1002,"Jsp1",19,"B","2019.6.17"};
		Object[] emp3 = {1003,"Jsp2",20,"C","2019.7.17"};
		
		Object[][] tableData = new Object[3][];
		tableData[0] = emp1;
		tableData[1] = emp2;
		tableData[2] = emp3;
		
		for(Object[] temp:tableData){
			System.out.println(Arrays.toString(temp));
		}
	}
}