java入门day 05

1、数组
/**

1、数组是什么？为什么需要使用数组

	 * 比如我要统计每位员工的工资，我得定义多个变量去
	 * 分开存储，如果过多员工，就太麻烦了。
	 * 
	 * 那么我怎么用一个变量来存储多个员工的工资呢？
	 * 可以使用数组，数组就是一个大的容器，它可以存放多个值

2、什么是数组？

	 * 数组和变量差不多，都是存放数据的，不同的是变量只能
	 * 保存一条数据，而数组可以保存多条数据，前提是这多条数据必须是
	 * 同一类型的
	 * 数组是引用数据类型

3、如何定义数组？

	 * 数组类型[] 数组名;
	 * 如果定义好数组以后，必须给数组进行初始化。
	 * 数组初始化分为两种情况：
	 * (1)动态初始化：指定数组的长度。弊端是：一旦长度指定，就是数组中只能存放多少数据
	 * 第一种：
	 * 数组类型[] 数组名=new 数组类型[数组长度];
	 * 第二种：
	 * 数组类型[] 数组名;
	 * 数组名=new 数组类型[数组长度];
	 * (2)静态初始化：不是指定数组长度，而是直接在初始化时给数组进行赋值
	 * 第一种：
	 * 数组类型[] 数组名=new 数组类型[]{数据1，数据2，数据3...};
	 * 第二种：
	 * 数组类型[] 数组名;
	 * 数组名=new 数组类型[]{数据1，数据2，...};
	 * (3)最简单的一种方式
	 * 数组类型[] 数组名={数据1，数据2，...};
	 * 
	 */

参考代码：

		//1、定义了一个数组，并进行动态初始化第一种
		/**
		 * int：数组类型是int类型的，也说明了这个数组， 只能存放整数，
		 * 而且只能存放9个整数
		 * array：数组名
		 */
		int [] array=new int [9];
		
		//2、动态初始化的第二种
		double [] array1;
		array1=new double[10];
		
		//创建好了数组，如何给数组进行赋值？通过数组的下标进行赋值，数组的下标从0开始
		array[0]=10;//给数组的第一个元素进行赋值
		array[1]=11;
		//array[8]="aaa";  因为定义的数组是int型的
		//array[9]=20;数组下标越界了
		
		//3、静态初始化的第一种
		int []array2=new int[] {8,9,19,45};
		System.out.println(array2[3]);//45
		
		//4、静态初始化的第二种
		int [] array3;
		array3=new int[] {67,89,1,33};
		System.out.println(array3[0]);//67
		
		//5、最简洁的方式创建数组
		int [] array4= {12,3,2,5,6};
		System.out.println(array4[0]);//12
		
		//6、如果我想获取数组的长度，怎么办呢？数组名.lenght
		System.out.println("array4的长度:"+array4.length);
		
		

4、数组最常见的异常：

	//7、数组中最常见的几种异常
		int [] a=new int [3];
	//	System.out.println(a[3]=6);java.lang.ArrayIndexOutOfBoundsException数组下标越界异常
		int [] b=null;
	//	System.out.println(b[0]);java.lang.NullPointerException空指针异常

5、遍历数组

		int [] array=new int[] {12,4,6,34,90,89};
		//我想获取数组的每一个元素的值
		
		//for循环,i代表数组的下标
		System.out.println("使用for循环遍历数组");
		for(int i=0;i<array.length;i++) {
			System.out.println(array[i]);
		}
		
		//foreach（for循环的增强版）
		System.out.println("使用foreach循环遍历数组");
		/**
		 * for(定义变量接受数组的每一个元素值:要遍历的数组名)
		 * 
		 * 数组遍历只有这两种方式
		 */
		for(int a:array) {
			System.out.println(a);
		}

6、数组分类
/**
* 数组分类
* 1、基本数据类型的数组
* 动态初始化数组以后，数组的元素都会赋予一个默认的值
* byte short int long float double char boolean
* 0 0 0 0 0.0 0.0 空格 false
* 2、引用数据类型的数组
* String 接口 自己定义的类
* 引用数据类型的默认值为null
*/
参考代码：

		//int类型的数组
		int []num=new int[5];
		num[0]=10;
		num[3]=12;
		for(int n:num) {
			System.out.println(n);
		}
		System.out.println("============");
		//double类型
		double []d=new double[5];
		System.out.println(d[0]);//0.0
		System.out.println("============");
		//char类型
		char []c=new char[6];
		System.out.println("-"+c[0]+"-");//空格
		System.out.println("============");
		//布尔类型
		boolean [] b=new boolean[3];
		System.out.println(b[0]);
		System.out.println("============");
		//String
		String [] str=new String[5];
		str[0]="张三";
		for(String s:str) {
			System.out.println(s);//null
		}

7、数组里的数据为什么会有默认值呢？
/**
* java中的内存是怎么进行分配的？
* 内存的申请和释放都是jvm进行管理的，java程序要运行，jvm
* 会自动的向电脑申请一块内存。
* 把这块内存分为5部分:
* 1、栈(Stack):主要存放局部变量
* 2、堆(Heap):凡是new出来的东西都在堆里卖弄，堆
* 当中的数据都有默认原则
* 3、方法区(Method Area):存放的是与.class相关的信息
* 4、本地方法区(Native Method Area):与操作系统有关
* 5、寄存器(Register):与cpu有关
*/

8、其他参考题目:

	/**
		 * 1、求出学生成绩的总分、平均分、最高分、最低分
		 * 
		 */
		double [] score=new double [] {90,89,56,87};
		//求总分
		double sum=0;
		double max=score[0],min=score[0];
		
		for(int i=0;i<score.length;i++) {
			if(score[i]>max) {
				max=score[i];
				
			}
			if(score[i]<min) {
				min=score[i];
				
			}
			sum+=score[i];
		}
		System.out.println("总分："+sum);
		//求平均分
		double avg=sum/score.length;
		System.out.println("平均分为："+avg);	
		System.out.println("最高分为:"+max);
		System.out.println("最低分为："+min);
	
		

	/**
		 * 2、将{"C语言"，"C++","C#","Java","Python"};
		 * 逆序输出。
		 */
		
		String [] str=new String[] {"C语言","C++","C#","Java","Python"};
/**		for(int i=0;i<str.length;i++) {
			String temp=str[i];
			str[i]=str[str.length-1-i];
			str[str.length-1-i]=temp;
			System.out.println(str[i]);
		}
		//这段注释掉的代码时错误的
*/
		
		
		for(int i=0;i<str.length/2;i++) {
			String temp=str[i];
			str[i]=str[str.length-1-i];
			str[str.length-1-i]=temp;
			
			}
		for(String s:str) {
			System.out.print(s+"\t");
		}
		System.out.println();
//		System.out.println("================");
//		
//		for(int i=str.length-1;i>=0;i--) {
//			System.out.print(str[i]+"\t");
//		}   
//上面注释的代码是可以与上面的互替的
		
		

8、冒泡排序
/**
* 冒泡排序
* 核心思想:
* 数组中的元素两两比较
* 如:10 20 30 40 50 60
*
* 第一趟：比较了5次
* 20 30 40 50 60 10
* 第二趟：比较了4次
* 30 40 50 60 20 10
* 第三趟 :比较了3次
* 40 50 60 30 20 10
* 第四趟：比较了两次
* 50 60 40 30 20 10
* 第五趟:比较了一次
* 60 50 40 30 20 10
*
* 总结规律：
* 6个数比较5趟
* n个数比较n-1趟
*
* 次数：n个数-第几趟数
*/
参考代码：

		int [] num=new int[] {3,8,1,5,2,9};
		//从大到小排列
		//外层循环控制趟数
		for(int i=0;i<num.length-1;i++) {
			//内层循环控制次数
			for(int j=0;j<num.length-(i+1);j++) {
			//比较  从大到小用<   从小到大用>
				if(num[j]<num[j+1]) {
					int temp=num[j];
					num[j]=num[j+1];
					num[j+1]=temp;
				}
			}
			
			}
		for(int num1:num) {
			System.out.print(num1+"\t");
		}