大資料教程：Transformation和Action運算元演示

val  conf = new   SparkConf (). setAppName ( "Test" ). setMaster ( "local" )
       val  sc = new   SparkContext (conf)

     // 透過並行化生成 rdd
     val  rdd = sc. parallelize (List( 5 , 6 , 4 , 7 , 3 , 8 , 2 , 9 , 10 ))

     //map: 對 rdd 裡面每一個元乘以 2 然後排序
     val  rdd2: RDD[Int] = rdd. map (_ * 2 )
     //collect 以陣列的形式返回資料集的所有元素 ( 是 Action 運算元 )
     println (rdd2. collect (). toBuffer )

     //filter: 該 RDD 由經過 func 函式計算後返回值為 true 的輸入元素組成
     val  rdd3: RDD[Int] = rdd2. filter (_ > 10 )
     println (rdd3. collect (). toBuffer )

     val  rdd4 = sc. parallelize (Array( "a b c" , "b c d" ))
     //flatMap: 將 rdd4 中的元素進行切分後壓平
     val  rdd5: RDD[String] = rdd4. flatMap (_. split ( " " ))
     println (rdd5. collect (). toBuffer )
     // 假如 : List(List(" a,b" ,"b c"),List("e c"," i o"))
     // 壓平 flatMap(_.flatMap(_.split(" ")))
    
     //sample 隨機抽樣
     //withReplacement 表示是抽出的資料是否放回， true 為有放回的抽樣， false 為無放回的抽樣
     //fraction 抽樣比例例如 30% 即 0.3 但是這個值是一個浮動的值不準確
     //seed 用於指定隨機數生成器種子 預設引數不傳
     val  rdd5_ 1  = sc. parallelize ( 1  to 10 )
     val  sample = rdd. sample ( false , 0.5 )
     println (sample. collect (). toBuffer )

     //union: 求並集
     val  rdd6 = sc. parallelize (List( 5 , 6 , 7 , 8 ))
     val  rdd7 = sc. parallelize (List( 1 , 2 , 5 , 6 ))
     val  rdd8 = rdd6 union rdd7
     println (rdd8. collect . toBuffer )

     //intersection: 求交集
     val  rdd9 = rdd6 intersection rdd7
     println (rdd9. collect . toBuffer )

     //distinct: 去重出重複
     println (rdd8. distinct . collect . toBuffer )

     //join 相同的 key 會被合併
     val  rdd10_ 1  = sc. parallelize (List(( "tom" , 1 ),( "jerry"  , 3 ),( "kitty" , 2 )))
     val  rdd10_ 2  = sc. parallelize (List(( "jerry"  , 2 ),( "tom" , 2 ),( "dog" , 10 )))
     val  rdd10_ 3  = rdd10_ 1  join rdd10_ 2
     println (rdd10_ 3. collect (). toBuffer )
    
     // 左連線和右連線
     // 除基準值外是 Option 型別 , 因為可能存在空值所以使用 Option
     val  rdd10_ 4  = rdd10_ 1  leftOuterJoin rdd10_ 2   // 以左邊為基準沒有是 null
     val  rdd10_ 5  = rdd10_ 1  rightOuterJoin rdd10_ 2   // 以右邊為基準沒有是 null
     println (rdd10_ 4. collect (). toList )
     println (rdd10_ 5. collect (). toBuffer )

     val  rdd11_ 1  = sc. parallelize (List(( "tom" , 1 ),( "jerry"  , 3 ),( "kitty" , 2 )))
     val  rdd11_ 2  = sc. parallelize (List(( "jerry"  , 2 ),( "tom" , 2 ),( "dog" , 10 )))
     // 笛卡爾積
     val  rdd11_ 3  = rdd11_ 1  cartesian rdd11_ 2
     println (rdd11_ 3. collect. toBuffer )
  
    // 根據傳入的引數進行分組
     val  rdd11_ 5 _ 1  = rdd11_ 4. groupBy (_._ 1 )
     println (rdd11_ 5 _ 1. collect (). toList )

     // 按照相同 key 進行分組 , 並且可以制定分割槽
     val  rdd11_ 5 _ 2  = rdd11_ 4. groupByKey
     println (rdd11_ 5 _ 2. collect (). toList )

     // 根據相同 key 進行分組 [ 分組的話需要二元組 ]
     //cogroup 和 groupBykey 的區別
     //cogroup 不需要對資料先進行合併就以進行分組 得到的結果是 同一個 key 和不同資料集中的資料集合
     //groupByKey 是需要先進行合併然後在根據相同 key 進行分組
     val  rdd11_ 6 : RDD[(String, (Iterable[Int], Iterable[Int]))] = rdd11_ 1  cogroup rdd11_ 2
     println (rdd11_ 6 )

val  conf = new   SparkConf (). setAppName ( "Test" ). setMaster ( "local[*]" )
     val  sc = new   SparkContext (conf)
     /* Action 運算元 */
     // 集合函式
     val  rdd1 = sc. parallelize (List( 2 , 1 , 3 , 6 , 5 ), 2 )
     val  rdd1_ 1  = rdd1. reduce (_+_)
     println (rdd1_ 1 )
     // 以陣列的形式返回資料集的所有元素
     println (rdd1. collect (). toBuffer )
     // 返回 RDD 的元素個數
     println (rdd1. count ())
     // 取出對應數量的值 預設降序 , 若輸入 0 會返回一個空陣列
     println (rdd1. top ( 3 ). toBuffer )
     // 順序取出對應數量的值
     println (rdd1. take ( 3 ). toBuffer )
     // 順序取出對應數量的值 預設生序
     println (rdd1. takeOrdered ( 3 ). toBuffer )
     // 獲取第一個值 等價於 take(1)
     println (rdd1. first ())
     // 將處理過後的資料寫成檔案 ( 儲存在 HDFS 或本地檔案系統 )
     //rdd1.saveAsTextFile("dir/file1")
     // 統計 key 的個數並生成 map k 是 key 名 v 是 key 的個數
     val  rdd2 = sc. parallelize (List(( "key1" , 2 ),( "key2" , 1 ),( "key3" , 3 ),( "key4" , 6 ),( "key5" , 5 )), 2 )
     val  rdd2_ 1 : collection. Map [String, Long] = rdd2. countByKey ()
     println (rdd2_ 1 )
     // 遍歷資料
    rdd1. foreach (x => println (x))

     /* 其他運算元 */
     // 統計 value 的個數 但是會將集合中的一個元素看做是一個 vluae
     val  value: collection. Map [(String, Int), Long] = rdd2. countByValue
     println (value)
     //filterByRange: 對 RDD 中的元素進行過濾 , 返回指定範圍內的資料
     val  rdd3 = sc. parallelize (List(( "e" , 5 ),( "c" , 3 ),( "d" , 4 ),( "c" , 2 ),( "a" , 1 )))
     val  rdd3_ 1 : RDD[(String, Int)] = rdd3. filterByRange ( "c" , "e" ) // 包括開始和結束的
     println (rdd3_ 1. collect. toList )
     //flatMapValues 對引數進行扁平化操作 , 是 value 的值
     val  rdd3_ 2  = sc. parallelize (List(( "a" , "1 2" ),( "b" , "3 4" )))
     println ( rdd3_ 2.f latMapValues(_. split ( " " )). collect . toList )
     //foreachPartition 迴圈的是分割槽資料
     // foreachPartiton 一般應用於資料的持久化 , 存入資料庫 , 可以進行分割槽的資料儲存
     val  rdd4 = sc. parallelize (List( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ), 3 )
    rdd4. foreachPartition (x => println (x. reduce (_+_)))
     //keyBy 以傳入的函式返回值作為 key ,RDD 中的元素為 value 新的元組
     val  rdd5 = sc. parallelize (List( "dog" , "cat" , "pig" , "wolf" , "bee" ), 3 )
     val  rdd5_ 1 : RDD[(Int, String)] = rdd5. keyBy (_. length )
     println (rdd5_ 1. collect. toList )
     //keys 獲取所有的 key  values 獲取所有的 values
     println (rdd5_ 1. keys. collect . toList )
     println (rdd5_ 1. values. collect . toList )
     //collectAsMap   將需要的二元組轉換成 Map
     val  map: collection. Map [String, Int] = rdd2. collectAsMap ()
     println (map)