java尚硅谷学习笔记Lecture6之数组

这几天跟着尚硅谷视频学习了数组的相关知识，发现在Java中数组的定义和其他语言还是有所区别的，在看视频的时候个人感觉还是先看视频，看完之后，独自把代码实现一边，印象会更深刻。下面就是我在复现过程中的代码。

首先是一维数组：；

package com.zju.java;


/*
 * 数组
 * 数组的概念
 * >数组名
 * >元素
 * >角标、下标、索引
 * >数组的长度：元素的个数
 * 
 * 数组的特点：
 * 有序排列
 * 数组是引用数据类型，数组的元素可以是引用数据类型也可以是基本数据类型
 * 数组在内存中开辟一段连续的空间
 * 数组长度一旦确定就不可以修改
 * 
 * 数组的分类：
 * 按照维度：一维数组、二维数组
 * 按照数组元素的类型划分：基本类型元素的数组、引用数据类型元素的数组
 * 
 * 一维数组的使用：
 * 一维数组的声明和初始化
 * 如何调用指定位置的元素
 * 获取数组的长度
 * 遍历数组元素
 * 数组元素默认初始化值
 * 数组的内存解析
 * 
 */

public class ArrayTest 
{
	public static void main(String[] args) 
	{
		//一维数组的声明和初始化
		int[] ids;//数组的声明
		//静态初始化：数组的初始化和数组元素的赋值同时进行
		ids= new int[] {1001,1002,1003};
		//动态初始化：数组的初始化和数组元素的赋值分开进行
		String[] names =new String[5];
		//总结：数组一旦初始化完成，数组的长度就确定了
		
		//如何调用指定位置的元素:通过角标/索引的方式进行调用
		//数组的角标是从0开始，到数组长度-1结束
		names[0]="张三";
		names[1]="李四";
		names[2]="王五";
		names[3]="周六";//charAt(0):获取'周'字
		names[4]="黑夜";
		
		//获取数组的长度
		//属性：length
		System.out.println(names.length);//5
		System.out.println(ids.length);//3
		
		//遍历数组元素
		for(int i=0;i<names.length;i++)
		{
			System.out.println(names[i]);
		}
		
		//数组元素默认初始化值
		/*
		 >数组元素是整型：0
		 >数组元素是浮点型：0.0
		 >数组元素是char型:ASCII码0,而非'0'
		 >数组元素是boolean型：false
		 
		 >数组元素是引用数据类型时：null
		 */
		int[] ints=new int[3];
		for(int i=0;i<ints.length;i++)
		{
			System.out.println(ints[i]);
		}
		
		float[] ints1=new float[3];
		for(int i=0;i<ints1.length;i++)
		{
			System.out.println(ints1[i]);
		}
		
		char[] ints2=new char[3];
		for(int i=0;i<ints2.length;i++)
		{
			System.out.println("---"+ints2[i]);
		}
		
		boolean[] boolarr=new boolean[5];
		System.out.println(boolarr[0]);
		
		String[] strarr=new String[3];
		System.out.println(strarr[0]);
		
		//数组的内存解析
		
		
	}
}

接着是二维数组：

package com.zju.java;
/*
 * 
 * 二维数组的理解：
 * 从内存底层来看，二维数组是在堆区其中一个连续空间上的部分分别指向另一块连续空间
 * 
 * 二维数组的使用：
 * 二维数组的声明和初始化
 * 如何调用指定位置的元素
 * 获取数组的长度
 * 遍历数组元素
 * 数组元素默认初始化值
 * 数组的内存解析
 */
public class Arrtest1 
{

	public static void main(String[] args)
	{
		//二维数组的声明和初始化
		int[] arr=new int[] {1,2,3};//一维静态定义
		int[][] arr2=new int[][] {{1,2,3},{4,5},{7,9,5}};//二维静态
		int[] arr1=new int[3];//一维动态定义
		String[][] arr21=new String[2][3];//二维动态定义1
		String[][] arr22=new String[2][];//可以只明确定义第一个元素（行）
		//说明：从内存的角度分析，在堆空间开辟了第一段连续空间，有两个元素，这两个元素的指向还不明确
		
		//其他写法：
		String arr3[][]= new String[4][];
		//类型推断
		int arr4[][]=new int[5][];
		int arr41[][]= {{1,2,3},{2,4,6}};//省略写法
		
		
		arr22[1]=new String[3];
		//如何调用指定位置的元素，调用arr22这种定义时若：
		System.out.println(arr22[1][0]);
		//会报空指针错误(java.lang.NullPointerException)，第一段空间上的每个部分没有可指向的空间，需提前指明指向的空间
		
		
		
		//获取数组的长度
		System.out.println(arr2.length);//3
		System.out.println(arr2[1].length);//2
		System.err.println(arr2[2].length);//3
		
		
		//遍历数组元素
		for(int i=0;i<arr2.length;i++)
		{
			for(int j=0;j<arr2[i].length;j++)
			{
				System.out.print(arr2[i][j]+" ");
			}
			System.out.println();
		}
		
		//数组元素默认初始化值
		/*
		 * 对于二维数组规定：
		 * int[][] arr=new int[3][2];
		 * 
		 * 外层元素：arr[0]、arr[1]
		 * 内层元素：arr[0][0]、arr[0][1]
		 * 
		 */
		int[][] arr5=new int[3][2];
		System.out.println(arr5[0]);//输出地址 带一个[
		System.out.println(arr5[0][1]);//0
		
		
		float[][] arr6=new float[3][2];
		System.out.println(arr6[0]);//输出地址 带一个[
		System.out.println(arr6[0][1]);//0.0
		
		String[][] arr7=new String[3][2];
		System.out.println(arr7[0]);//输出地址 带一个[
		System.out.println(arr7[0][1]);//null
		
		System.out.println(arr6);//输出地址，带两个[[ 
		int arr8[][] =new int[5][];
		System.out.println(arr8[1]);//null 
		//由于在堆中只开辟了一段内存空间，而存放的是数组，为引用数据类型，所以返回null
//		System.out.println(arr8[1][0]);//空指针异常，索引失败
		
		/*
		 * 总结:
		 * 初始化方式一：int[][] arr=new int[3][4];
		 * 外层元素：arr[0]、arr[1]初始值为地址值，存放指向内层一维数组的地址
		 * 内层元素：arr[0][0]初始值与定义的数组类型相关
		 * 
		 * 初始化方式二：int[][] arr1=new int[3][];
		 * 外层元素：arr[0]、arr[1]初始值为null
		 * 内层元素：不可调用
		 */
	}
}