Scala 慕课网笔记

for循环

  val l = List("Tom", "Bob123", "WangMeng")       //> l  : List[String] = List(Tom, Bob123, WangMeng)
  for {
    s <- l
  } println(s)                                    //> Tom
                                                  //| Bob123
                                                  //| WangMeng
                                                  //| res0: <error> = ()
	for {
		s <- l
		if (s.length>3)
	}println(s)                               //> Bob123
                                                  //| WangMeng
	for {
		s <- l
		s1 = s.toUpperCase()
		if (s1 != "")
		if (s.length > 3)
	}yield(s1)                                //> res1: <error> = List(BOB123, WANGMENG)
	

	val result_try = try {
		Integer.parseInt("Cat")
	} catch {
		case _ => 3
	} finally {
		println("must be printed")
	}                                         //> must be printed
                                                  //| result_try  : Int = 3
		
	val code = 2                              //> code  : Int = 2
	val result_match = code match {
		case 1 => "one"
		case 2 => "two"
		case _ => "others"
	}                                         //> result_match  : String = two

使用_*转换参数列表

call by value/name

call by value: 对函数实参求值，且仅求值一次  x: Int
call by name: 函数实参每次在函数体内被用到时都会求值 y: => Int
 

      def bar (x: Int,y: => Int) = 1
      def loop(): Int = loop   // 递归      
      bar(1,loop)                   // 能执行，call by name开始不会执行loop
      bar(loop,1)   // 死循环，call by value需要先运行loop

  高阶函数

：用函数作为形参或者返回值的函数
    
    def operate(f: (Int,Int) => Int) ={
        f(4,4)
    }
    
    def greeting() = (name: String) => {"hello" + " " + name }
    
    // 上面的greeting()函数后面跟的是匿名函数：(形参列表) => {函数体}

  柯里化函数 

：把具有多个参数的函数转化为一条函数链，每个节点上是单一参数
    def curriedAdd(a: Int)(b: Int) = a + b
    curriedAdd(2)(2)
    var addOne = curriedAdd(1)_
    addOne(2)

递归函数
  

 def factorial(n: Int): Int =
        if (n <= 0) 1
        else n * factorial(n - 1)
    
    factorial(3)
    
    // 普通递归容易出现堆栈溢出。尾递归函数：所有递归形式的调用都出现在函数的尾部，当编译器检
    // 测到一个函数调用尾递归的时候，就覆盖当前的活动记录而不是在栈中去创建一个新的
    @annotation.tailrec
    def fac(n: Int,m: Int): Int =
        if (n<=0) m else fac(n-1,m*n)
        
    fac(4,1)   // 在worksheet里不出结果，在终端可以有结果

 6-2 list的高级使用
  

  val a = List(1,2,3)
    a.filter(x => x % 2 == 1)
    "99 my name is LH".toList.filter(x => Character.isDigit(x))
    "99 my name is LH".toList.takeWhile(x => x != 'n')  // 没有匹配到 'n' 一直输出

  6-3 map函数
  

val c = List("x","y","z")
  c.map(x => x.toUpperCase)   // （都是匿名函数  ）等价于 c.map(_.toUpperCase)
             //双重List处理
    val d = List(a,List(4,5,6))
    d.map(_.filter(_ % 2 == 0))
    d.flatMap(_.filter(_ % 2 == 0))     // flatMap 将List合并

    6-4 reduceLeft 和  flodLeft

 List(1,2,3).reduceLeft((x,y) => x+y)
    List(1,2,3).reduce(_ + _)
    
    List(1,2,3).foldLeft(5)((x,y) => x+y)  // foldLeft用法x：第一次调用5，y调用1，再把x+y=6的结果放在(5)的位置作为返回；再x调用6，y调用2，依次把(1,2,3)遍历完，返回(5)位置的结果11

6-5 stream
    

 val stream = (1 to 10000000).toStream   // 相当于迭代器用到才会求值

 toupe 和 Map
  

  1 -> 2
    val t = (1,"ALice","Math",89.3)   // 访问方式
    //touple的应用
     def sumSq(in: List[Int]):(Int,Int,Int) = in.foldLeft((0,0,0))((x,y) => (x._1+1,x._2+y,x._3+y*y))
      sumSq(List(1,2,3))   //  (Int, Int, Int) = (3,6,14)

 map 相当于字典
    val p = Map(1 -> "David",3 -> "John")
    p(1)
    p.keys
    p.values
    p.contains(1)
    p.contains(12)
    p - 1
    p + (4 -> "Ammi")
    p ++  List(1->"a1",2->"bas")     // 一次加多个键值对
    p --  List(1,2)  // 一次减个键值对