Java流程控制基础
用户交互Scanner
java.util.Scanner 。Java5的新特征,可以通过Scanner类来获取用户的输入输出。
基本语法:
Scanner s = new Scanner(System.in);
通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
hasNext会等待程序输入完毕
next():
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白,next方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
- next()不能得到带有空格的字符串。
package com.star_line.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//创建一个扫描对象,用于接受键盘数据in是输入,封装成scanner对象
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方法接收:");
//判断用户有没有输入字符串
if (scanner.hasNext()){
String str = scanner.next(); //next接受用户输入
System.out.println("输出的内容为:" + str);
}
scanner.close(); //凡是属于io流的类如果不关闭就会一直占用资源,要养成好习惯用完就关掉。
}
}
使用next方法接收:
hello world!
输出的内容为:hello
进程已结束,退出代码0
nextLine():
- 以enter为结束符,也就是说该方法返回的是输入回车前的所有字符。
- 可以有空白。
package com.star_line.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("使用NextLine方式接收:"); //从键盘接收数据
//判断是否还有输入
if (scanner.hasNextLine()){
String str = scanner.nextLine();
System.out.println("输出的内容为:" + str);
}
scanner.close();
}
}
使用NextLine方式接收:
hello world!
输出的内容为:hello world!
进程已结束,退出代码0
package com.star_line.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据:");
String str = scanner.nextLine();
System.out.println("输出的内容为:" + str);
scanner.close();
}
}
请输入数据:
欢迎来到狂神说java 希望大家一起学习
输出的内容为:欢迎来到狂神说java 希望大家一起学习
进程已结束,退出代码0
package com.star_line.scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//从键盘输入数据
int i = 0;
float f =0.0f;
System.out.println("请输入整数:");
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("整数数据:" + i);
}else{
System.out.println("输入的不是整数!");
}
System.out.println("请输入小数:");
if (scanner.hasNextFloat()){
f = scanner.nextFloat();
System.out.println("小数数据:" + f);
}else{
System.out.println("输入的不是小数!");
}
scanner.close();
}
}
请输入整数:
10
整数数据:10
请输入小数:
1.1
小数数据:1.1
进程已结束,退出代码0
请输入整数:
10.1
输入的不是整数!
请输入小数:
小数数据:10.1
进程已结束,退出代码0
package com.star_line.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//我们可以输入多个数字,并求其总和与平均数,每输入一个数字用回车确认,通过输入非数字来结束输入并输出执行结果。
Scanner scanner = new Scanner(System.in);
//and
double sum = 0;
//计算输入多少数字
int m = 0;
//通过循环判断是否还有输入,并在里面对每一次进行求和统计。
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();//
m = m + 1;//m++;
sum = sum + x;
System.out.println("你输入了第" + m + "个数据,当前结果sum= " + sum);
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值为" + (sum/m));
scanner.close();
}
}
10
你输入了第1个数据,当前结果sum= 10.0
20
你输入了第2个数据,当前结果sum= 30.0
30
你输入了第3个数据,当前结果sum= 60.0
40
你输入了第4个数据,当前结果sum= 100.0
x
4个数的和为100.0
4个数的平均值为25.0
进程已结束,退出代码0
顺序结构
java的基本结构是顺序结构。除非特别指明,否则一句句按顺序执行。
从上到下,依次执行。
任何一种算法都离不开的基本算法结构。
package com.star_line.struct;
public class ShunxuDemo {
public static void main(String[] args) {
System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("hello4");
System.out.println("hello5");
}
}
选择结构*
if单选泽结构
语法:if(布尔表达式){
//如果布尔表达式为true,执行语句。
}
package com.star_line.struct;
import java.util.Scanner;
public class IfDemo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容:");
String s = scanner.nextLine();
//equas:判断字符串是否相等
if (s.equals("Hello")){
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
请输入内容:
sdhk
End
进程已结束,退出代码0
请输入内容:
Hello
Hello
End
进程已结束,退出代码0
if双选择结构
if(布尔表达式){
//布尔表达式为true
}else{
//布尔表达式为false
}
package com.star_line.struct;
import java.util.Scanner;
public class IfDemo02 {
public static void main(String[] args) {
//考试分数》60及格,《60 不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
int score = scanner.nextInt();
if(score>60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
scanner.close();
}
}
请输入成绩:
60
不及格
进程已结束,退出代码0
请输入成绩:
80
及格
进程已结束,退出代码0
if多选择结构
if(布尔表达式1){
1为true
}else if(布尔表达式2){
2为true
}else if(布尔表达式3){
3为true
}else{
以上表达式都不为true
}
package com.star_line.struct;
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
int score = scanner.nextInt();
if(score==100){
System.out.println("恭喜满分");
}else if(score < 100 && score >= 90){
System.out.println("A级");
}else if(score < 90 && score >= 80){
System.out.println("B级");
}else if(score < 80 && score >= 70){
System.out.println("C级");
}else if(score < 70 && score >= 60){
System.out.println("D级");
} else if (score<60 && score>=0) {
System.out.println("不及格");
} else{
System.out.println("成绩不合法!");
}
scanner.close();
}
}
请输入成绩:
102
成绩不合法!
进程已结束,退出代码0
请输入成绩:
100
恭喜满分
进程已结束,退出代码0
请输入成绩:
75
C级
进程已结束,退出代码0
请输入成绩:
15
不及格
进程已结束,退出代码0
- if语句至多有一个else语句,else语句在所有的else if语句之后。
- if语句可以有若干个else if语句,它们必须在else语句之前
- 一旦其中一个else if语句检测为 true,其他的else if以及else语句都将跳过执行。
if嵌套结构
if(布尔表达式1){
1为true
if(布尔表达式2){2为true}
}
思考:在1~100之间寻找一个数。
if和else if内部都可以嵌套。
所有的流程控制语句都能相互嵌套。
switch多选择结构
switch case语句判断一个变量与一系列值中某个值是否相等,每个值成为一个分支。
switch(expression){
case value :
//语句
break;//可选
case value :
//语句
break;//可选
default : //可选
//语句
}
switch变量类型:
byte、short、int、char
*string(jdk7)
case标签必须为字符串常量或字面量。
package com.star_line.struct;
public class SwitchDemo01 {
public static void main(String[] args) {
//case穿透。不加break,后续全部输出。 switch匹配一个具体的值
char grade = 'B';
switch (grade){
case 'A' :
System.out.println("优秀");
break;
case 'B' :
System.out.println("良好");
break;
case 'C' :
System.out.println("及格");
break;
case 'D' :
System.out.println("再接再厉");
break;
case 'E' :
System.out.println("挂科");
break;
default :
System.out.println("未知等级");
}
}
}
及格
再接再厉
挂科
进程已结束,退出代码0
良好
及格
再接再厉
挂科
未知等级
进程已结束,退出代码0
良好
进程已结束,退出代码0
switch的反编译:
文件-结构-路径
打开路径-右键包-在文件夹打开-添加.class-
循环结构
while循环
while(布尔表达式){
//循环内容
}
不要表达式为true,循环一直执行。
大多数情况要让循环停止,需要一个让表达式失效的情况停滞循环。
少部分情况需要一直执行循环,比如服务器的请求响应监听等。
循环条件一直为true会在撑死循环
package com.star_line.struct;
public class WhileDemo01 {
public static void main(String[] args) {
// 输出1~100
int i = 0;
while (i<100){
i++;
System.out.println(i);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
进程已结束,退出代码0
思考:1+2+3+。。。。+100?
package com.star_line.struct;
public class WhileDemo03 {
public static void main(String[] args) {
//计算1+2+3+……+100?
int i = 0;
int sum = 0;
while(i<=100){
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
5050
进程已结束,退出代码0
do…while 循环
do{
//代码
}while(布尔表达式)
do……while至少执行一次。
先执行后判断、先判断后执行
5050
进程已结束,退出代码0
package com.star_line.struct;
public class DOWhileDemo01 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do{
sum = sum + i;
i++;
}while(i <= 100);
System.out.println(sum);
}
}
========================
0
进程已结束,退出代码0
package com.star_line.struct;
public class DOWhileDemo02 {
public static void main(String[] args) {
int a = 0;
while (a<0){
System.out.println(a);
a++;
}
System.out.println("========================");
do{
System.out.println(a);
a++;
}while (a<0);
}
}
for循环
在Java5中引入了一种主要用于数组的增强型for循环。
for是支持迭代的一种通用结构,是最有效最灵活的循环结构。
for循环执行的次数是在执行前就确定的。语法格式如下:
for(初始化条件;布尔表达式条件判断;更新迭代){
//代码
}
package com.star_line.struct;
public class ForDemo01 {
public static void main(String[] args) {
int a = 1;//初始化条件
while (a<=100){//条件判断
System.out.println(a);//循环体
a += 2;//迭代
}
System.out.println("while循环结束。");
for (int i = 1;i <= 100;i++){//初始化条件;条件判断;迭代
System.out.println(i);
}
System.out.println("for循环结束。");
}
}
1
3
5
7
9
11
13
15
17
19
21
23
25
27
29
31
33
35
37
39
41
43
45
47
49
51
53
55
57
59
61
63
65
67
69
71
73
75
77
79
81
83
85
87
89
91
93
95
97
99
while循环结束。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
for循环结束。
进程已结束,退出代码0
快捷键(for(int i=0;i<100;i++))100.for+enter
- 关于for循环的说明:
- 最先执行初始化步骤。可以声明一种类型,但可以初始化一个或多个循环控制变量,也可以是空语句。
- 然后检测布尔表达式的值。如果为true,循环体被执行;如果为false,循环中止,执行循环体后面的语句。
- 执行一次循环后,更新循环控制变量(迭代因子控制循环变量的增减)
- 再次检测布尔表达式,执行上述过程。
- for(i=0;i<100;i++)
for(;i<100;i++)
for(;;i++)死循环1
for(;;)死循环2
练习1:计算从0~100之间的奇数和偶数的和。
package com.star_line.struct;
public class ForDemo02 {
public static void main(String[] args) {
//test1: 计算从0~100之间的奇数和偶数的和。
int oddsum = 0;//奇数
int evensum = 0;
for (int i = 0; i <= 100; i++) {
if (i%2 != 0){
oddsum+=i;
}else{
evensum+=i;
}
}
System.out.println("奇数的和:" + oddsum);
System.out.println("偶数的和:" + evensum);
}
}
奇数的和:2500
偶数的和:2550
进程已结束,退出代码0
练习2:用while或for循环输出1~1000之间能被5整除的数,并且每行输出3个。
package com.star_line.struct;
public class ForDemo03 {
public static void main(String[] args) {
//用while或for循环输出1~1000之间能被5整除的数,并且每行输出3个。
for (int i = 0; i < 1000; i++) {
if (i%5 == 0){
System.out.print(i+"\t");
}
if (i%(5*3)==0){//换行
System.out.println();
//System.out.print("\n");
/*
* println 输出完毕会换行
* print 输出完毕不会换行
* */
}
}
}
}
0
5 10 15
20 25 30
35 40 45
50 55 60
65 70 75
80 85 90
95 100 105
110 115 120
125 130 135
140 145 150
155 160 165
170 175 180
185 190 195
200 205 210
215 220 225
230 235 240
245 250 255
260 265 270
275 280 285
290 295 300
305 310 315
320 325 330
335 340 345
350 355 360
365 370 375
380 385 390
395 400 405
410 415 420
425 430 435
440 445 450
455 460 465
470 475 480
485 490 495
500 505 510
515 520 525
530 535 540
545 550 555
560 565 570
575 580 585
590 595 600
605 610 615
620 625 630
635 640 645
650 655 660
665 670 675
680 685 690
695 700 705
710 715 720
725 730 735
740 745 750
755 760 765
770 775 780
785 790 795
800 805 810
815 820 825
830 835 840
845 850 855
860 865 870
875 880 885
890 895 900
905 910 915
920 925 930
935 940 945
950 955 960
965 970 975
980 985 990
995
进程已结束,退出代码0
练习3:打印九九乘法表。
进程已结束,退出代码0
进程已结束,退出代码0
- 打印第一列
- 把第一列扩展到九列
- 去掉重复项,i<=j
- 调整样式。
package com.star_line.struct;
/*九九乘法表*/
public class ForDemo04 {
public static void main(String[] args) {
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j + "*" + i + "=" +(i*1) + "\t");
}
System.out.println();
}
}
}
练习4:倒着打印九九乘法表。
- 打印第一列
- 把第一列扩展到九列
- 去掉重复项,i<=j
- 调整样式。
package com.star_line.struct;
/*
* 练习4:倒着打印九九乘法表。
9*1 9*2 ... 9*9
8*1 8*2 ...8*8
* ...
* 1*1
1. 打印第一列
2. 把第一列扩展到九列
3. 去掉重复项,i<=j
4. 调整样式。*/
public class ForDemo041 {
public static void main(String[] args) {
for (int j = 9; j >= 1; j--) {
for (int i = 1; i <= j; i++) {
System.out.print(j + "*" + i + "=" + (j*i) +"\t");
}
System.out.println();
}
}
}
增强for循环
遍历数组和集合(Java5)
for(声明语句:表达式){//代码}
package com.star_line.struct;
public class ForDemo05 {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50};//定义了一个数组
for (int i = 0; i < 5; i++) {
System.out.println(numbers[i]);
}
System.out.println("================");
//遍历数组的元素
for(int x:numbers){
System.out.println(x);
}
}
}
10
20
30
40
50
================
10
20
30
40
50
进程已结束,退出代码0
break continue
break在任何循环语句的主体部分,都可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。
continue用于循环语句体中,用于中止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否循环的判定。
关于goto关键字
Java保留了这个关键字,但是java没有goto。break和continue能看出一些goto的影子,像是带标签的break和continue。
“标签”是后面跟一个:的标识符,如label:
对Java来说唯一用到标签的地方在循环语句之前。然而在循环前设置标签的唯一理由是:我们希望在循环中嵌套其他的循环,由于break和continue通常只中断当前循环,但是若随标签使用,它们就会中断到标签所在的位置。
package com.star_line.struct;
public class BreakDemo {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
System.out.println(i);
if(i==30){
break;
}
}
System.out.println("123");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
123
进程已结束,退出代码0
package com.star_line.struct;
public class ContinueDemo {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
if(i%10 == 0){
System.out.println();
continue;
}
System.out.print(i);
}
}
}
123456789
111213141516171819
212223242526272829
313233343536373839
414243444546474849
515253545556575859
616263646566676869
717273747576777879
818283848586878889
919293949596979899
进程已结束,退出代码0
continue请假,break辞职,return换个星球生活=)
练习课:
打印一个五行的等边三角形。
先打印半个,再打印另一半。
public class TestDemo {
public static void main(String[] args) {
//打印三角形,5行
for (int i = 1; i <= 5; i++) {
//倒三角形,空白的
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
打印菱形◇
package com.star_line.struct;
public class TestDemo {
public static void main(String[] args) {
//打印菱形,5行
for (int i = 1; i <= 5; i++) {
//倒三角形,空白的
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(" ");
}
for (int j = 5; j >= i; j--) {
System.out.print("*");
}
for (int j = 5; j > i; j--) {
System.out.print("*");
}
System.out.println();
}
}
}