scala 编程思想 -map和reduce

package com.test1

object Scala09_test10 {
  def main(args: Array[String]): Unit = {
  //作为对象的函数
    //我们可以将方法以对象的形式作为参数给其他方法
    //为了实现这一点，需要函数对象来打包方法，函数对象简称为函数
    //例如foreach对于像vector这样的序列来说是一个非常有用的方法
    //它接受参数，并将其应用到序列中每个元素上。
    def show(n:Int):Unit = {println("> "+n)}
    val v:Vector[Int] = Vector(1,2,3,4)
    v.foreach(show)
    v.foreach(n=>{println("> "+n)})

    var s = ""
    val duck = "Duck".toVector
    duck.foreach(n=>s=s+n+":")
    println(s)

    val v1:Vector[Int] = Vector(19,1,7,3,2,14)
    println(v1.sorted)
    println(v1.sortWith((i,j)=>j<i))
    //缺省的sorted方法会产生期望的升序结果，而sortwith方法会接受一个具有两个参数的函数

    class Later(val f:()=>Unit){
      def call():Unit={
        f()
      }
    }

    val cl = new Later( ()=>println("now"))
    cl.call()
    //甚至可以将匿名函数赋给一个var或val
    val later1 = ()=>println("now")
    val later2 = ()=>println("now")
    later1.apply()
    later2.apply()

    //map和reduce在前一个原子中，我们通过foreach这个
    val v2 = Vector(1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4)
    v2.map(n=>(n,n+1))
    println(v2.map(n=>(n,1)))


  }
}

在前一个原子中，我们通过foreach这个例子学习了匿名函数数的知识，尽管foreach非常有用，但是仍有局限性 ，

因为使用它只是为了其副作用，

初学scala者肯定会对:: , +:, :+, :::, +++,这些操作有些疑惑,今天总结一下,方便大家的使用


package test
/**
  * scala中的:: , +:, :+, :::, +++, 等操作;
  */
object listTest {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3)
    // :: 用于的是向队列的头部追加数据,产生新的列表, x::list,x就会添加到list的头部
    println(4 :: list)  //输出: List(4, 1, 2, 3)
    // .:: 这个是list的一个方法;作用和上面的一样,把元素添加到头部位置; list.::(x);
    println( list.:: (5)) //输出: List(5, 1, 2, 3)
    // :+ 用于在list尾部追加元素; list :+ x;
    println(list :+ 6)  //输出: List(1, 2, 3, 6)
    // +: 用于在list的头部添加元素;
    val list2 = "A"+:"B"+:Nil //Nil Nil是一个空的List,定义为List[Nothing]
    println(list2)  //输出: List(A, B)
    // ::: 用于连接两个List类型的集合 list ::: list2
    println(list ::: list2) //输出: List(1, 2, 3, A, B)
    // ++ 用于连接两个集合，list ++ list2
    println(list ++ list2) //输出: List(1, 2, 3, A, B)
  }
}

推导

package com.test1

object Scala09_test11 {
  def main(args: Array[String]): Unit = {
    val v1 = Vector(1,2,3,4,5,6,7,8)
    val v2  = v1.map(i=>(i,1))
    val v3 = Vector(1,10,100,1000)
    var sum = 0
    //v3.reduce((sum,n)=>{sum=sum+n,sum)}
    //println(sum)
    //v2.reduce((vx,1)=>{vx._1,))
    println(v3.reduce((sum,n)=>sum+n))
   // v2.reduce((item,v)=>(v._1,v._2=v._2+1))
    println((1 to 100).reduce((sum,n)=>sum+n))
    println(Vector("D","u","c","k").reduce((sum,n)=>sum+":"+n))

    //推导，现在，你已经准备好了，可以开始学习有关强有力的for和if的组合的知识了，
    //这种组合称为for推导了，或者简称为推导

    def evenGT5(v:Vector[Int]):Vector[Int]={
      var result = Vector[Int]()
      for{
        n<-v
        if n >5
        if n %2 == 0

      }result = result :+ n
      result
    }
    val v = Vector(1,2,3,5,6,7,8,10,13,14,17)
    println(evenGT5(v))
    //注意，rsult并非常见的val,而是var,因此我们可以修改result.
    //一般情况下，我们总是尝试使用val,

    def yielding(v:Vector[Int]):Vector[Int]={
      val result = for{
        n <- v
        if n < 10
        if n %2 !=0
      }yield  n
      result
    }

    val v20 = Vector(1,2,3,5,6,7,8,10,13,14,17)
    println(yielding(v20))
    case class Persion(name:String)

    //基于类型的模式匹配
    //我们已经看过基于值的模式匹配，还可以按照值的类型来匹配。下面的方法并不关心其参数的类型
    def acceptAnything(x:Any):String={
      x match {
        case s:String=>"A String"+s
        case i:Int if(i<=20)=>s"An int less than 20：$i"
        case i:Int =>s"Some other Int:$i"
        case p:Persion=>s"A person ${p.name}"
        case _ =>"I don't know what that is"
      }
    }

    println(acceptAnything(5))
    println(acceptAnything(25))
    println(acceptAnything(Persion("wjj")))
    println(acceptAnything(Vector(1,2,5)))
    


  }
}