第六章_数组

定义数组

数组（Array）标志是[ ] ;
用于储存多个相同类型数据的集合。
想要获取数组中的元素值，可以通过下标来获取，下标是从0开始的。

数组的创建方式有两种：

			动态初始化： int[] a = new int[5];
			
			静态初始化： int[] b = new int[]{1,2,3,4,5};
			
					    int[] c = {1,2,3,4,5};	

练习：向数组中存入hello
	public static void main(String[] args) {
		//1.创建数组
				//静态创建
				char [] c = new char[] {'h','e','l','l','o'};
				char [] c2= {'h','e','l','l','o'};
				//动态创建
				char [] c3= new char[5];
				c3[0]='h'; //给第一个元素赋值。
				c3[1]='e'; //给第二个元素赋值。
				c3[2]='l'; //给第三个元素赋值。
				c3[3]='l'; //给第四个元素赋值。
				c3[4]='o'; //给第五个元素赋值。
			System.out.println(c);
			System.out.println(c2);
			System.out.println(c3);
			System.out.println(c.length);	length属性，用来打印数组的长度。
	}		

遍历数组–也可以叫数组的循环

.length属性–打印数组的长度
数组一旦创建，长度不可变
允许0长度的数组

数组的遍历------其实就是一个循环体

for(1.从下标为0的位置开始2.下标的取值<数组的长度3.下标++){
 							循环体;
		}

  练习1：输出每个月的天数
	   //1.创建数组
	   int[]a= {31,29,31,30,31,30,31,31,30,31,30,31};
	   //数组的遍历------------------------------也可以叫数组的循环
	   for (int i = 0; i < a.length; i++) {
		System.out.println((i+1)+"月有"+a[i]+"天");a[i]指根据下标i获取a数组中元素的值
 
练习2. 遍历数组，存入1到10
		//1.创建数组  动态
	  int[] a =new int[10];
	  for (int i = 0; i < a.length; i++) {	//2. 遍历数组 给元素赋值
		a[i]=i+1;
 * int i =0,是指下标为0的位置开始
 * i < a.length 是指下标最大值小于数组的长度
 *i+1给每个元素赋值，i取值是0——9，+1后是1——10.	 
 		 System.out.println(a);//[I@2ff4acd0  打印数组得到的是一个地址值，数组虽然被赋值，但直接打印并不能查看其内容 
	 	 //Arrays是数组的工具类，toString(m)----m是要把哪个数组的元素显示成一个字符串
	  	System.out.println(Arrays.toString(a));//赋值之后要想查看其元素，除了char类型，其他都需要使用Arrays工具类来实现

冒泡排序

冒泡排序：bubble sort是一种计算机科学领域的较简单的排序算法。

形式:

  		相邻位置比较，从小到大排序，如果小就往前换。

冒泡排序需要两层循环来实现：
第一层循环：控制比较的轮数，如果是5个数据，需要比较4次（5—1）
第二层循环：相邻比较 +交换顺序

	public static void main(String[] args) {
		//冒泡排序的代码实现：
		//1.创建一个无序数组
		int [] a = new int [10];
		for (int i = 0; i < a.length; i++) {
			a[i]=new Random().nextInt(100);
		}
		//2.调用method()排序
		int[] b =method(a);
		System.out.println(Arrays.toString(b));
	}
	//创建method()完成排序
	public static int[] method(int[] a) {
		//1.外循环控制比较轮数，假设N个数，需要比较N-1次
		for (int i = 0; i <a.length-1; i++) {
			//2.内循环：相邻比较，交换位置
			for (int j = 0; j < a.length-1; j++) {
				//相邻比较,a[j]代表前一个元素，a[j+1]代表后一个元素
				if (a[j]>a[j+1]) {
					//交换位置--首尾相连
					int t=a[j];
					a[j]=a[j+1];
					a[j+1]=t;
				}	
			return a;

数组的工具类使用

数组工具类Arrays
  1.Arrays.toString(数组名)--需要查看数组里的元素时使用

		把数组里的数据，用逗号连接成一个字符串。[值1，值2，值3]
  		System.out.println(Arrays.toString(a));

  2.Arrays.sort(数组)---需要给数组排序时使用
  		对数组排序，从小到大排序。
  		对基本类型，使用快速排序算法，效率高。
  	 	对引用类型，使用合并排序算法。
  			int[] a = new int[]{21,25,98,64,71};
  			Arrays.sort(a);
 				System.out.println(Arrays.toString(a)); 

 	3.Arrays.copyOf(要复制的数组名，新的长度)---需要复制一个新数组时使用
  		把数组复制成一个 指定长度的新数组
  		新数组长度大于原数组，相当于复制并增加位置扩容
  			新数组长度小于原数组，相当于截取前一部分数据缩容
		int [] a= {1,2,3,4,5,6};
		要取一个新数组名，，因为数组一旦创建长度不可变，所以复制完产生的是一个新数组 

		int [] b1=Arrays.copyOf(a, 10);
		int [] b2=Arrays.copyOf(a, 3);

		System.out.println(Arrays.toString(b));//[1, 2, 3, 4, 5, 6, 0, 0, 0, 0]---扩容
		System.out.println(Arrays.toString(b2));//[1, 2, 3]---缩容
		

二维数组

	存放数组的数组--数组里存的还是数组的数据形式。

 二维数组的形式： 
     1.创建二维数组
         int [] [] a = new int[3][3];         
         int [] [] a = {{1,5,6},{7,5,8},{2,4,6}};   
       
 			2.遍历二维数组
		 	for (int i = 0; i < a.length; i++) {	
				for (int j = 0; j <a[i].length; j++) {
				}
}
		
案例：
	int [] [] a = {{1,5,6},{7,5,8},{2,4,6}};
	for (int i = 0; i < a.length; i++) {//遍历外围数组
		for (int j = 0; j <a[i].length; j++) {//遍历内围数组
				System.out.println(a[i][j]);
			}
		}

变量的扩展

变量的全面认识

概念：
 			可以改变的数，称为变量。
 			一般通过三部分来描述变量。变量类型 变量名 变量值
 			使用原则：就近原则   尽量控制在最小范围


 局部变量：
 		定义在方法里，或者局部代码块中
 		注意：必须手动初始化，来分配内存。
 		作用域也是在方法里或局部代码块里，方法运行完内存就释放了。
 

 成员变量
 			定义在类里，方法外
  		注意：不用初始化，也会自动初始化成默认值
  		作用域是在整个类中，类消失了，变量才释放


 八大基本类型的默认值：	
 			byte-----0
 			short----0
 			int------0
  			long-----0L
  			float----0.0F
  			double---0.0d
 			char-----\u0000 
 			boolean--false
 			String---null`在这里插入代码片`