[2019-04-24] Scala Learning

1. 偏函数：偏函数最大的特点就是它只接受和处理其参数定义域的一个子集，而对于这个子集之外的参数则抛出运行时异常。

def main(args:Array[String]): Unit ={
    val data = List(1,2,3,4,5,6)
    data.foreach(println _)   // 偏函数
    data.foreach(x => println(x))

    def sum(x:Int, y:Int, z:Int) = x + y + z
    println(sum(1,2,3))

    val fp_a = sum _  //偏函数
    println(fp_a(1,2,3))
    println(fp_a.apply(1,2,3))


    val fp_b = sum(1, _:Int, 3)
    println(fp_b(2))
    println(fp_b(10))

    data.foreach(println)
  }

2. 闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
   闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。
   val multiplier = (i:Int) => i * factor
   在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 multiplier 函数被调用时，i 被赋予一个新的值。
   然而，factor不是形式参数，而是自由变量，考虑下面代码：
   var factor = 3
   val multiplier = (i:Int) => i * factor

object ClosureOps{

  def main(args:Array[String]): Unit ={
    val data = Array(1,2,3,4,5,6)
    var sum = 0
    data.foreach(sum += _)
    println(sum)

    val y = 110
    def add(x:Int) = (y:Int) => x+y
    val a = add(1)
    println(a(100))

    val b = add(1)
    println(b(2))

  }
}

3. 高阶函数

import scala.math._
object FunctionTest{
  def main(args:Array[String]): Unit ={
    (1 to 9 ).map("*" * _ ).foreach(println)
    (1 to 9 ).map("*" * _ ).foreach(println _ )

    (1 to 9 ).filter( _ % 2 == 0).foreach(println)
    (1 to 9 ).filter( _ % 2 == 0).foreach(println _)

    println((1 to 9).reduceLeft(_ * _))
    "Hello world this is Scala Test".split(" ").sortWith(_.length < _.length).foreach(println)

    val fun = ceil _
    val num = 3.14
    println(fun(num))

    Array(1.23,2.34,3.21,4.21).map(fun).foreach(println)

    val triple = (x:Double) => 3 * x
    println(triple(20))
    Array(14.1,22.2,3.3,6.4,5.5,4.6).map(triple).foreach(println)
    Array(12.01,120.2,32.0).map((x:Double) => 2 * x).foreach(println)
    Array(12.01,120.2,32.0).map{ (x:Double) => 2 * x }.foreach(println)

    def high_order_function( f:(Double) => Double) = f(0.25)
    println(high_order_function(ceil _))
    println(high_order_function(sqrt _))

    def mulBy(factor:Double) = (x:Double) => factor * x
    val quintuple = mulBy(5)
    println(quintuple(20))

    println(high_order_function((x:Double) => 3 * x))
    high_order_function((x) => 3 * x)
    high_order_function(x => 3 * x)
    println(high_order_function(3 * _))

  }
}

4. 柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。
   新的函数返回一个以原有第二个参数为参数的函数。

object CurringTest{
  def main(args: Array[String]) {
//    val str1:String = "Hello, "
//    val str2:String = "Scala!"
//    println( "str1 + str2 = " +  strcat(str1)(str2) )
    def mutiple(x:Int, y:Int) = x * y
    def multipleOne(x:Int) = (y:Int) => x*y
    println(multipleOne(6)(7))
    def curring(x:Int)(y:Int) = x * y
    val a = Array("Hello", "Scala")
    val b = Array("Hello", "Python")
    println( a.corresponds(b)(_.equalsIgnoreCase(_)))
  }
  def strcat(s1: String)(s2: String) = {
    s1 + s2
  }
}

5. Match Case
   // Match

object MatchTest{
    def main(args:Array[String]): Unit ={
      val data = 30

      data match {
        case 1 => println("First")
        case 2 => println("Second")
        case _ => println("Unknown Number")
      }

      val result = data match {
        case i if i == 1 => "First Test"
        case number if number == 2 => "Second Test"
        case _ => "Not known number"
      }
      println(result)

      "Spark !" foreach { x => println(
        x match {
          case ' ' => "space"
          case ch => "Char: " + ch
        }
      )}


      def match_type(t:Any) = t match {
        case p:Int => println("It is Integer")
        case p:String => println("It is  string type")
        case m:Map[_,_] => m.foreach(println)
        case _ => println("Unknown Type")
      }

      match_type(2)
      match_type(Map("Scala" -> "Spark"))


      def match_array(arr:Any) = arr match{
        case Array(0) => println("Array" + " 0 ")
        case Array(x, y) => println("Array: " + x + " " + y)
        case Array(0, _*) => println("Array" + "0.......")
        case _ => println("something else")
      }
      match_array(Array(1))
      match_array(Array(0,1))
      match_array(Array(0,1,2,3,4,5,6))

      def match_list(lst:Any): Unit = lst match{
        case 0 :: Nil => println("List:" + "0")
        case x :: y :: Nil => println("List:" + x + " " + y)
        case 0 :: tail => println("List: " + "0......")
        case _ => println("Something else")
      }

      match_list(List(0))
      match_list(List(0,1))
      match_list(List(0,1,2,3,4,5,6))


      def match_tuple(tuple:Any): Unit = tuple match{
        case (0, _) => println("Tuple:" + "0")
        case (x, 0) => println("Tuple:" + x)
        case _ => println("Something else")
      }

      match_tuple(match_tuple(0, "scala"))
      match_tuple(match_tuple(1,0))
      match_tuple(match_tuple(0,1,2,3,4,5,6))
  }
}

6. case object / case class
   // case function: 1. transfer inform
   // 2. pattern match
   // 伴生对象 伴生类 apply

abstract class Person
case class Student(age:Int) extends Person
case class Worker(age:Int, salary:Double) extends Person

// age, salary is val by default

abstract class Item
case class Book(description:String, price:Double) extends Item
case class Bundle(description:String, price:Double, items:Item*) extends Item


case object Shared extends Person
object  CaseClassObjectTest{
   def main(args:Array[String]): Unit ={
     def caseOps(person:Person) = person match{
       case Student(age) => println("I am " + age + "years old ")
       case Worker(_, salary) => println("My monthly salary is " + salary)
       case Shared => println("No property")
     }
     caseOps(Student(10))
     caseOps(Shared)

     val worker = Worker(29,199993.1)
     val worker1 = worker.copy(salary=19.95)
     val worker2 = worker.copy(age = 15)

     println(worker, worker1, worker2)



     def case_class_nested(person: Item) = person match {
       case Bundle(_,_, art @ Book(_,_), rest @ _*) => println(art.description + ":" + art.price)
//       case Bundle(_,_,Book(descr, _), _*) => println("The description is " + descr)
       case _ => println("Oops!")
     }

     case_class_nested(Bundle("111 specials", 30.0, Book("Scala for devekoper", 69.95),
                       Bundle("112 specials", 29.0, Book("Scala for devekoper", 70.0)),
                       Bundle("Hadoop", 29.0, Book("Scala for devekoper", 70.0),
                                              Book("Java for devekoper", 70.1)),
     ))

      case_class_nested(Bundle("Hadoop", 29.0, Book("Scala Python", 70.0)))

   }
}

7. list操作

object ListTest{

  def main(args:Array[String]): Unit ={
    val bigdata = List("Hadoop", "Spark", "Java", "Scala")
    val data = List(1,2,3,4,5,6)

    val bigdata_Core = "Hello" :: ("World" :: Nil)
    val data_Int = 1 :: 2:: 3 ::4 :: Nil

    println(data.isEmpty)
    println(data.head)
    println(data.tail.head)


    val List(a,b,_,_) = bigdata
    println("a is: " + a + "b is: " + b)

    val x::y::z = data
    println("x is " + x + " y is " + y + " rest is:" + z)


    println(List(1,2,3,4) ::: List(5,6,7) ::: List(8,9))
    println(List(1,2,3,4) ::: (List(5,6,7) ::: List(8,9)))
    println(List(1,2,3,4,5).length)

    val bigData = List("Hadoop", "Scala", "Python")
    println(bigData.last)
    println(bigData.init)
    println(bigData.reverse)


    println(bigData)
    println(bigData take 2 )
    println(bigData drop 2)
    println(bigData drop 1)
    println(bigData splitAt 2)

    println(bigData apply 2)
    println(bigData(2))


    val data2 = List('a','b','c','d','e','f','g')
    println(data2.indices)
    println(data2.indices zip data2)
    println(data2.toString())
    println(data2.mkString)
    println(data2.mkString("   "))
    println(data2.mkString("[", ",", "]"))
    println(data2.zipWithIndex)

    println("buffer")
    val buffer = new StringBuilder
    data2 addString(buffer, "(", ";;",")")
    println(buffer)
    println(data2)


    println("array")
    val array = data2.toArray
    println(array.toList)

    println("New Array")
    val new_Array = new Array[Char](10)
    data2.copyToArray(new_Array,3)
    new_Array.foreach(print)
    println

    val iterator=data2.toIterator
    println(iterator.next)
    println(iterator.next)

  }
}

8. List 操作2

object ListTestCalculation{
  def main(args:Array[String]): Unit ={
    println(List(1,2,3,4,5,6).map( _ + 1))
    val data = List("Scala", "Python", "Java","Hello")
    println(data.map(_.length))
    println(data.map(_.toList.reverse.mkString))
    println(data.map(_.toList))
    println(data.flatMap(_.toList))

    println(List.range(1,10).flatMap(i => List.range(1,i).map(j => (i,j))))

    var sum = 0
    List(1,2,3,4,5,6).foreach(sum += _ )
    println(sum)

    println(List(1,2,3,4,5,6,7,8,9,10).filter(_ % 2 == 0))
    println(data.filter(_.length == 5))
  }
}

9.List Opt3

object ListOpration{
  def main(args:Array[String]): Unit ={
    // 生成List
    println(List.apply(1,2,3,4,5,6,7))
    println(List.range(1,5))
    println(List.range(9,1,-3))

    // 拼接List
    val zipped = "abcde".toList zip List(1,2,3,4,5)
    println(zipped)
    println(zipped.unzip)

    // 拼接List
    println(List(List("a", "b"), List("c", "d")).flatten)
    println(List.concat(List("a"), List("g")))

  }
}