scala函數式變程，curry，讀取文件，字符串插值，隱式轉換，模式匹配

scala函數式變程

object AdFunctionApp {
  def main(args: Array[String]): Unit = {
    val l = List(1,2,3,4)

    列表裏面的元素*2
    for(ele <- l){
      println(ele*2)
    }

    對列表中每一個元素都做一個操作
    println(l.map((x:Int) => x*2))
    println(l.map(x => x*2))
    println(l.map(_ * 2))

    println換行，print不換行
    l.map(_*2).foreach(x => println(x))
    l.foreach( x => println(x*2))

    篩選咯
    println(l.map(_*2).filter(_ >8))

    取前3個
    println(l.take(3))

    求和
    println(l.reduce(_+_))
    1-2-3-4
    println(l.reduce(_-_))

    用下面代碼試試是什麼意思
    println(l.reduceLeft(_-_))
    println(l.reduceRight(_-_))

    1,2
    -1,3
    -4,4
    l.reduceLeft((x,y) => {
      println(x+","+y)
      x-y
    })


    3,4
    2,-1
    1,3
    l.reduceRight((x,y) => {
      println(x+","+y)
      x-y
    })

    curry
    2相當於初始值，最後加上後面的結果
    println(l.fold(2)(_+_))
    相減看下面代碼，結果爲0
    println(l.fold(10)(_-_))

    10,1
    9,2
    7,3
    4,4
    l.fold(10)((x,y) =>{
      println(x+","+y)
      x-y
    })

    裏面要有判斷條件
    println(l.count(_>1))


    扁平化操作
    val f=List(List(1,2),List(3,4))
    List(List(1, 2), List(3, 4))
    println(f)
    List(1, 2, 3, 4)
    println(f.flatten)
    List(2, 4, 6, 8)
    println(f.flatMap(_.map(_*2)))


  }

  def sum(a:Int,b:Int)=a+b
  curry
  def add(a:Int)(b:Int)=a+b
}

scala讀取文件

//注意導這個包
import scala.io.Source

object FileApp {
  def main(args: Array[String]): Unit = {
    //讀取文件
    val file = Source.fromFile("f:/asd.txt")

    for(line <- file.getLines()){
      println(line)
    }
  }
}

字符串插值

object StringApp {
  def main(args: Array[String]): Unit = {
    val name  ="asd"
    println("hello:"+name)
    //字符串插值
    println(s"hello:$name")

    //""""""好多輸出
    val b =
      s"""
        |huanying asd
        |fuck you
        |$name
      """.stripMargin

    println(b)
  }
}

scala隱式轉換

import scala.io.Source
//導入java的File類
import java.io.File

import ImplicitAspect._

object ImplicitApp {
  def main(args: Array[String]): Unit = {
    //隱式轉換,傳進來個普通對象，賦予他高級對象的功能
//    implicit def man2superman(man: Man):Superman=new Superman(man.name)
//    val man =new Man("xxx")
//    //如果原函數有fly方法，優先使用原函數的
//    man.fly()

//    implicit def file2RedFile(file:File):RichFile=new RichFile(file)
    val file = new File("f:/asd.txt")
    val content =file.read()
    println(content)

  }
}

class Man(var name:String){
//  def fly()={
//    println("asd")
//  }
}

class Superman(var name: String){
  def fly()={
    println("niubi")
  }
}

class RichFile(val file:File){
  def read() =Source.fromFile(file.getPath).mkString
}

上面那段程序可以把隱式轉換單獨包裝，然後程序裏導入這個包

import java.io.File

object ImplicitAspect {
  implicit def man2superman(man:Man):Superman = new Superman(man.name)
  implicit def file2RichFile(file:File):RichFile = new RichFile(file)
}

模式匹配，偏函數，try catch

import scala.util.Random



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

    val teachers = Array("qwe","asd","zxc")
    //隨機選一個
    val teacher=teachers(Random.nextInt(teachers.length))

//    for(i <- 1.to(4)){
//      //隨機選一個
//      val teacher=teachers(Random.nextInt(teachers.length))
//      println(teacher)
//    }

    //模式匹配
//    teacher match {
//      case "qwe"=> println("ewq")
//      case "asd"=> println("dsa")
//      case "zxc"=> println("cxz")
//    }

    //偏函數
    def saysomething(name:String)= name match {
      case "qwe"=> println("ewq")
      case "asd"=> println("dsa")
      case "zxc"=> println("cxz")
    }

    saysomething("qwe")
//進去是個字符串類型，出來也是字符串類型
    //模式匹配和偏函數，區別，被包在花括號沒有match的一組case語句是偏函數
    def saysomething2:PartialFunction[String,String]={
      case "qwe"=> "ewq"
      case "asd"=> "dsa"
      case "zxc"=> "cxz"
    }

    println(saysomething2("asd"))



    def greeting(array: Array[String])={
      array match {
        case Array("zhangsan") => println("hi:zhangsan")
        case Array(x,y)=> println(s"hi:$x,$y")
        case Array("zhangsan",_*) => println("hi asd")
        case _=>println("welcome..")

      }
    }

    greeting(Array("zhangsan","asd"))

    try{
          val i=1/0
          println(i)
        }catch {
      //Ar畢竟是Exception的子類，但是如果寫的更前，報Ar
          case e:Exception => println("aaaa")
          case e:ArithmeticException =>println("cuola")
        }finally {
          println("這個finall是一定要執行的")
        }

  }
}