循环结构、数组

一、break与continue

1.

break: 直接结束当前循环,跳出循环体

break以后的循环体中的语句不会继续执行,循环体外的会执行
注意如果是嵌套for循环,在内层循环遇到了break,只会跳出当前这一层内循环

continue: 跳出本轮循环,继续下一轮循环

continue后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行

2.练习：测试Break与Continue猜数字

package cn.tedu.basic;

import java.util.Scanner;

/**练习：找数字88*/
//给用户100次机会，猜数字88，如果不是88，继续输入，找到88就结束
public class TestBreakAndContinue {
	public static void main(String[] args) {
		//1.创建循环结构，完成循环100次的功能，可以帮助我们执行重复的业务
		for(int i = 1;i <= 100;i++){
			//2.提示并接收用户输入的数字
			System.out.println("请您输入猜测的数字：");
			int input = new Scanner(System.in).nextInt();
			//3.在每次循环中判断用户是否猜对
			if(input != 88) {//猜错了就结束本轮后面的语句
				continue;
			}
			System.out.println("我测试continue有没有跳过后半部分代码");
			if(input == 88) {
				System.out.println("恭喜您，答对了");
				break;//结束剩下的所有轮的循环
			}
		}
	}
	
}

3.练习while循环猜数字

package cn.tedu.basic;

import java.util.Random;
import java.util.Scanner;

/**本类用于练习while循环*/
//需求：产生一个随机数，与用户输入的数字作比较，直到用户输对
public class TestWhile {
		public static void main(String[] args) {
			guessNum();//调用自定义的猜数字方法
			
		}

		public static void guessNum() {
			//1.生成一个随机整数，交给r保存
			int r = new Random().nextInt(100);
			//System.out.println(r);
			//2.写一个死循环，直到用户猜对
			while(true) {
				System.out.println("请输入您猜的数字：");
				int input = new Scanner(System.in).nextInt();
				if(input > r) {
					System.out.println("猜大了，继续猜猜");
				}else if(input < r) {
					System.out.println("猜小了，继续猜猜");
				}else if(input == r) {
					System.out.println("猜对了，恭喜您！");
					break;
				}
				
			}
		}
		
}

4.练习do while结构

package cn.tedu.basic;

import java.util.Random;

/**本类用于练习do while结构*/
public class TestDoWhile {
	public static void main(String[] args) {
		int n;//1.定义一个变量
		do {//至少执行一次
			System.out.println("我是循环体");
			n = new Random().nextInt(300);//随机数得范围[300)
			System.out.println(n);//打印生成的随机数
		}while(n>100);//不符合循环条件，也就是随机数<=100就结束循环
	}
}

5.三种循环的区别

1. for：知道循环次数
2. while/do while：当循环次数不确定时
3. while：先判断，不符合规则，不执行代码
4. do while：代码最少被执行一次，再去判断，符合规则，再次执行代码
5. 循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码哦

二、数组

1.创建数组

数组的创建方式一般分为动态初始化和静态初始化

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

2.练习数组的创建

package cn.tedu.array;

import java.util.Arrays;

/**本类用于练习数组的创建*/
public class TestCreateArray {
//	public static void main(String[] args) {
//		//需求：分别用数组创建的3种方式，创建char类型的数组，存入单词hello
//		//1.1静态创建--创建时不仅知道数组的类型，还知道每一个位置上的具体元素
//		char[] c1 = {'h','e','l','l','o'};//第一种格式
//		System.out.println(c1);//hello
//		
//		char[] c2 = new char[]{'h','e','l','l','o'};//第二种格式
//		System.out.println(c2);//hello
//		
//		//1.2动态创建--知道数组的类型与长度，不知道具体的元素值
//		char[] c3 = new char[5];//创建一个长度为5的char类型数组
//		c3[0] = 'h';
		c3[1] = 'e';
		c3[2] = 'l';
//		c3[3] = 'l';
//		c3[4] = 'o';
//		
//		System.out.println(c3);
//	}
	public static void main(String[] args) {
		//1.创建数组
		//1.1静态创建--数组类型 数组中具体元素
		char[] c1 = {'h','e','l','l','o'};
		char[] c2 = new char[]{'h','e','l','l','o'};
		
		//1.2动态创建--
		char[] c3 = new char[5];
		//给数组中每个元素动态赋值
		/**我们通过数组的下标来操作数组中的每一个元素
		 * 注意：数组的下标从0开始，最大下标为数组的长度-1*/
		c3[0] = 'h';
		c3[1] = 'e';
		c3[2] = 'l';
		//c3[3] = 'l';
		c3[4] = 'o';
		
		//2.查看创建好的3个数组
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		
		//3.使用3种方式创建String类型的数组，存放数据"a"   "b"   "c"
		String[] s1 = {"a","b","c"};
		String[] s2 = new String[] {"a","b","c"};
		String[] s3 = new String[3];
		s3[0] = "a";
		s3[1] = "b";
		s3[2] = "c";
		
		/**char类型的数组底层中做了处理，可以直接打印数组中的具体元素
		 * 但除了char类型以外的数据，如果想要查看数组中的具体元素，需要使用：
		 * Arrays.toString(数组名)，注意：Arrays需要导包*/
		//4.打印创建好的数组
		
		System.out.println(s1);//打印出来的是数组的地址值
		System.out.println(Arrays.toString(s1));//数组结果
		System.out.println(Arrays.toString(s2));
		System.out.println(Arrays.toString(s3));
		
		//5.查看数组的长度--数组中存放元素的个数
		/**数组一旦创建，长度不可改变
		 * 如果想要增加/删除数组中的元素，只能先创建一个新长度的新数组
		 * 再将原来的数据复制过去*/
		System.out.println(c1.length);//5
		System.out.println(s1.length);//3
	}
}

3. 创建数组过程分析

程序创建数组 int[] a = new int[5]; 时发生了什么?

在内存中开辟连续的空间,用来存放数据,长度是5
给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
数组完成初始化会分配一个唯一的地址值
把唯一的地址值交给引用类型的变量a去保存
数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

4.数组的遍历

遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标

开始:开始下标0 结束:结束下标length-1 如何变化:++
for(从下标为0的位置开始 ; 下标的取值 <= 数组的长度-1 ; 下标++){
循环体;
}

5.练习数组的复制  缩容  扩容

package cn.tedu.array;

import java.util.Arrays;

/**本类用于练习数组的复制  缩容  扩容*/
public class TestCopyOf {
	public static void main(String[] args) {
		//1.创建数组
		int[] from = {1,2,3,4,5};
		
		//2.1数组的普通复制
		/**copyOf()用于完成数组的复制，两个参数：
		 * 参数1：要复制哪个数组
		 * 参数2：新数组的长度
		 * 如果新数组的长度=原数组的长度->普通复制*/
		int[] to = Arrays.copyOf(from, 5);
		System.out.println(Arrays.toString(to));//[1,2,3,4,5]
		
		//2.2数组的扩容
		/**扩容：扩充数组的容量：新数组的长度>原数组的长度
		 * 扩容思路：先创建对应新长度的新数组，每个位置上都有默认值
		 * 然后从原数组中将对应的元素复制到新数组，没有被覆盖的位置还是默认值
		 * 
		 * */
		int[] to2 = Arrays.copyOf(from, 10);
		System.out.println(Arrays.toString(to2));//[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
		
		//2.3数组的缩容
		/**缩容：缩小数组的容量：新数组的长度<原数组的长度
		 * 缩容思路：先创建对应长度的新数组，每个位置上都有默认值
		 * 然后从原数组中复制指定个数的元素到新数组中，类似于截取*/
		int[] to3 = Arrays.copyOf(from, 3);
		System.out.println(Arrays.toString(to3));
	}
}

6.练习数组的遍历

package cn.tedu.array;

import java.util.Arrays;
import java.util.Random;

/**本类用于练习数组的遍历  3184826557*/
public class ArrayExec {
	public static void main(String[] args) {
		//getMonthDay();//调用自定义方法
		//createArray1();//调用自定义创建数组的方法，存入数据1-10
		createArray2();//调用自定义创建数组的方法，存入随机值
	}

	private static void createArray2() {
		//1.动态创建一个长度为6的数组
		int[] a = new int[6];
		//2.遍历数组，依次给数组的每一个位置赋值
		for(int i = 0;i < a.length;i++) {
			//给数组中每个位置上的元素赋值，随机数的范围：[0-100)
			//这个100是自定义的数字
			a[i] = new Random().nextInt(100);
		}
		//3.for循环结束使用数组工具类查看数组中的元素值
		System.out.println(Arrays.toString(a));
	}

	private static void createArray1() {//创建自定义方法
		//1.创建数组--动态创建
		int[] a = new int[10];//a.length=10
		//2.遍历数组，依次给数组的每个位置赋值
		//从哪开始 0     到哪结束 a.length-1     如何变化 ++
		for(int i = 0;i < a.length;i++) {
			//a[0]~a[9]
			a[i] = i+1;//i=0-9  i+1=1-10
		}
		System.out.println(Arrays.toString(a));
	}

	private static void getMonthDay() {//创建自定义方法
		//1.创建一个数组，用来保存12个月的天数
		int[] a = {31,28,31,30,31,30,31,31,30,31,30,31};
		
		//2.输出每个月的天数到控制台
		//从哪开始 a[0]     到哪结束 a[a.length-1]      如何变化 ++
		/**从此处的循环变量i代表的是数组的下标：0~a.lenth-1*/
		for(int i = 0;i < a.length;i++) {//可以写成i <= a.length-1
//			System.out.println("下标："+i);//0-11代表的是数组的下标
			System.out.println((i+1)+"月有："+"\t"+a[i]+"天");
		}
	}
}

三、冒泡排序

冒泡排序（Bubble Sort），是计算机科学领域中较简单的一种排序算法。
它重复地走访需要进行排序的元素，依次比较两个相邻的元素，如果元素的顺序（如从大到小、首字母从A到Z）错误就把元素的位置互换。
走访元素是重复进行的,直到没有任何相邻位置上的元素需要交换位置，排序完成。

1.练习：冒泡排序

package cn.tedu.array;

import java.util.Arrays;

/**本类用于实现冒泡排序*/
public class BubbleSort {
	public static void main(String[] args) {
		//1.创建一个无序的数组
		int[] a = {27,96,73,25,21};	
		
		//2.创建自定义排序方法
		sortArray(a);
		
	}
	
	private static void sortArray(int[] a) {
		//1.外层循环：控制的是比较的轮数，假设有n个数，最多比较n-1轮
		//外层循环的循环变量代表的是轮数
		//比如5个数，最多比较4轮，<=a.length-1，最多取到1234共四个值
		for(int i = 1;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;
				}
			}
			System.out.println("第"+i+"轮排序的结果："+Arrays.toString(a));
		}
		System.out.println(Arrays.toString(a));
	}
	
	
}