オプションのマッチングの

ヴァル・マップ= 地図（（"zhangsan"、2000年）、（"リージ"、2500年）、（"wangwu"、3000））
valのオプション：すべて= map.get（"zhangsan" ）
オプションの試合 {
  ケースいくつかの（V） => のprintln（V）
  ケースなし=> のprintln（"無"）
  場合 _ => のprintln（）
}

役職：

オブジェクト Test2を{
  DEFメイン（引数：配列[文字列]）：単位= {
    // MRマッパlineRecordReaderイテレータリストヴァルのライン：イテレータ[文字列]ソースを=。fromFileの（"log.txtという"）.getLines（）//のprintln（ "site3 ,,"スプリット（ "" - 1）.LENGTH。）ヴァル filterData：イテレータ[文字列] = lines.filter（_スプリット（。""）.LENGTH == 3）// 1、サイト2、ユーザ3時間    //日紫外線のPV ヴァルの DATA1：イテレータ[（文字列、文字列、文字列）] = filterData.map（T => { ヴァル STRS：配列[文字列] = t.split（"" ）      （STRS（0）、STRS（1）、STRS（2）.split（""










    ヴァル DATA2：地図[（文字列、文字列）、リスト[（文字列、文字列、文字列）]] = data1.toList.groupBy（T =>（t._1、t._3））

   ヴァル dayPV = data2.mapValues（_ .LENGTH）

    dayPV.foreach（のprintln）

    ヴァル dayUV = data2.mapValues（T => t.map（_._ 2）.distinct.length）

    dayUV.foreach（のprintln）
  }
}
// site4、ユーザ5、// site3、、// SITE1、user1,2018-03-02 2時25分25秒オブジェクト Test3は{ DEFメイン（引数：配列[文字列]）：単位= { // MRマッパーlineRecordReaderイテレータリストヴァルのライン：イテレータ[文字列]ソース= 。fromFileの（"log.txtという"）.getLines（）




    //のprintln（ "site3 ,,"スプリット（ " " - 1）.LENGTH）ヴァル filterData：イテレータ[文字列] = lines.filter（。_スプリット（"、"）.LENGTH == 3）// 1つのサイト2、ユーザ3時間    //日紫外線のPV ヴァルの DATA1：イテレータ[（文字列、文字列、文字列、文字列）] = filterData.map（T => { ヴァル STRS：配列[文字列] = t.split（""）ヴァル時間= STRS（2）.split（"" ）のVal時間=回（1）.split（"："）（0）      （STRS（0）、STRS（1）、時間（0）、時間）/ /サイトのユーザ日 }）ヴァル DATA2：地図[（文字列、文字列、文字列）、リスト[（文字列、文字列、文字列、文字列）]] = data1.toList.groupBy（T =>（t._1、t._3 、トン。_4）） H












    hourPV = data2.mapValues（_長さ）

    hourPV.foreach（のprintln）

    のprintln（"**********************" ）

    ヴァル hourUV = data2.mapValues（ T => t.map（_._ 2）.distinct.length）

    hourUV.foreach（のprintln）
  }
}

object MovieTest {
  def main(args: Array[String]): Unit = {
    val ratingData = Source.fromFile("ratings.txt").getLines()
    val movieData = Source.fromFile("movies.txt").getLines()
    val ratingData1:Iterator[(String,String,String)] = ratingData.map(t=>{
      val strs = t.split(",")
      (strs(0),strs(1),strs(2))
      //uid mid
    })
    val movieData1:Iterator[(String,String)] = movieData.map(t=>{
      val strs = t.split(",")
      (strs(0),strs(strs.length-1))
      //mid types
    })
    // mid type
      val mAndTypes:Map[String,String] = movieData1.toMap

   val umScore:Iterator[(String,String,String)] = ratingData1.flatMap(t=>{
      //t uid mid score
     val types:String = mAndTypes(t._2) // 动作|惊悚|犯罪
//      (t._1,t._3,types)
      //uid score types
      val typess = types.split("\\|")
      val userMovieScore:Array[(String,String,String)] = typess.map(e=>{
        (t._1,t._3,e)
        //uid score type
      })
      userMovieScore
    })
                      //uid    type          uid    score   type
    val lt = umScore.toList
    val groupData:Map[(String,String),List[(String,String,String)]] = lt.groupBy(t=>(t._1,t._3))

    val utypeAvg:Map[(String,String),Double] = groupData.mapValues(t=>{
      val avg = t.map(_._2.toDouble).sum/t.length
      avg
    })

    val list:List[((String,String),Double)] = utypeAvg.toList
    val list1:List[(String,String,Double)] =list.map(t=>{
      (t._1._1,t._1._2,t._2)
    })

    val groupList:Map[String,List[(String,String,Double)]] = list1.groupBy(_._1)

    val result:Map[String,(String,Double)] = groupList.mapValues(t=>{
      val lst: List[(String, String, Double)] = t.sortBy(-_._3)
      (lst(0)._2,lst(0)._3)
    })

    result.foreach(println)
  }
}

偏函数

专门是匹配的函数

scala> var arr = Array(1,2,3,4,5,6)

arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> def pf:PartialFunction[Int,Int]={

| case x=>x*10

| }

pf: PartialFunction[Int,Int]

scala> arr.map(pf)

res1: Array[Int] = Array(10, 20, 30, 40, 50, 60)

scala> var arr = Array(("zhangsan",2000),("lisi",2500))

arr: Array[(String, Int)] = Array((zhangsan,2000), (lisi,2500))

scala> def pf:PartialFunction[(String,Int),(String,Int)]={

| case (x,y)=>(x,y+1000)

| }

pf: PartialFunction[(String, Int),(String, Int)]

scala> arr.map(pf)

res2: Array[(String, Int)] = Array((zhangsan,3000), (lisi,3500))

定义偏函数

def methodName:PartitionFunction[inType,outType]={

case =>

}

AKKA

akka是一个通信机制，相当于hadoop中的RPC协议

akka就是spark1.6以前的通信协议，1.6以后使用的通信协议是netty

akka相当于多线程 ---> 多线程 --->单线程处理能力差不能解决并发的问题---->多线程就是多个线程一起工作 ---> 线程数据混乱（多线程之间不会进行通信）

python mysql

hadoop

スケール（06）----（アッカ）

AKKA

おすすめ