java 多行输入 控制台 java输入多行整数

目录

• 关于Java中从键盘输入的语句

• nextxxx()、next()、nextLine()的区别

• 语句

• if和if else语句
• Switch语句
• for语句
• while和do..while
• break和continue

---

前言

一如既往的
试着
试着同命运
拉近
挨着肩膀
呼吸
跳动着脉搏
所在的
是
那一声呼喊
命运的诉说

---

关于Java中从键盘输入的语句

关于Java语句中从键盘接受数据到控制台的语法有很多，我们今天给大家讲述最常用也是最广泛的一种语法：Scannner

从键盘输入语法：

public class PutinText
{
 public static void main(String[] args){
 
java.util.Scanner s=new java.util.Scanner(System.in);
System.out.print("请输入：");
s.nextLine();
  }
}

控制台结果：

nextxxx()、next()、nextLine()的区别

nextInt() : 通俗的来说，就是读取int类型的数值【读取到浮点型字符串等就会报错】
nextFloat() 和 nextDouble() 一样，需要输入什么类型的数值，就选择什么类型。
语法：next数据类型()

next()：只读取输入，直到输入空格的时候。也就是说，当遇到空格的时候就读取停止了

nextLine()：读取输入所有的符号，包括单词之间的空格【除了回车之外】【当我们输入字符串的时候可以使用此种语法】

nextxxx() 代码如下：

public class PutinText
{
 public static void main(String[] args){
  java.util.Scanner s=new java.util.Scanner(System.in);
  System.out.print("请输入一个整数：");
  int a=s.nextInt();
  System.out.print("请输入一个小数：");
  Double b=s.nextDouble();
  System.out.println("结果如下：");
  System.out.println(a);
  System.out.println(b);
 }
}

输出结果：

next()、nextLine() 的区别代码如下：

public class PutinText01
{ 
 public static void main(String[] args){
  java.util.Scanner s=new java.util.Scanner(System.in);
  System.out.println("请输入:I Love China!");
  String c=s.nextLine();//接受输入的全部字符
  System.out.println("请输入:ILoveChina!");
  String d=s.next();//接受字符到空格时停止
  System.out.println("请输入:I Love China!");
  String e=s.next();//接受字符，遇见空格停止；输出：I
  System.out.println("结果如下：");
  System.out.println(c);
  System.out.println(d);
  System.out.println(e);
    }
 }

输出结果：

语句

if和if else语句

if和if else控制语句

f语句的语法结构：有四种

1，

if(布尔表达式){
 Java语句1；
 Java语句2；
 Java语句3；
 .........
 }

2，

if(布尔表达式){//当布尔表达式为真，执行if{}里面的程序  
Java语句1；
Java语句2；
Java语句3
.........
}else{  //当布尔表达式为假，执行else{}里面的程序
Java语句1；
Java语句2；
Java语句3；
.........
}

3，

if(布尔表达式){          
 Java语句1；
 Java语句2；
 Java语句3；
 .........
 }else if(布尔表达式){             
 Java语句1；
 Java语句2；
 Java语句3；
 .........
 }else if(布尔表达式)...
 //只要有一个分支语句执行判断成功，则该整体语句结束

4，

if(布尔表达式){          
 Java语句1；
 Java语句2；
 Java语句3；
 .........
}else if(布尔表达式){
 Java语句1；
 Java语句2；
 Java语句3；
 .........
}else{
 Java语句1；
 Java语句2；
 Java语句3；
 .........
}

例子1：
请输入您的成绩，判断您的成绩范围。
要求：成绩满分100分
等级：
【90-100】 A
【80-90】 B
【70-80】 C
【60-70】 D
【0-60】 E

代码如下：

public class IfText01
{
 public static void main(String[] args){
  java.util.Scanner s=new java.util.Scanner(System.in);
  System.out.print("请输入您的成绩：");
  Double score = s.nextDouble();
  String cj="A";
  if(score<0 || score>100) {
   cj="您输入的成绩无效,请重新输入！";
   
   }else if(score>=90){
   cj="你的成绩等级为：A";

   }else if(score>=80){
   cj="你的成绩等级为：B";

  }else if(score>=70){
   cj="你的成绩等级为：C";

  }else if(score>=60){
   cj="你的成绩等级为：D";
 
  }else{
   cj="你的成绩等级为：E";

  }
      System.out.println(cj);
       }
}

输出结果：

例子二：
输入您的年龄，判断您属于什么期间
【大于60】老年人
【35-60】中年人
【18=35】青年
【10-18】青少年
【3-10】儿童
【0-3】幼儿

代码如下：

public class Text02
{
 public static void main(String[] args){
  java.util.Scanner s=new java.util.Scanner(System.in);
  System.out.print("请输入您的年龄：");
  Double age=s.nextDouble();
  String str="少年";
  if(age<0 || age>160){
   str="您输入的年龄不合法";
  }else if(age>60){
   str="老年人";
  }else if(age>35){
   str="中年";
  }else if(age>18){
   str="青年";
  }else if(age>10){
   str="青少年";
  }else if(age>3){
   str="儿童";
  }else {
   str="幼儿";
  }
  System.out.println(str);
   }
}

输出结果：

Switch语句

switch语句的执行原理:

switch后面小括号当中的数据"和case后面的、数据"进行一一匹配,匹配成功的分支执行，按照自上而下的顺序依次匹配

匹配成功的分支执行,分支当中最后有"break;:"语句的话,整个switch语句终止.

匹配成功的分支执行,分支当中没有"break,:"语句的话,直接进入下一个分支执行(不进行匹配)
这种现象被称为case穿透现象。【提供break;语句可以避免穿透】

所有分支都没有匹配成功,当有default的语句话,会执行default分支当中的程序

switch后面和case后面只能是int或者String类型的数据,不能是探测其它类型

当然byte, short, char也可以直接写到switch和case后面,
因为它们可以进行自动类型转换byte, short,char可以自动转换成int类型

JDK6的, switch和case后面只能探测int类型

JDK7之后包括7版本在内,引入新特性, switch关键字和case关键字后面可以探测int或String类型的数据

case可以合并：

int a=100;
switch(a){
case 1: case 2: case 3:
System.out.println(“lllll”);
}

例如还是求成绩等级的问题【例子一】

代码如下：

public class SwitchText
{
 public  static void main(String[] args){
  java.util.Scanner s=new java.util.Scanner(System.in);
  System.out.print("请输入您的成绩：");
  double num=s.nextDouble();
  switch((int)(num/10)){   //将输入成绩转换类为整型
   case 9 : case 10 :
    System.out.println("你的成绩等级为：A");
       break;
   case 8 :
    System.out.println("你的成绩等级为：B");
       break;
   case 7 :
    System.out.println("你的成绩等级为：C");
       break;
   case 6 :
    System.out.println("你的成绩等级为：D");
       break;
   case 5 :case 4 :case 3 :case 2:case 1:case 0:
    System.out.println("你的成绩等级为：E");
       break;
   default:
    System.out.println("您输入的成绩不合法！");
    }
  }
 
}

输出结果：

例子二：

请简单的做出一个计算器系统，会做+ - * / %运算

代码如下：

public class SwitchText01
{
 public static void main(String[] args){
  java.util.Scanner s=new java.util.Scanner(System.in);
  System.out.print("请输入第一个数字：");
  Double num1=s.nextDouble();//输入一个double类型的数字
  System.out.print("请输入你的运算符【仅限于+-*/%】：");
  String operator=s.next();//输入运算符
  System.out.print("请输入第二个数字：");
  Double num2=s.nextDouble();//输入一个double类型的数字
  Double result=(double)0;//Java默认右边的数字为int类型，将int类型强制转换成double类型
  switch(operator){
   case "+":
    result=num1+num2;//+法运算
   break;
   case "-":
    result=num1-num2;//-法运算
   break;
   case "*":
    result=num1*num2;//*法运算
   break;
   case "/":
    result=num1/num2;// /法运算
   break;
   case "%":
    result=num1%num2;//  %运算
   break;
   default :
    System.out.println("输入格式不对！请重新输入");
    }
    System.out.println("输出的结果为:"+num1+operator+num2+"="+result);
     }
}

输出结果：

for语句

for控制语句在编程语言中很常见，例如对循环变量的控制等；在编程问题上，for语句的应用，大大减少了编程冗余度
语法规则：

1，
for(初始化表达式；布尔表达式；更新表达式){
 java语句;
 .....
}

2，
for(初始化表达式；布尔表达式；更新表达式){
 for(初始化表达式；布尔表达式；更新表达式){
    .....//这里也可以跟if语句等
 java语句;
 }
}

举个例子：如果要在键盘上输出1-10数字，该怎么做？

传统上只要输出1-10就可以，常规做法：

public class ForText
{
 public static void main(String[] args){
  System.out.println(1);
  System.out.println(2);
  System.out.println(3);
  System.out.println(4);
  System.out.println(5);
  System.out.println(6);
  System.out.println(7);
  System.out.println(8);
  System.out.println(9);
  System.out.println(10); 
     }
  }

输出结果：

上述输出结果达到了题目要求，但如果题目要求输出1-10000的数字，显然这种方法不可取，那我们可以考虑用一种累加的方式，每一次输出自身加1的结果，将最大控制累加到10000就停止累加，这个时候我们就可以用for循环语句

上述代码如下：

public class ForText
{
 public static void main(String[] args){
   int i;
   for(i=1;i<=10000;i++){//定义i初始量为1；最高不超过10000；实现i每次循环加1
   System.out.print(i+" ");//以横向空格方式输出
      }
    }
  }

输出结果：

由此我们可以看出，for语句在此处的重要性，大大减少了程序的写入，效率得到提高。

例子1：
实现1-100的累加和
代码如下：

public class ForText
{
 public static void main(String[] args){
  int i;
  int sum=0;//定于sum变量，初始赋值0
  for(i=1;i<=100;i++){//定义初始值为1；i的值<=100；i自身累加1
  sum+=i;//实现i的自加，相当于sum=sum+i;
  }
   System.out.println("1-100的累加和为："+sum);
    }
}

输出结果：

例子2：
请在屏幕上输出99乘法表：如下：

1* 1=1
2* 1=2 2* 2=4
3* 1=3 3* 2=6 3* 3=9
… … … … … … … …
9* 1=9 … … … … … … … …9* 9=81

分析：

第几行	表达式个数
1	1
2	2
3	3
…	…
n	n

则第n行的表达式个数不超过行数；我们把表达式个数记为j；
则j<=n;
那么我们可以将外层循环变量表达为行数，不超过9；而内层则不超过行数；再将内外层变量相乘，得到我们想要的结果

代码如下：

public class ForText
{
 public static void main(String[] args){
  int i,j;
  /*
  当i=1时，内层循环j<=1;内层循环执行一次输出
  当i=2时，内层循环j<=2;内层循环执行两次输出
  .......................
  当i=9时，内层循环j<=9;内=层循环执行9次输出
  */
  for(i=1;i<=9;i++){//外层循环变量为行数，不超过9
   for(j=1;j<=i;j++){//内层循环变量小于外层
    System.out.print(i + "*" + j+ "=" +i*j+" ");
   }
   System.out.println();//将1行输出完换行输出下一行
     }
 }
}

while和do…while

while语法结构：

while(布尔表达式){
  循环体;
}

do…whlie语法结构：

do{
循环体;
}while(布尔表达式);

while和do…whlie有一点不同：

while语句先判断布尔表达式是否为真，然后再进行循环；【按部就班】

do…while语句先执行一次循环，再看布尔表达式是否为真，为真，则继续循环，为假，则停止循环【先斩后奏】

例子1：在控制台输出1-10数字；

whlie:

public class WhileText
{
 public static void main(String[] args){
  int i=1;//定义初始变量i；并赋值为1；
  while(i<=10){//控制循环变量i的大小，如果i为真则执行循环，为假，则不执行循环；
  System.out.println("第"+i+"个数字:"+i);//输出i的值；
  i++;//将i自加1；
     }
   }
}

结果如下：

do…whlie:

public class WhileText
{
 public static void main(String[] args){
  int i=1;
  do { 
      System.out.println("第"+i+"个数字:"+i);//先打印输出循环变量i；
      i++;//实现i的自加1
     }while (i<=10);//判断布尔表达式的真假，控制循环次数
   }
}

输出结果：

例子2：
实现1-100的累加和，用whlie和do…while循环：

/*
  while循环
*/
public class WhileText01
{
 public static void main(String[] args){
  int i=1;
  int sum=0;
  while(i<=100){
   sum+=i;
   i++;
   }
      System.out.println("1-100的累加和为："+sum);
 }
}

结果如下：

/*
   do ...whlie 循环：
*/
public class WhileText01
{
 public static void main(String[] args){
  int i=1;
  int sum=0;
  do{
   sum+=i;
   i++;
  }while (i<=100);
      System.out.println("1-100的累加和为："+sum);
 }
}

输出结果为：

break和continue

break语句顾名思义是终止的意思，当用在循环语句当中，表达终止该循环【除了和switch语句搭配使用，还可用于for循环当中】
continue顾名思义是继续的意思，当该表达式为真时，跳过该循环，直接进入下一循环；

例子1：
输出1-100；当数字达到50时，停止循环，输出数字50

public class WhileText01
{
 public static void main(String[] args){
  int i;
  for(i=1;i<=100;i++){
    if(i==50)//当数字i为50时，for循环停止
     break;
  }
   System.out.println(i); //输出i的值
 }
}

输出结果如下;

例子2：

请输出1 3 4 5 6 7 8 9 10数字

public class WhileText01
{
 public static void main(String[] args){
  int i;
  for(i=1;i<=10;i++){
    if(i==2)//当变量i==2是，直接跳过该循环，进入下一循环
     continue;
    System.out.println(i); //输出i的值
  }
 
 }
}

输出结果如下：

例子2：请将99乘法表只输出前两列，用break语句控制

public class WhileText01
{
 public static void main(String[] args){
  int i;
  int j;
  for(i=1;i<10;i++){//99乘法表总共9行
    for(j=1;j<=i;j++){//每行表达式等于行数
     if(j==3){//当表达式为3时【即列数为3时】，循环中断，
     break;//break控制的是离它最近的for循环；
     }
      System.out.print(j+"*"+i+"="+i*j+" ");
    }
    System.out.println();
  }
   
 }
}

输出结果如下：

请将99乘法表除了第2列之外，其他输出；

public class WhileText01
{
 public static void main(String[] args){
  int i;
  int j;
  for(i=1;i<10;i++){
    for(j=1;j<=i;j++){
     if(j==3){//当内存循环为3，即第2列时，
     continue;//跳出该循环，进行下一循环
     }
      System.out.print(j+"*"+i+"="+i*j+" ");
    }
    System.out.println();
  }
   
 }
}

输出结果如下：

---

作为了解：

break和continue控制的是离它最近的循环

但如果要想控制外部循环，如何去做？

给循环起名字，berak+“所起的名字”/continue+“所起的名字”

还是上面的例子，我们分别看一下效果：

public class WhileText01
{
 public static void main(String[] args){
  int i;
  int j;
  a:for(i=1;i<10;i++){
   b: for(j=1;j<=i;j++){
     if(j==3){
     break a;//当外部循环变量达到3时，结束外部循环，整个循环结束
     }
      System.out.print(j+"*"+i+"="+i*j+" ");
    }
    System.out.println();
  }
   
 }
}

输出结果如下：

这种方式在编程语言当中基本上都有，只不过不常用而已，作为了解，当别人编写用到的时候，能够识别。

---

时间从不曾缓慢抬起它的双脚
而走过的地方
必将留下痕迹…

---