目录
Day04---循环+数组... 1
1 break和continue. 1
1.1 形式... 1
1.2 练习1：找数字88. 1
2 循环结构2：while. 1
2.1 格式... 1
2.2 练习1：猜数字... 1
3 循环结构3：do-while. 1
3.1 格式... 1
3.2 练习1：改造猜数字... 1
4 !!!数组... 1
4.1 概念... 1
4.2 创建数组... 1
4.3 练习1：数组中存入hello. 1
4.4 数组的长度... 1
4.5 数组的遍历/循环... 1
4.5.1 形式... 1
4.5.2 练习1：输出每个月的天数... 1
4.5.3 练习2：遍历数组，存入1到10. 1
4.5.4 练习3：创建随机数组... 1
5 [了解]二维数组... 1
5.1 概念... 1
5.2 创建二维数组... 1
5.3 遍历二位数组... 1
6 拓展... 1
6.1 三种循环的区别... 1
6.2 冒泡排序... 1
Day04---循环+数组
1 break和continue
1.1 形式
break: 中断当前循环，简单粗暴
continue：跳出本次循环，进入下一轮
1.2 练习1：找数字88
创建day04工程
创建cn.tedu.breakconti包
创建Test1_Break.java
接收用户输入的100次数字
如果不是88继续输入
找到88就结束
package cn.tedu.breakconti;
import java.util.Scanner;
//找数字88
public class Test1_Break {
public static void main(String[] args) {
//执行100次，保证能接收100次输入
for(int i = 0 ; i < 100 ; i++) {
//1、接收用户输入的数字
int input = new Scanner(System.in).nextInt();
//2、判断是不是88
if(input != 88) {//不是88
continue;//continue可以让程序结束本次循环，继续下一次的输入
}else if(input == 88) {//是88
System.out.println("中了！！");
break;//break可以让程序立刻结束
// System.out.println("中了！！");不可到达的代码
}
}
}
}
2 循环结构2：while
先判断，再执行
2.1 格式
while(执行条件){
代码…
}
2.2 练习1：猜数字
产生一个随机数
和用户一直在输入，
的数字比较。
package cn.tedu.whiledemo;
import java.util.Random;
import java.util.Scanner;
//测试while循环
public class Test2_While {
public static void main(String[] args) {
//1、让程序产生随机数，
//nextInt(n) -- 产生n以内的随机数，从0开始
int random = new Random().nextInt(100)+1;
System.out.println(random);
//2、调用method()完成猜数字游戏
method(random);//random 是实参
}
//创建method(random) r是形参
public static void method(int r) {
//3、一直接受用户输入的数字
// for(int i = 1; i >= 1 ;i++) {//for的死循环
// while(r> 50) {//如果满足r > 50的条件，才执行循环体
while(true) {//while(true) -- 死循环，必须设置程序的出口
int input = new Scanner(System.in).nextInt();
//4、判断输入的值和随机数的关系
if(input> r) {
System.out.println("大了");
}else if(input < r) {
System.out.println("小了");
}else if(input == r) {
System.out.println("中了");
break;//设置出口！！！！！
}
}
}
}
3 循环结构3：do-while
先执行，再判断
3.1 格式
do{
代码…
} while(执行条件);
3.2 练习1：改造猜数字
产生一个随机数，和用户一直在输入的数字比较。
package cn.tedu.whiledemo;
import java.util.Random;
import java.util.Scanner;
//测试while循环
public class Test2_While {
public static void main(String[] args) {
//1、让程序产生随机数，
//nextInt(n) -- 产生n以内的随机数，从0开始
int random = new Random().nextInt(100)+1;
System.out.println(random);
//2、调用method()完成猜数字游戏---以while循环
// method(random);//random 是实参
//改造猜数字游戏---以do...while循环
method2(random);
}
//创建method2(random)---以do...while循环
//do...while循环 保证代码最少执行1次。 -- 先执行，再判断
public static void method2(int r) {
do {//while(true) -- 死循环，必须设置程序的出口
int input = new Scanner(System.in).nextInt();
//4、判断输入的值和随机数的关系
if(input> r) {
System.out.println("大了");
}else if(input < r) {
System.out.println("小了");
}else if(input == r) {
System.out.println("中了");
break;//设置出口！！！！！
}
}while(true);
}
//创建method(random) r是形参---以while循环
//while必须满足条件才执行 -- 先判断，在执行
public static void method(int r) {
//3、一直接受用户输入的数字
// for(int i = 1; i >= 1 ;i++) {//for的死循环
// while(r> 50) {//如果满足r > 50的条件，才执行循环体
while(true) {//while(true) -- 死循环，必须设置程序的出口
int input = new Scanner(System.in).nextInt();
//4、判断输入的值和随机数的关系
if(input> r) {
System.out.println("大了");
}else if(input < r) {
System.out.println("小了");
}else if(input == r) {
System.out.println("中了");
break;//设置出口！！！！！
}
}
}
}
4 !!!数组
4.1 概念
数组Array，标志[ ]。
是用于储存多个相同类型数据的集合。
想要获取数组中的元素值，可以通过脚标（下标）来获取，下标是从0开始的。
4.2 创建数组
一般分为动态初始化和静态初始化
1、动态初始化 -- 不知道数组里具体要存啥数据
int[] a = new int[5];
2、静态初始化 -- 创建时就已经知道了数组里要放啥
int[] b = new int[]{1,2,3,4,5,6,7,8,9,10};
int[] c = {1,2,3,4,5,6,7,8,9,10};
4.3 练习1：数组中存入hello
package cn.tedu.array;
//测试数组的使用
public class Test3_Array {
public static void main(String[] args) {
//1、创建数组
//-- 静态创建
char[] a = new char[] {'h','e','l','l','o'};
char[] b = {'h','e','l','l','o'};
System.out.println(a);
System.out.println(b);
//-- 动态创建
char c[] = new char[5];
c[0] = 'h';//给第1个元素(下标为0的)赋值
c[1] = 'e';//给第2个元素(下标为1的)赋值
c[2] = 'l';//给第3个元素(下标为2的)赋值
c[3] = 'l';//给第4个元素(下标为3的)赋值
c[4] = 'o';//给第5个元素(下标为4的)赋值
//java.lang.ArrayIndexOutOfBoundsException：因为访问了数组中不存在的下标
// c[5] = 'x';//给第6个元素(下标为5的)赋值
System.out.println(c);
}
}
4.4 数组的长度
- length属性
- 数组一旦创建，长度不可变
- 允许0长度的数组
4.5 数组的遍历/循环
从头到尾，依次访问数组的位置。
4.5.1 形式
for(从下标为0的位置开始;下标<= 数组的长度-1;下标++){
循环体
}
4.5.2 练习1：输出每个月的天数
package cn.tedu.array;
//测试数组的练习
public class Test4_Array {
public static void main(String[] args) {
//输出每个月的天数
//1、静态创建数组，存放12个数字
int[] a = {31,28,31,30,31,30,31,31,30,31,30,31};
//TODO 2、遍历数组中的每个元素
//i表示下标，int i = 0 指从下标为0的位置开始
//i <= a.length-1 指下标<= 数组的长度-1
//i++ 指下标依次递增，向后遍历数据
for(int i = 0 ;i <= a.length-1 ; i++){
// System.out.println("3月有30天");
//a[i] 根据下标获取元素
System.out.println(i+1+"月有"+a[i]+"天");
}
}
}
4.5.3 练习2：遍历数组，存入1到10
//向数组中存入1-10
public static void method2() {
//1、动态创建数组
int[] a = new int[10];
//TODO 2、遍历数组中的每个元素
//i表示下标，int i = 0 指从下标为0的位置开始
//i< = a.length-1 指下标<= 数组的长度-1
//i++ 指下标依次递增，向后遍历数据
for(int i = 0 ; i <= a.length-1 ; i++ ) {
a[i] = i+1;//a[i]根据下标修改元素的值，把原来的默认值覆盖掉
System.out.println(a[i]);
}
System.out.println(a);//[I@659e0bfd -- 地址值
//想看不是char[]的数组里的元素是啥
//Arrays.toString() -- 把指定的数组里的元素变成字符串显示
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
System.out.println(Arrays.toString(a));
}
4.5.4 练习3：创建随机数组
获取100以内的随机值的数组
// 创建随机数组
public static void method3() {
// 1、动态创建数组，长度是10
int[] a = new int[10];
// 2、根据下标遍历数组
// i表示下标，int i = 0 指从下标为0的位置开始
// i <= a.length-1 指下标<= 数组的长度-1
// i++ 指下标依次递增，向后遍历数据
for (int i = 0; i <= a.length - 1; i++) {
//根据下标给每个下标对应的元素赋随机数
a[i] = new Random().nextInt(100);
}
//3、打印a数组中的元素
//[79, 74, 75, 48, 37, 55, 55, 94, 33, 96]
System.out.println(Arrays.toString(a));
}
5 [了解]二维数组
5.1 概念
标志是[ ][ ]。
存放数组的数组，也就是说数组里存的还是数组的数据形式。
5.2 创建二维数组
1、静态初始化
int[][] a= {{1,2},{3,4},{5,6},{8,9}};
--创建外部数组长度是4
--创建内部数组长度分别是2
--初始化数组，存入默认值
--修改数组中的默认值
--分配唯一的内存地址值，并交给引用型变量a保存
5.3 遍历二位数组
for(int i=0;i<a.length;i++){//遍历外部数组
for(int j=0;j<a[i].length;j++){//遍历内部数组
syso(a[i][j]);//根据外围数组下标和内部数组下标结合定位元素
a[i][j]=?;
}
}
6 拓展
6.1 三种循环的区别
三种循环都可以互相代替。
1、for -- 必须知道开始位置 + 知道循环的次数
for(开始位置；循环的判断条件；更改条件){
循环体；
}
2、while -- 先判断，再执行 -- 只需要知道条件
while(循环的判断条件){
循环体；
}
3、do...while -- 先执行，再判断 -- 只需要知道条件 -- 保证代码最少执行1次
do{
循环体；
}while(循环的判断条件);
6.2 冒泡排序
package day005;
import java.util.Arrays;
import java.util.Random;
public class Test1_冒泡 {
public static void main(String[] args) {
int[] arr = suiji();//获得随机数组
System.out.println(Arrays.toString(arr));
sort(arr);//冒泡
System.out.println(Arrays.toString(arr));
}
//获得随机数组
private static int[] suiji() {
int n = 5+new Random().nextInt(6);
int[] arr = new int[n];
for (int i = 0; i< arr.length; i++) {
arr[i]=new Random().nextInt(100);
}
return arr;
}
//冒泡，从小到大排序
private static void sort(int[] a) {
for(int i=0;i<a.length;i++){
for(int j=a.length-1;j>i;j--){
if(a[j]<a[j-1]){
int t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
}
}
}