Java学习笔记（一维数组类型、初始化、使用/基本类型数组和引用类型数组）--day_4

【1】数组类型
在任何已有类型后加上方括号[ ]，又变成一种新类型，这种类型统称为数组类型，所有的数组类型又称为引用类型，所以又称引用类型。
Java的数组要求所有数组元素具有相同的数据类型。因此，在一个数组中，数组元素的类型是唯一的，即一个数组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。


一旦数组的初始化完成，**数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。**即使把某个数组元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。
Java的数组既可以存储基本类型的数据，也可以存储引用类型的数据。
值得指出的是：数组也是一种数据类型，它本身是一种引用类型。

【2】定义数组
Java语言支持两种语法格式来定义数组：
type[ ] arrayName;
type arrayName[ ];
对于这两种语法格式，一般推荐使用第一种格式。因为第一种格式不仅具有更好的语意，也具有更好的可读性。
数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量（也就是定义了一个指针），这个引用变量还未指向任何有效的内存，因此定义数组时不能指定数组的长度。
※注意：定义数组时不能指定数组的长度。

【3】数组的初始化
静态初始化：初始化时由程序员显式指定每个数组的初始值，由系统决定需要的数组长度。
动态初始化：初始化时程序员指定数组长度，由系统为数组元素分配初始值
arrayName = new type[ length];
在上面的语法中，需要指定一个int整型的length参数，这个参数指定了数组的长度，也就是可以容纳数组元素的个数。

【4】使用数组
数组最常用的用法就是访问数组元素，包括对数组元素赋值和访问数组元素的值，访问数组元素是通过在数组引用变量后紧跟一个方括号（[ ]），方括号里是数组元素的索引值。
Java语言的数组索引是从0开始的，也就是说，第一个数组元素的索引值为0，最后一个数组元素的索引为数组长度减1。
如果访问数组元素进指定的索引小于0，或者大于等于数组的长度，编译程序不会出现任何错误，但运行时出现异常：java.lang.ArrayIndexOutOfBoundsException:2（数组索引越界异常），在这个异常提示信息后有一个int 整数，这个整数就是程序员试图访问的数组索引。
所有数组都提供了一个**length属性，通过这个属性可以访问到数组的长度，**一旦获得了数组的长度后，就可以通过循环来遍历该数组的每个数组元素。

public class Arry 
{
	public static void main(String[] args) 
	{
		
		int[] a = new int[]{3,4,20,25};//静态初始化
		System.out.println(a[2]);

		int i,j;
		for(i=0;i<4;i++)
		{
		System.out.println(a[i]);
		}


		double[] b =new double[4];//动态初始化
		b=new double[]{3,4,20,25};
		for(j=0;j<b.length;j++)
		{
		System.out.println(b[j]);
		}
	
 }
}

public class ArrayTest
{
	public static void main(String[] args)
	{
		// 定义一个int数组类型的变量，变量名为intArr.
		int[] intArr;
		// 使用静态初始化，初始化数组时只指定数组元素的初始值，不指定数组长度。
		intArr = new int[]{5, 6, 8 , 20};
		// 定义一个Object数组类型的变量，变量名为objArr.
		Object[] objArr ;
		// 使用静态初始化，初始化数组时数组元素的类型是
		// 定义数组时所指定的数组元素类型的子类
		objArr = new String[]{"Java" , "李刚"};
		Object[] objArr2 ;
		// 使用静态初始化
		objArr2 = new Object[] {"Java" , "李刚"};


		// 数组的定义和初始化同时完成，使用简化的静态初始化写法
		int[] a = {5, 6 , 7, 9};


		//数组的定义和初始化同时完成，使用动态初始化语法
		int[] prices = new int[5];
		// 数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类
		Object[] books = new String[4];


		// 输出objArr数组的第二个元素，将输出字符串"李刚"
		System.out.println(objArr[1]);
		// 为objArr2的第一个数组元素赋值
		objArr2[0] = "Spring";

		// 访问数组元素指定的索引等于数组长度，所以下面代码将在运行时出现异常
		// System.out.println(objArr2[2]);


		// 使用循环输出prices数组的每个数组元素的值
		for (int i = 0; i < prices.length ; i ++ )
		{
			System.out.println(prices[i]);
		}

		// 对动态初始化后的数组元素进行赋值
		books[0] = "疯狂Java讲义";
		books[1] = "轻量级Java EE企业应用实战";
		// 使用循环输出books数组的每个数组元素的值
		for (int i = 0 ; i < books.length ; i++ )
		{
			System.out.println(books[i]);
		}
	}
}

【5】foreach循环
从JDK1.5 之后，Java提供了一种更简单的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组和集合元素时，无须获得数组和集合长度，无须根据索引来访问数组元素和集合元素，foreach循环自动遍历数组和集合的每个元素。
当使用foreach循环来迭代输出数组元素或集合时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允许的，但没有太大的意义，而且极容易引起错误。

public class ForEachErrorTest
{
	public static void main(String[] args)
	{
		String[] books = {"张三" ,"李四","王五"};
		// 使用foreach循环来遍历数组元素，其中book将会自动迭代每个数组元素
		for (String book : books)
		{
			System.out.println(book);
		}
	}
}

【6】深入数组
数组元素和数组变量在内存里是分开存放的。实际的数组元素是存储在堆（heap）内存中；数组引用变量是一个引用类型的变量，被存储在栈（stack）内存中。
如果堆内存中数组不再有任何引用变量指向自己，则这个数组将成为垃圾，该数组所占的内存将会被系统的垃圾回收机制回收。因此，为了让垃圾回收机制回收一个数组所占的内存空间，则可以将该数组变量赋为null，也就切断了数组引用变量和实际数组之间的引用关系，实际数组也就成了垃圾。

【7】数组长度不可变
只要类型相互兼容，可以让一个数组变量指向另一个实际的数组，这种操作会产生数组的长度可变的错觉。
但由于数组变量整体赋值导致的数组的长度可以改变，只是一个假相。

public class Ar
{
	public static void main(String[] args)
	{
		// 定义并初始化数组，使用静态初始化
		int[] a = {5, 7 , 20};
		// 定义并初始化数组，使用动态初始化
		int[] b = new int[4];
		// 输出b数组的长度
		System.out.println("b数组的长度为：" + b.length);
		// 循环输出a数组的元素
		for (int i = 0 ,len = a.length; i < len ; i++ )
		{
			System.out.println(a[i]);
		}
		// 循环输出b数组的元素
		for (int i = 0 , len = b.length; i < len ; i++ )
		{
			System.out.println(b[i]);
		}
		// 因为a是int[]类型，b也是int[]类型，所以可以将a的值赋给b。
		// 也就是让b引用指向a引用指向的数组
		b = a;
		// 再次输出b数组的长度
		System.out.println("b数组的长度为：" + b.length);
	}
}

【8】基本类型数组和引用类型数组的初始化
对于基本类型数组而言，数组元素的值直接存储在对应的数组元素中，因此，初始化数组时，先为该数组分配内存空间，然后直接将数组元素的值存入对应数组元素中。

引用类型数组的数组元素是引用，因此情况变得更加复杂：每个数组元素里存储的还是引用，它指向另一块内存，这块内存里存储了有效数据。