一、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.三种循环的区别
- for:知道循环次数
- while/do while:当循环次数不确定时
- while:先判断,不符合规则,不执行代码
- do while:代码最少被执行一次,再去判断,符合规则,再次执行代码
- 循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码哦
二、数组
1.创建数组
数组的创建方式一般分为动态初始化和静态初始化
- 动态初始化
int[] a = new int[5]; - 静态初始化
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));
}
}