目录
键盘录入
1）基本语法
StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()
2）案例实操
import scala.io.StdIn
object TestInput {
def main(args: Array[String]): Unit = {
// 1 输入姓名
println("input name:")
var name = StdIn.readLine()
// 2 输入年龄
println("input age:")
var age = StdIn.readShort()
// 3 输入薪水
println("input sal:")
var sal = StdIn.readDouble()
// 4 打印
println("name=" + name)
println("age=" + age)
println("sal=" + sal)
}
}
流程控制
分支控制 if-else
让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支
单分支
1）基本语法
if (条件表达式) {
执行代码块
}
2）案例实操
object TestIfElse {
def main(args: Array[String]): Unit = {
println("input age:")
var age = StdIn.readShort()
if (age > 18){
println("age>18")
}
}
}
双分支
1）基本语法
if (条件表达式) {
执行代码块1
} else {
执行代码块2
}
2）案例实操
object TestIfElse {
def main(args: Array[String]): Unit = {
println("input age:")
var age = StdIn.readShort()
if (age > 18){
println("age>18")
}else{
println("age<=18")
}
}
}
多分支
1）基本语法
if (条件表达式1) {
执行代码块1
}
else if (条件表达式2) {
执行代码块2
}
……
else {
执行代码块n
}
2）案例实操
object TestIfElse {
def main(args: Array[String]): Unit = {
println("请输入成绩")
val grade = StdIn.readInt()
if (grade == 100){
println("成绩为100分，奖励一辆BM")
}else if (grade > 80 && grade <= 90){
println("奖励一台iphone")
}else{
println("什么奖励也没有")
}
}
}
（3）注意：
如果大括号{}内的逻辑代码只有一行，大括号可以省略。
Scala中是没有三元运算符，因为可以这样简写
object TestIfElse {
def main(args: Array[String]): Unit = {
// Java
// int result = flag?1:0
// Scala
var flag:Boolean = true
var result = if(flag) 1 else 0
println(result)
}
}
嵌套分支
1）基本语法
if(){
if(){
}else{
}
}
2）案例实操
object TestIfElse {
def main(args: Array[String]): Unit = {
println("输入性别：")
var gender = StdIn.readChar()
if (gender == '男'){
println("男子组")
}else{
println("女子组")
println("输入成绩：")
var grade = StdIn.readDouble()
if (grade > 8.0){
println("你被淘汰了")
}else{
println("成功晋级")
}
}
}
}
switch 分支结构
在Scala中没有Switch，而是使用模式匹配来处理。
后面涉及到匹配模式在补充
for 循环
to
1）基本语法
for(i <- 1 to 3){
print(i + " ")
}
（1）i 表示循环的变量，<- 规定to
（2）i 将会从 1-3 循环，前后闭合
object TestFor {
def main(args: Array[String]): Unit = {
for(i <- 1 to 10){
println("宋宋，喜欢海狗人参丸"+i)
}
}
}
until
1）基本语法
for(i <- 1 until 3) {
print(i + " ")
}
println()
（1）这种方式和前面的区别在于i是从1到3-1
（2）即使前闭合后开的范围
2）案例实操
object TestFor {
def main(args: Array[String]): Unit = {
for(i <- 1 until 10+1){
println("宋宋，喜欢海狗人参丸"+i)
}
}
}
循环守卫
1）基本语法
for(i <- 1 to 3 if i != 2) {
print(i + " ")
}
说明：
（1）循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue。
（2）上面的代码等价
for (i <- 1 to 3){
if (i != 2) {
print(i + "")
}
}
2）案例实操
object TestFor {
def main(args: Array[String]): Unit = {
for (i <- 1 to 10 if i != 5) {
println(i + "")
}
}
}
循环步长
1）基本语法
for (i <- 1 to 10 by 2) {
println(“i=” + i)
}
说明：by表示步长
2）案例实操
for (i <- 1 to 10 by 2) {
println("i=" + i)
}
//输出结果
i=1
i=3
i=5
i=7
i=9
嵌套循环
1）基本语法
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}
说明：没有关键字，所以范围后一定要加；来隔断逻辑
上面的代码等价：
for (i <- 1 to 3) {
for (j <- 1 to 3) {
println("i =" + i + " j=" + j)
}
}
引入变量
1）基本语法
for(i <- 1 to 3; j = 4 - i) {
println(“i=” + i + " j=" + j)
}
说明：
（1）for推导式一行中有多个表达式时，所以要加；来隔断逻辑
（2）for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下
for {
i <- 1 to 3
j = 4 - i
} {
println("i=" + i + " j=" + j)
}
上面的代码等价于
for (i <- 1 to 3) {
var j = 4 - i
println("i=" + i + " j=" + j)
}
循环返回值
1）基本语法
val res = for(i <- 1 to 10) yield i
println(res)
说明：将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字
object TestFor {
def main(args: Array[String]): Unit = {
var res = for( i <-1 to 10 ) yield {
i * 2
}
println(res)
}
}
//输出结果
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
while循环
1）基本语法
循环变量初始化
while (循环条件) {
循环体(语句)
循环变量迭代
}
说明：
（1）循环条件是返回一个布尔值的表达式
（2）while循环是先判断再执行语句
（3）与if语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()
（4）因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，也就违背了函数式编程的重要思想（输入=>函数=>输出，不对外界造成影响），所以不推荐使用，而是推荐使用for循环。
2）案例实操
需求：输出10句 “宋宋，喜欢海狗人参丸”
object TestWhile {
def main(args: Array[String]): Unit = {
var i = 0
while (i < 10) {
println("宋宋，喜欢海狗人参丸" + i)
i += 1
}
}
}
do…while 循环
1）基本语法
循环变量初始化;
do{
循环体(语句)
循环变量迭代
} while(循环条件)
说明
（1）循环条件是返回一个布尔值的表达式
（2）do…while循环是先执行，再判断
2）案例实操
需求：输出10句 “宋宋，喜欢海狗人参丸”
object TestWhile {
def main(args: Array[String]): Unit = {
var i = 0
do {
println("宋宋，喜欢海狗人参丸" + i)
i += 1
} while (i < 10)
}
}
多重循环
1）基本说明
（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】
（2）实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
（3）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
2）案例实操
需求：打印出九九乘法表
object TestWhile {
def main(args: Array[String]): Unit = {
var max = 9
for (i <- 1 to max) {
for (j <- 1 to i) {
print(j + "*" + i + "=" + (i * j) + "\t")
}
println()
}
}
}
while 循环中断
1）基本说明
Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。scala中使用breakable控制结构来实现break和continue功能。
2）案例实操
需求一：循环遍历10以内的所有数据，数值为5，结束循环（break）
import util.control.Breaks._
object TestBreak {
def main(args: Array[String]): Unit = {
var n = 1
breakable {
while (n < 10) {
println("n=" + n)
n += 1
if (n == 5) {
break()
}
}
}
println("exit")
}
}
需求二：循环遍历10以内的所有数据，奇数打印，偶数跳过（continue）
import util.control.Breaks._
object TestBreak {
def main(args: Array[String]): Unit = {
var n = 0
while (n < 10) {
breakable {
n += 1
if (n % 2 != 0) {
println(n)
} else {
println("continue")
break()
}
}
}
}
}
3）注意事项
（1）break：breakable放在循环外
（2）continue：breakable放在循环内
209
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
