数组

数组

• 概念：数组可以看成是多个相同类型数据的组合，实现对这些数据的统一管理

• 数组就是容器：存放同一类型数据，可以是基本数据类型也可以是引用数据类型

• 数组的创建：

  //数组的声明
  		int[] arr1;
  		int arr2[];
  		
  		//数组的赋值  5:数组元素个数
  		arr1=new int[5];
  		arr2= new int[]{1,2,3};//数组元素个数3个
  		
  		//数组的创建：声明的同时并且完成初始化
  		int[] arr3= {2,3,4,5}; //静态初始化
  		int[] arr4=new int[]{1,2,3};//动态初始化
  

• 数组的特点

/**
 * 特点：
 * 	①数组是定长的，一旦数组被创建其元素的个数就是固定的
 *  ②数组是引用数据类型，其数据存放在堆区
 *  ③数组是有序有索引的，其最大索引为length-1，0表示数组第一个元素,访问数组时下标不能超过其索引
 *  ④数组在创建时如果没有赋值自定义的值，数组会有默认值，
 *  	默认值与数组的类型相关:引用数据类型默认为null,double默认为0.0,int默认为0，char 默认为0对应的字符

 *  ⑤数组的数据类型：可以是基本数据类型也可以是引用数据类型:数组元素的数据类型必须和数组的类型一致
 *  总结：数组是定长、有序的
 * 
 * @author Administrator
 *
 */
public class _数组的特点 {

	public static void main(String[] args) {
		/**
		 * int:数组的数据类型
		 * arr1：变量名
		 * 1,2,3,4：数组的元素
		 * 	元素的个数就是数组的长度length
		 */
		int[] arr1=new int[] {1,2,3,4};
		System.out.println(arr1.length);//4
		int[] arr2=new int[3];
		//数组的访问：
		System.out.println(arr1[0]);//1   0表示数组第一个元素  
//		System.out.println(arr1[4]);//java.lang.ArrayIndexOutOfBoundsException: 4
		System.out.println(arr2[0]);//0
		System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]
		System.out.println(Arrays.toString(arr2));//[0, 0, 0]
		
		//数组的数据类型：可以是基本数据类型也可以是引用数据类型
//		double[] darr1= {"zhangsan","lisi"};数组元素的数据类型必须和数组的类型一致
		double[] darr1= {123,4,1234.56};
		String[] sarr1= new String[]{"zhangsan","lisi","wangwu","zhaoliu"};
		String[] sarr2= {"zhangsan","lisi","wangwu","zhaoliu"};
		String[] sarr3=new String[3];
		System.out.println(Arrays.toString(sarr3));//[null, null, null]
		char[] carr1=new char[3];
		System.out.println(Arrays.toString(carr1));//[ , , ]
	}

• 数组的内存

	public static void main(String[] args) {
		//数组的数据存在堆区，其引用存在栈区
		int[] arr1=new int[3];//arr1是引用
		System.out.println(arr1);//[I@7852e922
		System.out.println(arr1[0]);//@7852e922
		
		//因为数组是定长的，所以不能对其进行增加和删除元素操作，只能对其元素进行修改
		arr1[0]=23;
		System.out.println(Arrays.toString(arr1));//[23, 0, 0]
		
		int[] arr2= new int[]{1,2,3,4};
		arr2[3]=78;
		System.out.println(Arrays.toString(arr2));//[1, 2, 3, 78]
		
		int[] arr3= {1,2,3};
		

• 数组的优缺点：

  • 数据结构：数组,逻辑上连续的两个元素，物理地址也连续

  • 优点：访问速度快

  • 缺点：定长，不能扩容，当你不确定存放数据的数量时很难去确定数组的长度，所以有可能定义数组存放数据时出行内存占用过度或不足的情况

• 数组的遍历和数组的传递

public static void main(String[] args) {
		//数组的遍历
		int[] arr1= {1,2,3,4,95,45,12};
//		方式1：for循环:较快
		for(int i=0;i<arr1.length;i++) {
			System.out.println(arr1[i]);
		}
		System.out.println("---------------------------------------------");
//		方式2：foreach循环
		/**
		 * 语法：
		 *  for(数组元素的数据类型 元素：数组对象){
		 *  	语句
		 *  }
		 * 
		 */
		for(int i:arr1) {
			System.out.println(i);
		}
		
		System.out.println(arr1);//[I@7852e922
		//数组的传递
		int[] arr2=arr1;
		System.out.println(arr2);//[I@7852e922
		System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4, 95, 45, 12]
		arr2[0]=78;
		System.out.println(Arrays.toString(arr2));//[78, 2, 3, 4, 95, 45, 12]
		System.out.println(Arrays.toString(arr1));//[78, 2, 3, 4, 95, 45, 12]
	}

• 二维数组的创建

	
		int[] i1=new int[3];
		
		//二维数组的声明
		int[][] arrs1;
		int[] arrs2[];
		int arrs3[][];
		
		//创建二维数组
		int[][] is=new int[3][];
		System.out.println(Arrays.toString(is));//[null, null, null]
		int[][] is1={{123},{23},{231}};
		System.out.println(Arrays.toString(is1));//[[I@7852e922, [I@4e25154f, [I@70dea4e]
		/**
		 * int[][] is2=new int[n][m]
		 * n表示的是二维数组的元素个数，m表示的是一维数组的元素个数
		 */
		int[][] is2=new int[3][4];//创建了三行四列的二维数组

• 二维数组的使用和内存

public class _二维数组的内存和使用 {
	public static void main(String[] args) {
		int[][] arr1= {{1,2,3},{12,13},{56,57}};
		//arr1[0]是一个一维数组
		System.out.println(arr1[0]);//@7852e922
		System.out.println(Arrays.toString(arr1[0]));//[1, 2, 3]
		
		//遍历二维数组:访问每一个数组
		//arr1.length 二维数组的数组长度
		/**
		 * [1, 2, 3]
			[12, 13]
		[56, 57]
		 */
		for(int i=0;i<arr1.length;i++) {
			System.out.println(Arrays.toString(arr1[i]));
		}
		//遍历二维数组:访问每一个数组中的每一个元素
		System.out.println(arr1[0][0]);//1
		System.out.println(arr1[2][1]);//57
		for(int i=0;i<arr1.length;i++) {
			for(int j=0;j<arr1[i].length;j++) {
				System.out.println(arr1[i][j]);
			}
		}
//		需求：定义一个三行三列的二维数组，赋值形式如下：
//		1 2 3
//		4 5 6 
//		7 8 9
		int num=1;
		int[][] arr2=new int[3][3];
		for(int i=0;i<arr2.length;i++) {
			for(int j=0;j<arr2[i].length;j++) {
			arr2[i][j]= num;
			num++;
		 }
		}
		for(int[] i:arr2) {
			System.out.println(Arrays.toString(i));
		}
	}

• 冒泡排序

	public static void main(String[] args) {
		使用冒泡排序将数组{12,1,2,56,7,8}升序排序
//		int[] arr= {12,1,2,56,7,8};
//		for(int j=0;j<arr.length-1;j++) {//只比较5次
//			//如果前一个数比后一个数大交换位置
//			if(arr[j+1]<arr[j]) {
//				int temp=arr[j];
//				arr[j]=arr[j+1];
//				arr[j+1]=temp;
//			}
//		}
//		System.out.println(Arrays.toString(arr));//[1, 2, 12, 7, 8, 56]
		System.out.println("--------------------------------------");
		int[] arr= {12,11,10,9,8,7};
		//循环length-1次即可
	/*	for(int i=0;i<arr.length-1;i++) {//循环的次数
			for(int j=0;j<arr.length-1;j++) {//只比较5次
				//如果前一个数比后一个数大交换位置
				if(arr[j+1]<arr[j]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
			System.out.println("第"+(i+1)+"次"+Arrays.toString(arr));
		}
		System.out.println("排序后的结果："+Arrays.toString(arr));
		*/
		
		//优化冒泡排序
		for(int i=1;i<arr.length;i++) {//循环的次数
			for(int j=0;j<arr.length-i;j++) {
				//如果前一个数比后一个数大交换位置
				if(arr[j+1]<arr[j]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
			System.out.println("第"+i+"次"+Arrays.toString(arr));
		}
		System.out.println("排序后的结果："+Arrays.toString(arr));
//		降序排序 [7, 8, 9, 10, 11, 12]
		int[] arr1= {7, 8, 9, 10, 11, 12};
		for(int i=1;i<arr1.length;i++) {//循环的次数
			for(int j=0;j<arr1.length-i;j++) {
				//如果前一个数比后一个数小交换位置
				if(arr1[j+1]>arr1[j]) {
					int temp=arr1[j];
					arr1[j]=arr1[j+1];
					arr1[j+1]=temp;
				}
			}
			System.out.println("第"+i+"次"+Arrays.toString(arr1));
		}
		System.out.println("排序后的结果："+Arrays.toString(arr1));//[12, 11, 10, 9, 8, 7]
		
	}
	

位置
if(arr1[j+1]>arr1[j]) {
int temp=arr1[j];
arr1[j]=arr1[j+1];
arr1[j+1]=temp;
}
}
System.out.println(“第”+i+“次”+Arrays.toString(arr1));
}
System.out.println(“排序后的结果：”+Arrays.toString(arr1));//[12, 11, 10, 9, 8, 7]

}