A、変換演算子
1.map- 1
1が特徴で、Aのうちの一つになりました
lines.map(one=>{
one+"#"
}).foreach(println)
2.flatMap-多く
山の一つうちに来ます。このようなデータの行読み取りなど：ハロー世界を、二つの言葉こんにちは、世界からです。データ読み出しに応じて：前記匿名関数は、論理定義空間セグメンテーション、単語の複数の最終的な出力
lines.flatMap(one=>{
one.split(" ")
}).foreach(println)
3.filterフィルタ
首尾出力アウトの定義を満たすために限り、ルールとして、入って来。すなわち：こんにちは、他のすべての単語が出力のみ除外されていることができます
//先得到一堆单词
val rdd1 = lines.flatMap(one => {
one.split(" ")
})
//定义过滤规则，进行过滤输出
rdd1.filter(one=>{
"hello".equals(one)
}).foreach(println)
4.reduceByKey和SORTBY
MRに相当するreduceByKeyプロセスを減らす、重合は同一の鍵を行うと（+1は、ここで行われ、すなわち、単語の数をカウント）に対応するロジックを実行しました。
RDDを並べ替えるには重合後、これをソート、タプルタプル数によって行われます。デフォルトで昇順にソートする第2ビットタプルによります。あなたが降順にしたい場合は、それresult.sortBy（TP => {} tp._2 、偽）
//得到split切割后的N多个单词
val words = lines.flatMap(one => {one.split(" ")})
//map，1 To 1，hello--->（hello，1）
val pairWords = words.map(one=>{(one,1)})
//聚合
val result = pairWords.reduceByKey((v1:Int,v2:Int)=>{v1+v2})
result.sortBy(tp=>{tp._2})//按照第二位来排序，进来tp，得到第二位
// result.sortBy(tp=>{tp._2},false)//降序输出，默认升序
result.foreach(println)
5.sortByKey
使用sortByKeyがSORTBY機能達成： "ハロー世界を" - > " hello"を"世界" - >（こんにちは、1）（世界、1）
重要な時期が来た、スワップ逆転タプルの使用、（ハロー1） - > （1、ハロー）
ソートにsortByKeyを使用して、その後反転し、再び使用
val words = lines.flatMap(one => {one.split(" ")})
val pairWords = words.map(one=>{(one,1)})
val result:RDD[(String,Int)] = pairWords.reduceByKey((v1:Int,v2:Int)=>{v1+v2})
val transRDD = result.map(tp=>{tp.swap})//反转，string，int 变 int，string
val r = transRDD.sortByKey(false)
r.map(_.swap).foreach(println)
6.sampleサンプリング
/**
* sample算子抽样
* true:抽出来一个，完事再放回去，再继续抽。
* 0.1:抽样的比例
* 100L:指定种子，抽到的数据不管运行多少次都一样
*/
val result: RDD[String] = lines.sample(true,0.1,100L)
result.foreach(println)
7.join
（K、V）（K、W） - >（K、（V、W））、kは同じで合流あります
val result = rdd1.join(rdd2)
7.1 leftOuterJoin
左主、未使用なしには、ピットを占めました
val result = rdd1.leftOuterJoin(rdd2)
7.2 rightOuterJoin
ない占拠なしの使用に、ベースと右へ
val result = rdd1.rightOuterJoin(rdd2)
8.union
タイプと一致するように、二つのデータセットをマージ
val result = rdd1.union(rdd2)
9.intersection
2つの交差点を取るRDD
val result = rdd1.intersection(rdd2)
10.subtract
差集合を取ります
val result = rdd1.subtract(rdd2)
11.mapPartitions
そして、同様のマップは、データユニットは、各パーティションに横断されます
val result = rdd1.mapPartitions(iter=>{
val listBuffer = new ListBuffer[String]()
println("打开")
while (iter.hasNext){
val s = iter.next()
println("插入。。。"+s)
listBuffer.append(s+"#")
}
println("关闭")
listBuffer.iterator
})
12.distinct：マップ+ redeceByKey +マップ
これは、重量に相当します
val rdd1: RDD[String] = sc.makeRDD(Array[String]("a", "b", "c", "a", "d", "e", "a", "b"))
val result = rdd1.distinct()
//等价
val result = rdd1.map(s=>{(s,1)}).reduceByKey(_+_).map(tp=>tp._1)
13.cogroup
（K、V）.cogroup（K、V）=>（K、（[V]、[W]））
输出：（zhangsan、（CompactBuffer（1）、CompactBuffer（100）））
val result = nameRDD.cogroup(scoreRDD)
result.foreach(println)
14.mapPartitionsWithIndex
インデックス：パーティション番号;
ITER：データパーティション番号
val rdd2 = rdd1.mapPartitionsWithIndex((index, iter) => {
val list = new ListBuffer[String]()
while (iter.hasNext) {
val one = iter.next()
list += (s"rdd1 partition = $index ,value = $one")
}
list.iterator
})
rdd2.foreach(println)//rdd1 partition = 1 ,value = b
15.repartition
あなたは、減少のパーティションを増大させることができます。ワイドオペレータ依存性、シャッフル発生し、
パーティションを増加し、減少させることも同様に可能で、ここでは区別が合体、合体。しかし、依存狭い合体演算子は、デフォルトのシャッフルは、セット真で開くことができます。複数のパーティションがシャッフルを生成しない、小さなパーティションを結合するために割り当てられた場合、動作しません。
あなたは次のように理解することができるように偽装：一般的にパーティションを増大させるために使用配分、COALESCEは、一般的にパーティションを削減するために使用します
val rdd3 = rdd2.repartition(3)
rdd3.mapPartitionsWithIndex((index, iter) => {
val list = new ListBuffer[String]()
while (iter.hasNext) {
val one = iter.next()
list += (s"rdd1 partition = $index ,value = $one")
}
list.iterator
}).foreach(println)
16.zip＆zipwithindex
ジップ2つのRDDはジッパーによって一緒に圧縮することができ、出力：（1）
zipwithindex：ロング指数は、RDD 0,1,2の指標である...と、それぞれの添字は一緒に圧縮された、フォームのKV形式RDD。例えば：（0）
rdd1.zip(rdd2).foreach(println)
val rdd: RDD[(String, Long)] = rdd1.zipWithIndex()
rdd.foreach(println)
二、アクションオペレータ
1.count
//count：计算数据源有多少行
val l = lines.count()
println(l)
2.collect
メモリへドライバ側の回復計算結果
val strings: Array[String] = lines.collect()
strings.foreach(println)
3.firs
最初のデータを取得します。まず、テイク（1）実装であります
val result = lines.first()
println(result)
4.Take
指定した行数は、データを取得します
val result = lines.take(5)
result.foreach(println)
5.foreachPartition
各パーティション上のデータのトラバーサル
rdd1.foreachPartition(iter=>{
println("创建数据库连接")
while (iter.hasNext){
val s = iter.next()
println("插入数据库："+s)
}
println("关闭数据库连接")
})
6.reduce＆countByKey＆countByValue
重合は、論理出力15を対応する実行しました
val reslut = sc.parallelize(List[Int](1,2,3,4,5)).reduce((v1,v2)=>{v1+v2})
println(reslut)
同じ全体のカウント数に応じてcountByKeyキーパケットには、いくつかを持っています
sc.parallelize(List[(String,Int)](("a",100),("b",200),("a",300),("d",400))).countByKey().foreach(println)
countByValue：全体のパケット値を計算出現。出力：（（100）、2）
sc.parallelize(List[(String,Int)](("a",100),("b",200),("a",300),("a",100))).countByValue().foreach(println)
