标签：遍历 统计 区别 客户端连接 表示 迭代 字符串的比较 未在 图标
Scanner s = new Scanner(System.in);
package Java流程控制;
import java.util.Scanner;
public class 用户交互Scanner1 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if (scanner.hasNext()==true){
//使用next方式接收：
String str = scanner.next();//这句话一旦执行，程序会等待用户输入完毕
System.out.println("输出的内容为："+str);
}
//凡是属于IO流(输入输出流)的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
scanner.close();
}
}
package Java流程控制;
import java.util.Scanner;
public class 用户交互Scanner2 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收：");
//判断用户是否还有输入
if (scanner.hasNextLine()==true){
//使用nextLine方式接收：
String str = scanner.nextLine();//这句话一旦执行，程序会等待用户输入完毕
System.out.println("输出的内容为："+str);
}
//凡是属于IO流(输入输出流)的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
scanner.close();
}
}
package Java流程控制;
import java.util.Scanner;
public class 用户交互Scanner3 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);//1.开始接收键盘数据
System.out.println("请输入数据：");
String str = scanner.nextLine();//2.在此停止，直到用户输入完毕按下回车，将输入的数据变成一个变量保存到str这个字符串里
System.out.println("输出的内容为："+str);//3.根据用户的输入进行输出
scanner.close();//4.关闭这个IO流
}
}
由于 next() 有空格就会断，所以平时 nextLine() 用得比较多，next() 的运用场景少一些
package Java流程控制;
import java.util.Scanner;
public class Scanner进阶使用 {
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()==true){
i = Scanner.nextInt();
System.out.println("整数数据：" + i);
}else{
System.out.println("输入的不是整数数据！");
}
System.out.println("请输入小数：");
//如果。。。那么
if (Scanner.hasNextFloat()==true){
f = Scanner.nextFloat();
System.out.println("小数数据：" + f);
}else{
System.out.println("输入的不是小数数据！");
}
Scanner.close();//关闭IO流的代码可以先写，然后再中间写代码，就不会忘记关闭
}
}
package Java流程控制;
import java.util.Scanner;
public class Scanner进阶使用_例 {
public static void main(String[] args) {
//我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
System.out.println("傻逼你好，请输入数据，以非数字结束");
//通过循环判断是否还有输入，并在里面对每一次进行求和及统计
while (scanner.hasNextDouble()){
double X = scanner.nextDouble();
m = m + 1;//这路也可以使用m++ (自增)
sum = sum + X;
System.out.println("傻逼，你输入了第"+ m +"个数据，然后当前总和="+ sum);
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值是" + (sum / m));
scanner.close();
}
}
package Java流程控制;
public class 顺序结构 {
public static void main(String[] args) {
System.out.println("hello 1");
System.out.println("hello 2");
System.out.println("hello 3");
System.out.println("hello 4");
System.out.println("hello 5");
//按照自上而下的顺序输出了 hello 12345
}
}
if 单选择结构
if(布尔表达式)｛
//如果布尔表达式为true将执行的语句
｝
举例：
package Java流程控制;
import java.util.Scanner;
public class 选择结构_if单选择结构 {
public static void main(String[] args) {
Scanner Scanner = new Scanner(System.in);
System.out.println("请输入内容：");
String s = Scanner.nextLine();
//equals的作用：判断字符串是否一致，类似==但是这里不能用==判断
if (s.equals("hello"))
System.out.println(s);
System.out.println("End");
Scanner.close();
/*输入hello 会输出hello和end ；输入其他字符 会直接输出end
这就是选择结构的特点，如果成立(true/false)就执行下一语句，否则就跳过*/
}
}
if 双选择结构
假如现在有个需求，公司要收购一个软件，成功的话，给人支付100万元，如果失败，就自己找人开发。这样子的需求，用刚才的if单选择就无法完成了，需要一个双选择结构，所以就有了if-else结构
语法：
if(布尔表达式)｛
//如果布尔表达式的值为true
｝else｛
//如果布尔表达式的值为false
解析：布尔表达式之后：如果true--执行语句1 ； 如果false--执行语句2
package Java流程控制;
import java.util.Scanner;
public class 选择结构_if双选择结构 {
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();
//布尔表达式之后：如果true--执行语句1 ； 如果false--执行语句2
}
}
if 多选择结构
当遇到更加复杂的情况，如有ABCD多种情况（存在区间多级判断），比如成绩 90-100为A，80-90为B...等等，在生活中我们很多时候的选择往往也不知两个，所以我们需要一个多选择结构来处理这些问题
语法
if(布尔表达式1)｛
//如果布尔表达式1的值为true执行代码
｝else if（布尔表达式2）｛
//如果布尔表达式2的值为true执行代码
｝else if（布尔表达式3）｛
//如果布尔表达式3的值为true执行代码
｝else if（布尔表达式4）｛
//如果布尔表达式4的值为true执行代码
｝
package Java流程控制;
import java.util.Scanner;
public class 选择结构_if多选择结构 {
public static void main(String[] args) {
//分数90-100为A；80-89为B；70-79为C；60-69为D；60以下为不合格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score>=90 && score<=100){
System.out.println("A");
}else if (score>=80 && score<90){
System.out.println("B");
}else if (score>=70 && score<80){
System.out.println("C");
}else if (score>=60 && score<70) {
System.out.println("D");
}else if (score<60 && score>=0){
System.out.println("不及格 :( ");
} else {
System.out.println("成绩不合法");
}
scanner.close();
/*if 语句至多有 1 个 else 语句，else 语句应在所有 else if 语句之后
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行*/
}
}
嵌套的if结构
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
if(布尔表达式 2)}
//如果布尔表达式 2的值为true执行代码
}
}
? 所有的流程控制语句 都可以相互嵌套而互不影响
package Java流程控制;
import java.util.Scanner;
public class 选择结构_嵌套的if结构 {
public static void main(String[] args) {
//以超市购物 会员/非会员和消费金额不同 享受不同折扣举例：
Scanner input = new Scanner(System.in);
System.out.println("请输入是否为会员：是（Y）否（N）");
String name = input.next();
System.out.println("请输入消费金额：");
double money = input.nextDouble();
if (name.equals("Y")){ //判断是否为会员 如果是会员：
if (money >= 200){
money = money * 0.7; //会员且消费大于等于200，打7折
System.out.println("会员且消费满200，七折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
}else if (money < 200 && money >= 0 ){
money = money * 0.8; //会员消费小于200，打8折
System.out.println("会员且消费未满200，八折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
}
else{
System.out.println("输入的消费金额不合法"); //输入其他数据，如负数，输出“不合法”
}
}else if (name.equals("N")){ //如果不是会员
if (money >=100) {
money = money * 0.9; //非会员消费大于等于100，打9折
System.out.println("非会员且消费满100，九折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
}else if (money <100 && money >= 0){
money = money * 1; //非会员消费小于100，原价支付
System.out.println("非会员且未满100，需要原价支付" + money + "元人民币，欢迎下次光临！");
}else{
System.out.println("输入的消费金额不合法"); //输入其他数据，如负数，输出“不合法”
}
}else {
System.out.println("注意 由于之前未正确输入否为会员，无法得出应付金额！");
//输入除YN的其他数据，输出“无法得出金额”
}
input.close(); //关闭流
}
}
switch 多选择结构
switch(expression){
case value :
//语句
break;//可选
case value ：
//语句
break;//可选
//你可以有任意数量的 case 语句
default ： //可选
//语句
}
switch 语句中的变量类型可以是：
byte、short、int 或者 char (示例为 switch多选择结构 1)
从 Java SE 7 开始，switch 支持字符串 String 类型了(示例为 switch多选择结构 2)
同时 case 标签必须为字符串常量或字面量
package Java流程控制;
public class switch多选择结构1 {
public static void main(String[] args) {
//case 穿透 ?-1 会解释 //switch 会匹配一个具体的值
char grade = ‘A‘;
switch (grade){
case ‘A‘ :
System.out.println("优秀");
break;//输出将会这里停止 (break 为可选) 不会被 case 穿透 ?-1
case ‘B‘ :
System.out.println("良好");
break;//停止输出下面的内容
case ‘C‘ :
/* -1 由于下面没有 break，如果输入C 将会把下面全部输出 直到遇到 break
这就叫 case 穿透现象 (这里输入 C 会在输出 再接再厉 后停止)*/
System.out.println("及格");
case ‘D‘ :
System.out.println("再接再厉");
break;//停止 case 穿透
case ‘E‘ :
System.out.println("挂科");
break;//停止 case 穿透
default:
System.out.println("未知等级");
/*由于 case穿透现象 的存在，
所以一般每写一个 case，都应该在后面加上 break */
}
}
}
package Java流程控制;
public class switch多选择结构2 {
public static void main(String[] args) {
/*从 Java SE 7 开始，switch 支持字符串 String 类型了
也就是从 JDK7开始 支持字符串的比较了，表达式的结果可以是字符串 */
/*拓展：这是因为 字符的本质还是数字，编译是java--class(字节码文件)
在 反编译class(可以用IDEA进行) 之后 发现其实字符串也是根据哈希值比较的 */
String name = "X";
switch (name){
case "低密度脂蛋白":
System.out.println("低密度脂蛋白");
break;
case "木日雨林":
System.out.println("木日雨林");
break;
default:
System.out.println("???!!!");
/*怎么用 IDEA 进行反编译？在资源管理器中，将输出的 class文件 拷贝到java类文件夹里
然后再打开IDEA，打开那个class(字节码文件 图标为01)文件就可以 */
}
}
}
while 循环
while(布尔表达式){
//循环内容
}
package Java流程控制;
public class 循环结构_while循环1从1到100 {
public static void main(String[] args) {
//输出1~100
int i = 0;
while (i < 100){ // i 一旦大于100 表达式就会失效 循环就会结束
i++;// 每次执行前 都会检查 i 是否 < 100，当为 true 的情况下，将一直执行这个循环
System.out.println(i);
}
}
}
package Java流程控制;
public class 循环结构_while循环2无限循环 {
public static void main(String[] args) {
// 无限循环 死循环
while (true){ //这个循环将一直为 true 无限循环， 如等待客户端连接时、定时检查时...会用到
System.out.println("123"); //运行代码将会一直输出 123 :(
}
}
}
package Java流程控制;
public class 循环结构_while循环3暴力计算 {
public static void main(String[] args) {
//用 while 计算 1+2+3+...+100= ?
int i = 1;
int sum = 0;
while (i <= 100){ //当 i 小于等于100 时 执行下面的循环
sum = sum + i; //总和 = 当前总和 + 下一个自然数
i++; //每计算一次 自增
}
System.out.println(sum);
}
}
do...while 循环
do {
//代码语句
}while(布尔表达式);
while 和 do ... while 的区别：
案例：1、使用 do...while 循环计算1+2+3+ ... +100 = ? ； 2、while 循环 和 do...while 循环的对比
package Java流程控制;
public class 循环结构_dowhile循环1暴力计算 {
public static void main(String[] args) {
//用 do...while 计算 1+2+3+...+100= ?
int i = 1;
int sum = 0;
do {
sum = sum + i;
i ++;
}while ( i <= 100 );
System.out.println(sum);
}
}
package Java流程控制;
public class 循环结构_dowhile循环2和while对比 {
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);
}while (a < 0);
/*最后在分割线的下输出了一个 0 。这是由于 while 是先判断 后执行
在判断 a < 0 不成立后就不执行下面的循环了；
而 do...while 是先执行 后判断 在执行了一次 也就是输出0 之后
再判断 a < 0 不成立 就不再次执行循环了 所以只输出一个 0 */
}
}
for 循环
虽然所有循环结构都可以用 while 或者 do...while 表示，但 Java 提供了另一种语句--for 循环，使一些循环结构变得更加简单
for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构
for 循环执行次数是在执行前就确定的。语法格式如下：
for (初始值；布尔表达式（条件判断）；迭代){
//代码语句
}
下面代码依次是：
package Java流程控制;
public class 循环结构_for循环1效率很高 {
public static void main(String[] args) {
//用 while 和 for 实现相同功能 的对比
int a = 1; //初始化值
while (a <= 100){ //条件判断
System.out.println(a); //循环体 内容
a += 2; //迭代 (也就是每一次循环都会将 a 的值刷新)
}
System.out.println("while 循环已结束 ！");
System.out.println("==============================");
for (int i = 1;i <= 100;i ++){ //括号里分别是 (初始化值；条件判断；迭代)
// ↑ 这里可以使用快捷键 100.for 回车
System.out.println(i);
}
System.out.println("for 循环已结束 ！");
/*关于 for 循环有以下几点需要注意：
最先执行初始化步骤。可以声明一种类型，可初始化一个或者多个循环控制变量，也可以是空语句
然后，检测布尔表达式的值，如果为 true，循环体被执行；如果为 false，循环终止，跳过循环体 开始执行后面的语句
执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)
再次检测布尔表达式，循环执行上面的过程
也就是说 可以没有初始值 没有判断 没有迭代 for (; ; ) { } 会不断循环循环体内容 这就是死循环 */
}
}
package Java流程控制;
public class 循环结构_for循环2练习1 {
public static void main(String[] args) {
//练习1：计算 0 到 100 奇数和偶数的和
int oddSum = 0; //定义 oddSum 用来保存奇数的和
int evenSum = 0; //定义 evenSum 用来保存偶数的和
for (int i = 0; i <=100; i++) { //定义初始化值为：0 判断条件：小于等于100 迭代：每次+1
if (i%2!=0){ //取模运算: 当i/2的余数 不等于 0 时 也就是为奇数时
oddSum+= i; //奇数的和=当前奇数的和 + 下一个得到的奇数
}else { //取反 (取模等于 0 ) 时 也就是为偶数时
evenSum+= i; //偶数的和=当前偶数的和 + 下一个得到的偶数
}
}
System.out.println("0~100奇数的和=" + oddSum + "；偶数的和=" + evenSum + ".");
}
}
package Java流程控制;
public class 循环结构_for循环3练习2 {
public static void main(String[] args) {
//练习2：用 while 或 for 循环 输出 1~1000 能被5整除的数，并且每行输出3个
for (int i = 5; i <= 1000; i++) {
if (i % 5 == 0){
System.out.print(i+"\t"); // "/t"为转义字符 (空格)
}
if (i % (5*3) == 0){ //每当 i 能被 15 整除
System.out.print("\n"); //输出 "\n" (换行)
//System.out.println(); 这段代码也能实现和 ↑ 同样的功能 相当于输出空白然后换行
}
}
//println 输出完会换行； print 输出完不会换行
}
}
package Java流程控制;
public class 循环结构_for循环4练习3_1打印第一列 {
public static void main(String[] args) {
// 打印九九乘法表_1
/*
1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
1×4=4 2×4=8 3×4=12 4×4=16
1×5=5 2×5=10 3×5=15 4×5=20 5×5=25
1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36
1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49
1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64
1×9=9 2×8=16 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81 */
for (int i = 1; i <= 9; i++) {
System.out.println(1 + "*" + i + "="+ 1*i );
}
}
}
package Java流程控制;
public class 循环结构_for循环4练习3_2嵌套 {
public static void main(String[] args) {
// 打印九九乘法表_2
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= 9; i++) {
System.out.println(j + "*" + i + "="+ j*i );
}
}
}
}
package Java流程控制;
public class 循环结构_for循环4练习3_3去除重复 {
public static void main(String[] args) {
// 打印九九乘法表_2
/*总结
1.先打印第一列，比较简单
2.把固定的 1 再用一个循环包起来
3.用 i <= j 判断，去除重复项
4.调整样式 */
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(i + "*" + j + "="+ i*j + "\t");
}
System.out.println();
}
}
}
在 Java 5 中引入了一种主要用于数组的增强型 for 循环
for (声明语句 : 表达式)
{
//代码句子
}
package Java流程控制;
public class 循环结构_增强型for循环 {
public static void main(String[] args) {
int [] numbers = {10,20,30,40,50}; //这就是定义了一个数组
//遍历数组中的元素 ：
//1.用普通 for 循环
for (int i = 0; i < 5;i ++){ //定义 i 的初始值 为 0；判断条件 小于5；迭代 自增
System.out.println(numbers[i]); //numbers[i] 的意思就是取出数组里面的第 i 个元素
}
System.out.println("==============================");
//2.用 增强型 for 循环
for (int x:numbers){ //把 numbers 数组里每一项的值 直接赋值给了 int x 也就是简化流程
System.out.println(x);
}
}
}
package Java流程控制;
public class break和continue1_break {
public static void main(String[] args) {
int i = 0;
while (i < 100){
i ++;
System.out.println(i);
if (i == 30){ //当 i = 30 的时候
break; //跳出这个循环 (强制退出循环)
}
}
System.out.println("==============================");
System.out.println(i);
//这里仍会输出 30 ，这是因为 break 虽跳出了循环，但并没有终止程序
}
}
package Java流程控制;
public class break和continue2_continiu {
public static void main(String[] args) {
int i = 0;
while (i < 100){
i++;
if (i%10 == 0){ //当 i 能被10整除时
System.out.println(); //换行
continue; /*终止这次循环
(也就是不往下走了 不输出 10 的倍数。而是进行下一次是否执行循环的判定) */
}
System.out.print(i);
}
}
}
package Java流程控制;
public class 关于goto关键字_拓展<i> {
//打印 101 - 150 之间的所有质数
//质数是在大于1的自然数中，只有1和它本身 两个因数 的自然数
public static void main(String[] args) {
int count = 0 ;
outre:for (int i = 101;i < 150;i ++){
for (int j = 2;j < i/2;j++){
if (i % j == 0){ //当能被除了 1 和 小于自己1/2 的数字 整除 的时候
continue outre; //则回到标签的位置 (也就是从内部的循环 跳到了 外部的循环)
//由于使用起来十分麻烦 不建议使用标签
}
}
System.out.print(i+" ");
}
}
}
package Java流程控制;
public class 流程控制的练习 {
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();
}
}
}
end .
标签：遍历 统计 区别 客户端连接 表示 迭代 字符串的比较 未在 图标
原文地址：https://www.cnblogs.com/muriyulin/p/14520822.html
