数组小结 (个人笔记)

1.什么是数组（容器）

主要是用于存储一组类型相同且连续的多个数据，数组中每个数据叫做数组的元素。

2.数组的定义（声明）和赋值（初始化）

	//数组的静态初始化   只能在定义时赋值，不能先定义后赋值
		int [] arr01= {1,1,2,3,5,8,13};
		int a=10;
	//动态初始化  	可以先定义然后在赋值
		int [] arr02=new int[] {1,1,2,3,5,8,13};
		//输出数组中的所有元素
	System.out.println(Arrays.toString(arr02));
	//定义数组时，只给定长度，不指定具体元素内容
	//将数组长度写在[]里边，不跟{}
	//不指定具体元素内容时，数组元素会有默认值。
		int [] arr03=new int[5];				//定义一个有范围的空数组
	//整数类型数组，元素默认为0；	
	//浮点类型类型输出的数组元素，默认为0.0
	//double类型输出的数组元素，默认为false
	//字符类型输出的数组元素，默认为\u0000======代表空格字符
	//字符串类型数组元素，默认为null  代表为空；
		//输出下下标为1位置字符
		System.out.println((int)arr01[1]);

4.数组的遍历

一维数组

1>通过数组元素的下标来遍历

	for(int i=0;i<arr.length;i++){

		arr[ i ];//数组元素

	}

2>for each迭代器

	//for each迭代器，增强for循环
		/*
		 * 冒号右侧为要遍历的数组 冒号左侧为数组中去取出的每个元素要赋值给哪个变量
		 */
		for(String a:arr) {
			System.out.println(a);
		}

5.数组的扩容

数组扩容

因为数组长度不可变 ，所以扩容实质上是创建了一个长度不同的新数组 ，然后将其内容复制到新的数组中。

1>带返回值

String[ ]=Arrays.copyOf（原数组，新数组长度）；

2>不带返回值

System.arraycopy(

                                //原数组 ​

                                //原数组开始赋值元素的下标 ​

                                //目标数组

​                                 //目标数组开始放元素的下标

                                ​ //从原数组复制几个元素到目标数组

)

/*
		 * 数组扩容 
		 * 因为数组长度不可变 
		 * 所以扩容实质上是创建了一个长度不同的新数组 
		 * 然后将其内容复制到新的数组中
		 */
		//创建一个新数组 在原来的基础上新添加俩个
		String[] newArr=new String[arr.length+2];	
		System.out.println(Arrays.toString(newArr));
		
		//将原来数组中元素赋值到新的数组中去
		for(int i=0;i<arr.length;i++) {
			newArr[i]=arr[i];
		}
//			newArr[5]="f";
//			newArr[6]="g";
			System.out.println(Arrays.toString(newArr));
	System.out.println("=================================");
		//	带返回值：
		//创建一个新数组，是原来的数组长度加2
		//将原数组中的所有的元素复制到新数组中，并往新数组的第0个下标位置开始放
		//1.
		arr=Arrays.copyOf(arr,arr.length+2);
		System.out.println("扩容后="+Arrays.toString(arr));
	
		//2.	
		String [] newArr1=Arrays.copyOf(arr,arr.length+2);
		System.out.println("扩容后="+Arrays.toString(newArr));
		
	System.out.println("=======================================");
	
	//不带返回值的：
	String [] newArr2=new String[arr.length+2];
	System.arraycopy(arr,		//原数组
					1,	 		//原数组开始赋值元素的下标
					newArr2, 	//目标数组
					2, 			//目标数组开始放元素的下标
					2);			//从原数组 复制几个 元素到目标数组
			System.out.println("扩容后="+Arrays.toString(newArr2));

6.二维数组

二维数组中的每个元素环视一个数组

1>静态初始化

int[] [] arr ={{1，1}，{2，2}}；

2>动态初始化

int [] [] arr=new int [] [] {{1，1}，{2，2}}；

3>只给定长度

···规则的：

int[] [] arr = new int [2] [3];

···不规则的：

int[] [] arr = new int[2] [];

arr[0]= new int[2];

arr[1]= new int[4];

String cities[][]= {{ "西安","宝鸡","榆林","咸阳"},
				 			{"长沙","成都","武汉","重庆" }};
		 	//二维数组动态初始化：
		 String cities01[][]=new String[][]{ {"拉萨","内蒙","桂林","丽江"},
			 							   {"云南","上海","德州","青岛"} };
			 		for(int i=0;i<cities.length;i++) {
			 			String[]cities1=cities01[i];
			 			System.out.println(Arrays.toString(cities1));
			 		}
			 		for(int i=0;i<cities01.length;i++) {
			 			String[]cities2=cities[i];
			 			System.out.println(Arrays.toString(cities2));
			 		}

//二维数组只给定长度
		//定义一个3行4列的二维数组
			String cities02[][]=new String[3][4];	
			for(int e=0;e<cities02.length;e++) {
			System.out.println(Arrays.toString(cities02[e]));
		}
			System.out.println("============================================");
		//定义不规则的二维数组：	只给定长度     先指定行数不指定列数
			String[][]aaa=new String[3][];
		//在定义每一行指定列数
			aaa[0]=new String[2];
			aaa[1]=new String[4];
			aaa[2]=new String[3];
			for(int a=0;a<aaa.length;a++) {
			System.out.println(Arrays.toString(aaa[a]));
			}

4>数组遍历输出：

二维数据

//遍历输出	
				for (int i = 0; i < cities.length; i++) {		//二维数组外层的长度循环一次
					for (int j = 0; j < cities[i].length; j++) {	//二维数组内层数组的长度再循环一次
						System.out.println(cities[i][j]);
					}
				}