Scala教程(二十)For循环模式匹配与表达式

1 For循环模式匹配与表达式

1.1模式匹配下的For循环

object ForAdvanced {
def main(args: Array[String]): Unit = {
// for 调用的foreach方法
for (i <- List(1, 2, 3, 4, 5)) {
// 执行结果：1、2、3、4、5、
print(i + "、");
}
println();

// 变量绑定，用index绑定Flink，给Flink设置别名
for(index@"Flink" <- List("Hadoop","Spark","Flink")){
// 执行结果：Flink
println(index);
}

// 条件表达格=>模式匹配，匹配value值为Hadoop的元素
for((language,"Hadoop") <- Set("Scala" -> "Spark","Java" -> "Hadoop")){
// 执行结果：Java
println(language);
}

// 条件表达格式=》模式匹配，value的类型为Int类型的
for((k,v:Int) <-List(("Spark" -> 5),("Hadoop"->"BigData"))){
// 执行结果：Spark
println(k)
}
}
}

1.2 模式匹配下的赋值语句

object AssinmentInternals {
def main(args: Array[String]): Unit = {
// @符号，将a绑定到常量b,a为b的别名
val a @ b = 1000;
// 执行结果：a==1000,b==1000
println("a==" + a + ",b==" + b);

// 模式匹配，返回二元元组，c,d变量小字
val (c, d) = (1000, 2000);
// 执行结果：c==1000,d==2000
println("c==" + c + ",d==" + d);

// 编译失败：大写字符会被编译器当作常量
// val (e,F) = (1000,2000);

// 模式匹配，Array赋值
val Array(g, h) = Array(1000, 2000);
// 执行结果：g==1000,h==2000
println("g==" + g + ",h==" + h);

// 编译失败：大写字符会被编译器当作常量
// val Array(i,J) = Array(1000,2000);

// 模式匹配：传递的值是否是1，如果为1则匹配
object Test { val 1 = 1 }

// 模式匹配 val 1= 2 匹配不正确，lazy级别，只有在真正使用的情况下才报错。
object Test2 { val 1 = 2 }
}
}

1.3 模式匹配下的提取器

object :> {
def unapply[A](list: List[A]) = {
// list.init：除最后一个元素以外的所有元素
// list.last：最后一个元素
Some((list.init, list.last))
}
}

object ExtractorAdvanced {
def main(args: Array[String]): Unit = {
// 模式匹配9，执行结果返回：Hadoop
(1.to(9)).toList match { case _ :> 9 => println("Hadoop") }
// 模式匹配，右结合，先匹配9再匹配8，执行结果：Spark
(1.to(9)).toList match { case x :> 8 :> 9 => println("Spark") }
// 模式匹配，先匹配括号里面的，即：:>(_,8)，匹配成功后:>(:>(_,8),9)，执行结果：Flink
(1.to(9)).toList match { case :>(:>(_, 8), 9) => println("Flink") }
}
}

1.4 Scala中For表达式

// 声明Person类
case class Person(name: String, isMan: Boolean, children: Person*)
object ForExpressive {
def main(args: Array[String]): Unit = {
// 定对象lauren
val lauren = Person("Lauren", false);
// 定对象rocky
val rocky = Person("Rocky", true)
// 定对象vivian
val vivian = Person("Vivian", false, lauren, rocky);

val persons = List(lauren, rocky, vivian)

/*
*  persons.filter 条件过滤Person对象中 isMan为true
*  flatMap 返回的多个结果，合并到一个List
*  person.children.map 将每个子元素的person和child的名称返回List
*/
val result = persons.filter(person => !person.isMan).
flatMap(person => (person.children.map(child => (person.name, child.name))));
// 执行结果：List((Vivian,Lauren), (Vivian,Rocky))
println(result);

// for循环条件过滤Person对象中 isMan为true
for (person <- persons; if !person.isMan; child <- person.children) yield (person.name, child.name);
// 执行结果：List((Vivian,Lauren), (Vivian,Rocky))
println(result);

/*
*  生成器：person <- persons;
*  定义：name = person.name;
*  过滤器：if !person.isMan;
*  处理：  child <-person.children
*/
for (person <- persons; name = person.name; if !person.isMan; child <- person.children)
yield (person.name, child.name);

 // for表达式，也可用大括号
for {person <- persons; name = person.name; if !person.isMan; child <- person.children }
yield (person.name, child.name);

//　多生成器
val content = for (x <- List(1, 2, 3); y <- List("Hadoop", "Spark", "Filnk")) yield (x, y)
// 执行结果：List((1,Hadoop), (1,Spark), (1,Filnk), (2,Hadoop), (2,Spark), (2,Filnk), (3,Hadoop), (3,Spark), (3,Filnk))
println(content);
}
}

1.5 For表达式查询过滤

// 定义Book类
case class Book(title: String, authors: List[String])
object Book {
def main(args: Array[String]): Unit = {
val books: List[Book] = List(
Book("Structure and Interpretation", List("Abelson", "Harold", "Sussman")),
Book("Principles of Compiler Design", List("Aho", "Alfred", "Ullman", "Jeffrey")),
Book("Programming in Modula-a", List("Wirth,Niklaus")),
Book("Introduction to Functional Programming", List("Bird", "Richard")),
Book("The Java Language Specification", List("Gosling,James", "Joy,Bill", "Steele Guy", "Bracha,Gilad")));

// for循环遍历每本书下的所有的作者，查询以Gosling的书，返回该书的标题
var result = for (b <- books; a <- b.authors if a.startsWith("Gosling")) yield (b.title);
// 执行结果：List(The Java Language Specification)
println(result)

// for循环遍历每本书所有的题标中包含Programming字符
var result2 = for (book <- books; if (book.title.indexOf("Programming")) >= 0) yield book.title
// 执行结果：List(Introduction to Functional Programming)
println(result2);
}
}