Scala之（判断循环及元组）

数组的知识点的讲解，包括数组的遍历输出，数组的常用的函数等等。
If判断知识点的讲解，包括三目运算符的讲解，以及CASE模式匹配的简单引入。
For 循环中的遍历以及与breakable的完美结合，去展示相当于java中的continue与break 的 实现。
Do while 与 while的区别于对比及知识点的讲解.
（1）判断语句
在Scala中，所有的值都有类型，包括数值和函数。
①　图示

②　语法
if(布尔表达式 1){
// 如果布尔表达式 1 为 true 则执行该语句块
}else if(布尔表达式 2){
// 如果布尔表达式 2 为 true 则执行该语句块
}else if(布尔表达式 3){
// 如果布尔表达式 3 为 true 则执行该语句块
}else {
// 如果以上条件都为 false 执行该语句块
}
③　案例
object Test {
def main(args: Array[String]) {
var x = 30;

if( x == 10 ){
println(“X 的值为 10”);
}else if( x == 20 ){
println(“X 的值为 20”);
}else if( x == 30 ){
println(“X 的值为 30”);
}else{
println(“无法判断 X 的值”);
}
}}
④　小结
如果布尔表达式为 true 则执行大括号内的语句块，else 内的语句块可以在布尔表达式为 false 的时候执行。
（2）循环语句
Scala 提供一个轻量级的标记方式用来表示 序列推导。推导使用形式为 for (enumerators) yield e 的 for 表达式，此处 enumerators 指一组以分号分隔的枚举器。一个 enumerator 要么是一个产生新变量的生成器，要么是一个过滤器。for 表达式在枚举器产生的每一次绑定中都会计算 e 值，并在循环结束后返回这些值组成的序列。
①　图示

②　语法
for( var x <- Range ){
statement(s);
}
以上语法中，Range 可以是一个数字区间表示 i to j ，或者 i until j。左箭头 <- 用于为变量 x 赋值。
③　案例
case class User(name: String, age: Int)

val userBase = List(User(“Travis”, 28),
User(“Kelly”, 33),
User(“Jennifer”, 44),
User(“Dennis”, 23))
val twentySomethings =
for (user <- userBase if (user.age >=20 && user.age < 30))
yield user.name // i.e. add this to a list

twentySomethings.foreach(name => println(name)) // prints Travis Dennis

这里 for 循环后面使用的 yield 语句实际上会创建一个 List。因为当我们说 yield user.name 的时候，它实际上是一个 List[String]。 user <- userBase 是生成器，if (user.age >=20 && user.age < 30) 是过滤器用来过滤掉那些年龄不是20多岁的人。

下面这个例子复杂一些，使用了两个生成器。它计算了 0 到 n-1 的所有两两求和为 v 的数字的组合：

def foo(n: Int, v: Int) =
for (i <- 0 until n;
j <- i until n if i + j == v)
yield (i, j)

foo(10, 10) foreach {
case (i, j) =>
println(s"($i, $j) ") // prints (1, 9) (2, 8) (3, 7) (4, 6) (5, 5)

}
这里 n == 10 和 v == 10。在第一次迭代时，i == 0 并且 j == 0 所以 i + j != v 因此没有返回值被生成。在 i 的值递增到 1 之前，j 的值又递增了 9 次。如果没有 if 语句过滤，上面的例子只会打印出如下的结果：
(0, 0) (0, 1) (0, 2) (0, 3) (0, 4) (0, 5) (0, 6) (0, 7) (0, 8) (0, 9) (1, 1) …
④　小结
Scala中的for循环语法和java中for循环语法不一致，一定要注意，语法中的Range 可以是一个数字区间表示 i to j ，或者 i until j。左箭头 <- 用于为变量 x 赋值。

（3）循环跳出语句
Scala 提供一个轻量级的标记方式用来表示 序列推导。推导使用形式为 for (enumerators) yield e 的 for 表达式，此处 enumerators 指一组以分号分隔的枚举器。一个 enumerator 要么是一个产生新变量的生成器，要么是一个过滤器。for 表达式在枚举器产生的每一次绑定中都会计算 e 值，并在循环结束后返回这些值组成的序列。

①　语法
//结束循环
breakable{
for( var x <- Range ){

statement(s);
if(布尔值){

break
}
}
}

//结束本次循环，继续下次循环
for( var x <- Range ){
breakable{

statement(s);
if(布尔值){

break
}

}
}

②　案例

/**

• 循环跳出语句
  */
  object TiaoChuTest {
  def main(args: Array[String]): Unit = {

for(i <- 0 to 10 if(i < 5)){
println(i)
}

//break
//continue

//breakable放在循环体外，则是break的效果
breakable{

for(i <- 0 to 10){
if(i == 5){
break()
}
println(i)
}
}

//breakable放在循环体内，则是continue的效果
for (i <- 0 to 10) {

breakable {
if (i == 5) {

break()
}

println(i)
}
}

}
}

③　小结
breakable放在循环体外，则是java中break的效果。
breakable放在循环体内，则是java中continue的效果。

（4）元组
元组在Scala语言中是一个非常有用的容器对象。与列表一样，元组也是不可变的；但是与列表不同，元组可以包含不同类型的元素。

①　语法
//定义
var 变量 = ( 数据，数据，数据 )
②　案例

object TupleTest {
def main(args: Array[String]): Unit = {

//使用小括号括起来，元素之间用逗号分隔，元素没有类型限制
//元组的下标从1开始，元素不可修改，最多22个元素

//定义
var t = (2, 3, “abc”)
var t11 = (1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,21,22)
var t1 = (2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,21,22,23)

//获取数据
// println(t._1)
// println(t._2)
// println(t._3)

//不可修改其中元素
// t._1 = 4
//
// var t2 = (4, 5, “123”)
//
// t = t2
// println(t._1)
// println(t._2)
// println(t._3)

//遍历输出
// for(i <- 0 until t.productArity){
// println(t.productElement(i))
// }

//特殊元组
// var tt = (“a”,“b”)
// println(tt._1)
// println(tt._2)

// var tt2 = “a” -> “b” -> “c” -> “d”->“e”->“f”
var tt2 = “a” -> “b” -> “c”
var tt3 = ((“a”,“b”),“c”)
println(tt2._1._2)
}
}

③　小结
元组的元素使用小括号括起来，元素之间用逗号分隔，元素没有类型限制。
元组的下标从1开始，元素不可修改，一个元组最多可以有22个元素。

（5）数组
Scala 语言中提供的数组是用来存储固定大小的同类型元素，数组对于每一门编辑应语言来说都是重要的数据结构之一。

①　语法
//定义方式一
var 变量 = new Array数据类型

//定义方式二
var 变量 = Array( 数据，数据，数据 )

②　案例

/**

• 数组
• 类型单一，长度固定，默认初始值，Int型的为0，String型的为null
  */
  object ArrayTest {
  def main(args: Array[String]): Unit = {
  //定义
  //指定长度，再进行赋值
  // var arr1 = new ArrayString
  //
  //
  // //单个元素获取
  // println(arr1(0))
  //
  // //修改
  // arr1(0) = “helloworld”
  //
  //
  // //遍历输出
  // for(i <- 0 until arr1.size){
  // println(arr1(i))
  // }

//定义二
var arr2 = Array(“a”,“b”,“c”,“d”,“e”)

//遍历输出
// for(i <- arr2){
// println(i)
// }

// arr2.foreach( (s:String) => { println(s) })
// arr2.foreach(println(_))

// println(arr2.mkString(","))

//其他方法

var arr3 = Array(3,2,5,7,9,1,0,23,19,200)

println(arr3.max)
println(arr3.min)
println(arr3.sum)
println(arr3.count(i => true))
}
}

③　小结
数组的数据类型单一，长度固定，默认初始值，Int型的为0，String型的为null。

4．【练习案例】
1.使用scala语言中的for语句，输出1到30之内所有的偶数（50分）
2.使用scala语言中的while语句，输出1到50之内所有7的倍数（50分）
5.将变量“t”的值输出到控制台 (20分)
package daytest

object day2 {
def main(args: Array[String]): Unit = {
for(j<-1 to 30 if(j%20))
{
println(j)
}
var k:Int = 1
println(“以下打印7的倍数”)
while (k<50 )
{
if(k%70)
{
println(k)
}
k +=1
}
}
}
5．【能力提升】
通过这个的循循诱导了解以下图之间的关系