Java基础（二）——循环、数组

一、循环

for、while、do-while、foreach

循环四要素：

• 初始化循环变量
• 循环条件
• 循环体
• 更新循环变量

1、while循环

初始化循环变量
while(循环条件){
	循环体
	更新循环变量
}

//初始化循环变量
int num = 0;
//循环条件
while(num < 10) {
  //循环体
  System.out.println("Hello World");
  //更新循环变量
  num++;
}

String flag = "y";
	//字符串比较要调用equals方法
	while(flag.equals("y")) {
        System.out.println("请输入学生学号：");
      //创建一个Scanner类型的变量scanner
      //让程序接收用户输入的事件
        Scanner scanner = new Scanner(System.in);
        //整型变量调用scanner的nextInt方法
        int id = scanner.nextInt();
        System.out.println("用户输入的学号为："+id);
	    switch(id) {
	    case 1:
	    	System.out.println("张三的成绩是96");
	    	break;
	    case 2:
	    	System.out.println("李四的成绩是91");
	    	break;
	    case 3:
	    	System.out.println("王五的成绩是89");
	    	break;
	    default:
	    	System.out.println("请输入正确的学号");
	    	break;
	    }
	    System.out.println("是否继续？y/n");
	    //字符串要调用next方法
	    flag = scanner.next();
	   // i++;
	}
	System.out.println("感谢使用学生成绩查询系统");

2、do-while循环

//初始化循环变量
int num = 0;
do {
  //循环体
  System.out.println("Hello World");
  //更新循环变量
  num++;
}while(num<10);
//循环条件

    String flag = "y";
	do {
		System.out.println("请输入学生学号：");
		//创建一个Scanner类型的变量scanner
       //让程序接收用户输入的事件
		Scanner scanner = new Scanner(System.in);
		//整型调用scanner的nextInt方法
		int id = scanner.nextInt();
		System.out.println("用户输入的学号为：");
		switch(id) {
		case 1:
	    	System.out.println("张三的成绩是96");
	    	break;
	    case 2:
	    	System.out.println("李四的成绩是91");
	    	break;
	    case 3:
	    	System.out.println("王五的成绩是89");
	    	break;
	    default:
	    	System.out.println("请输入正确的学号");
	    	break;
	    }
	    System.out.println("是否继续？y/n");
	    //字符串要调用next方法
	    flag = scanner.next();
	}while(flag.equals("y")); //字符串比较要调用equals方法
	System.out.println("感谢使用学生成绩查询系统");

Scanner scanner = new Scanner(System.in);
String result = "";
do {
  System.out.println("张三参加体能测试，跑1000米");
  System.out.print("是否合格？y/n");
  result = scanner.next();
}while(result.equals("n"));
System.out.println("合格，通过测试");

3、for循环

for(初始化循环变量;循环条件;更新循环变量){
		循环体
}

for(int num = 0;num < 10;num++) {
  System.out.println("Hello World");
}

4、while、do-while、for 3种循环的区别

• 相同点：都遵循循环四要素，初始化循环变量、循环条件、循环体、更新循环变量。
• 不同点：
  • while 和 do-while 适用于循环次数不确定的业务场景；for 适用于循环次数确定的场景。
  • while 和 for 都是先判断循环条件，再执行循环体；do-while 先执行循环体，再判断循环条件。

比如分别使用 while、do-while、for 循环输出 10 以内的所有奇数。

//while循环
int num = 0;
while(num <= 10) {
  if(num%2!=0) {
    System.out.println(num);
  }
  num++;
}
//do-while循环
int num = 0;
do {
  if(num%2!=0) {
    System.out.println(num);
  }
  num++;
}while(num <= 10);
//for循环
for(int num = 0;num <= 10;num++) {
  if(num%2!=0) {
    System.out.println(num);
  }
}

for 循环只适用于循环次数确定的场景下(for 也可以适用于循环次数不确定的场景，只不过一般不会用这种方式进行开发)，while 和 do-while 循环次数确定或者不确定都可以使用。

        Scanner scanner = new Scanner(System.in);
		String result = "n";
		for(;result.equals("n");) {
			System.out.println("张三参加体能测试，跑1000米");
			System.out.println("是否合格？y/n");
			result = scanner.next();
		}
		System.out.println("合格，通过测试");

二、数组

数组就是一种可以存储大量数据类型相同的变量的数据结构，数组就是一个具有相同数据类型的数据集合。数组中的数据必须是同一种数据类型的。

1、 数组的基本要素

• 数组名称
• 数组元素
• 元素下标
• 数据类型

数组本身就是一个变量，所以数组名称就是变量名，数组中保存的每一个数据都会有一个下标（注意是从 0 开始）
【从0开始快速找到变量地址，可以最大程度的提高检索速度，提升计算机运算效率，从1开始也可以，但是多一些运算。】

2、创建数组：

        //先声明后赋值
        //声明int类型数组
		int [] array;
		//声明String类型数组
		String [] array2;
	    //分配内存空间
		array = new int[6];
		//给数组赋值
		array[0] = 1;
		array[1] = 2;
		array[2] = 3;
		array[3] = 4;
		array[4] = 5;
		array[5] = 6;
		
		//调用Arrays的toString方法，把某一个东西转换成字符串
		String str = Arrays.toString(array);
		//Arrays工具类，Java专门用来操作数组的工具类
		System.out.println(str);
		System.out.println("输出数组中的第三个元素："+array[2]);

输出结果为：
[1, 2, 3, 4, 5, 6]
输出数组中的第三个元素：3

eg：计算几个人身高的平均数：

        int[] array = new int[4];
		array[0] = 179;
		array[1] = 182;
		array[2] = 167;
		array[3] = 176;
		int sum = 0;
		for(int i=0;i<array.length;i++) {
			//System.out.println(array[i]);
			sum = sum + array[i];
		}
		System.out.println(sum/array.length);

输出结果为176，因为sum是一个整型，array.length也是一个整型。如果将sum类型定义为duble的话输出结果为小数

        //边声明边赋值两种方式
		int[] array1 = {1,2,3,4,5,6};
	    int[] array2 = new int[]{1,2,3,4,5,6};

3、 数组中常见的错误

• 数据类型不匹配。
• 边声明边赋值的方式，代码必须写在同一行，不能换行。
• 数组下标越界（最常见，容易抛出异常）。

4、 数组的常用操作及方法

• （1）求数组的最大值
• （2）求数组的最小值

        //1、求数组中最大值
		int[] array = {73,80,62,93,96,87};
		int max = array[0];
		for(int i=0;i<array.length;i++) {
			if(array[i] > max) {
				max = array[i];
			}
		}
		System.out.println("数组最大值是："+max);
		
		//2、求数组中最小值
		int min = array[0];
		for(int i=1;i<array.length;i++) {
			if(array[i] < min) {
				min = array[i];
			}
		}
		System.out.println("数组最小值是："+min);

输出结果为：
数组最大值是：96
数组最小值是：62

• （3）在数组的指定位置插入数据

         //3、在数组指定位置插入数据
		//将83插入到数组下标为3的位置
		int[] array1 = {96,93,87,80,73,62};
		int num = 83;
		System.out.println("添加新元素之前的数组是："+Arrays.toString(array1));
	    //创建一个长度比原数组大1的新数组
		int[] array2 = new int[array1.length+1];
		//将原数组中的数据移动到新数组中
		//移动下标3之前的数组
		for(int i=0;i<3;i++) {
			array2[i]= array1[i];
		}
	    //移动下标3之后的数组
		for(int i=4;i<array2.length;i++) {
			array2[i] = array1[i-1];
		}
		array2[3] = 83;
		System.out.println("添加新元素之后的数组是："+Arrays.toString(array2));

输出结果为：
添加新元素之前的数组是：[96, 93, 87, 80, 73, 62]
添加新元素之后的数组是：[96, 93, 87, 83, 80, 73, 62]

• （4）对数组进行排序

       //4、对数组进行排序
	   //冒泡排序算法
	   //升序排序
	   int[] array3 = {73,80,60,93,96,87};
	   System.out.println("排序之前的数组为："+Arrays.toString(array3));
	   for(int i =0;i<array3.length-1;i++){
		   if(array3[i] > array3[i+1]) {
			   int temp = array3[i];
			   array3[i] = array3[i+1];
			   array3[i+1] = temp;
		   }
	   }
	   System.out.println("第一次排序后的数组为："+Arrays.toString(array3));
	   
	   for(int i=0;i<array3.length-2;i++) {
		   if(array3[i] > array3[i+1]) {
			   int temp = array3[i];
			   array3[i] = array3[i+1];
			   array3[i+1] = temp;
		   }
	   }
	   System.out.println("第二次排序后的数组为："+Arrays.toString(array3));
	   
	   for(int i=0;i<array3.length-3;i++) {
		   if(array3[i] > array3[i+1]) {
			   int temp = array3[i];
			   array3[i] = array3[i+1];
			   array3[i+1] = temp;
		   }
	   }
	   System.out.println("第三次排序后的数组为："+Arrays.toString(array3));

输出结果为：
排序之前的数组为：[73, 80, 60, 93, 96, 87]
第一次排序后的数组为：[73, 60, 80, 93, 87, 96]
第二次排序后的数组为：[60, 73, 80, 87, 93, 96]
第三次排序后的数组为：[60, 73, 80, 87, 93, 96]

对上述算法优化：

        int[] array3 = {73,80,60,93,96,87};
		System.out.println("排序之前的数组为："+Arrays.toString(array3));
		for(int j=0;j<array3.length-1;j++) {
			for(int i=0;i<array3.length-1-j;i++) {
				if(array3[i] > array3[i+1]) {
					   int temp = array3[i];
					   array3[i] = array3[i+1];
					   array3[i+1] = temp;
			}
		}
	  }
	  System.out.println("排序之后的数组为："+Arrays.toString(array3));

输出结果为：
排序之前的数组为：[73, 80, 60, 93, 96, 87]
排序之后的数组为：[60, 73, 80, 87, 93, 96]

• （5）一些小tips：Arrays的一些常用方法：toString，sort，fill，copyof，binarySearch

toString方法： 是把某一个东西转换成字符串
equals方法： 判断两个数组是否相等
sort：排序方法
fill：填充方法,会把原来的值覆盖掉，要慎重使用
copyArray：复制方法,长度超过的填充0，不够的话截取原数组前几位
binarySearch：二分查找方法，数组必须是有序的，否则会出现问题

        int[] array = {73,80,62,93,87};
		int[] array1 = {73,80,62,93,87};
		int[] array2 = {66,55,44,33,22};
		//判断两个数组是否相等
	    System.out.println(Arrays.equals(array,array1));
	    System.out.println(Arrays.equals(array,array2));
	    //Arrays的sort排序方法
	    Arrays.sort(array);
	    System.out.println(Arrays.toString(array));
	    //fill填充方法,会把原来的值覆盖掉，要慎重使用
	    Arrays.fill(array, 66);
	    System.out.println(Arrays.toString(array));
	    //copyArray复制方法,长度超过的填充0，不够的话截取原数组前几位
	    int[] copyArray = Arrays.copyOf(array2,7);
	    System.out.println(Arrays.toString(copyArray));
	    //binarySearch二分查找方法，数组必须是有序的，否则会出现问题
	    int index = Arrays.binarySearch(array, 187);
	    System.out.println(index);

输出结果为：
true
false
[62, 73, 80, 87, 93]
[66, 66, 66, 66, 66]
[66, 55, 44, 33, 22, 0, 0]
-6
输出为负数表示数组中不存在查找的值或者数组是无序的，所以调用binarySearch方法时一定要先排序，否则会出现问题。

5、 二维数组

二维数组简单理解即一维数组中保存的值是另外一个一维数组。
二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，二维数组又称为矩阵，行列数相等的矩阵称为方阵。对称矩阵a[i][j] = a[j][i]，对角矩阵：n阶方阵主对角线外都是零元素。

        //声明
		int[][] array;
		//开辟内存空间
		array = new int[2][3];
		//赋值
//		array[0][0] = 50;
//	    array[0][1] = 60;
//		array[0][2] = 70;
//		array[1][0] = 80;
//		array[1][1] = 90;
//		array[1][2] = 100;
//		System.out.println(Arrays.toString(array));
	    
		
//		int[] item = {50,60,70};
//		int[] item1 = {80,90,100};
//		array[0] = item;
//		array[1] = item1;
//		System.out.println(Arrays.toString(array));
	    
		int[][] array2 ={{50,60,70},{80,90,100,200}};
		String str = "";
		System.out.println(array2.length);
		for(int i=0;i<array2.length;i++) {
			//array2.length是2
			//str += Arrays.toString(array2[i]);
		    //双层循环将数组中的值一个一个输出
			for(int j=0;j<array2[i].length;j++){
		    	System.out.println(array2[i][j]);
		    }		
		}
		System.out.println(str);

输出结果为：
2
50
60
70
80
90
100
200

二维数组的简单应用

        //二维数组的简单应用
		//三层货柜，每层货柜有6个格挡。计算鸡蛋的总数
		int[][] array = new int[3][6];
		int sum = 0;
		for(int i=0;i<array.length;i++) {
			System.out.println("-----第"+(i+1)+"层货架-----");
            for(int j=0;j<array[i].length;j++) {
            	int num = (i+1)*(j+1);
            	sum +=num;
            	System.out.println("第"+(j+1)+"个格挡的鸡蛋个数："+num);
            }
		}
		System.out.println("鸡蛋的总数是："+sum);

输出结果：
-----第1层货架-----
第1个格挡的鸡蛋个数：1
第2个格挡的鸡蛋个数：2
第3个格挡的鸡蛋个数：3
第4个格挡的鸡蛋个数：4
第5个格挡的鸡蛋个数：5
第6个格挡的鸡蛋个数：6
-----第2层货架-----
第1个格挡的鸡蛋个数：2
第2个格挡的鸡蛋个数：4
第3个格挡的鸡蛋个数：6
第4个格挡的鸡蛋个数：8
第5个格挡的鸡蛋个数：10
第6个格挡的鸡蛋个数：12
-----第3层货架-----
第1个格挡的鸡蛋个数：3
第2个格挡的鸡蛋个数：6
第3个格挡的鸡蛋个数：9
第4个格挡的鸡蛋个数：12
第5个格挡的鸡蛋个数：15
第6个格挡的鸡蛋个数：18
鸡蛋的总数是：126