spark总结

1：创建数组

#第1种方式
var arr: Array[String] = new Array[String](num)
#第2种方式
var arr:Array[String] = Array(元素1,元素2,...)

2：数组的方法

lengt 返回数组的长度
head 查看数组的第一个元素
tail 查看数组中除了第一个元素外的其他元素
isEmpty 判断数组是否为空
contains(x) 判断数组是否包含元素x

用法

#查看数组z的长度
 z.length
#查看数组z的第一个元素
 z.head
#查看数组z中除了第一个元素外的其他元素
 z.tai
#判断数组z是否为空
 z.isEmpty
#判断数组z是否包含元素"baidu"
 z.contains("baidu")

3：数组的连接

#通过操作符“++”连接数和
val arr1 = Array(1, 2， 3)
val arr2= Array(4, 5， 6)
val arr3 = arr1 ++ arr2
#通过concat()方法连接数组
import Array._
val arr4 = concat(arrl, arr2)

4：if语句

1：if...

2：if...else...

3： if...elif...else...

4：

if...

    if...else

else...

5：if判断

if判断
1f(布尔表达式)(若布尔表达式为true,则执行该语句块4语句
12(布尔表达式)(若布尔表达式为trus,则执行该语句块)1f.le句
 lse|若布尔表达式为fa)se,则执行该语句块)
 iCelse it else语句布尔表达式1:1
若布尔表达式1为1rue,则执行该语句块
)eise tf布尔表达式211
若布尔表达式2为true,则执行该语句块
)else it(布尔表达式3)(
若布东表达式3为zr0,则执行该语句块
} else i
若以上市尔表达式都为false,则执行该语句块
 if.else套语句
 f(布尔表达式1)ft布尔表达式2；(
若布尔表达式2为true,则执行该语句块}e_se if(布尔表达式3)|
若布尔表达式3为true,则执行该语句块
)else{
若布尔表达式2为falae且布尔表达式3为fal
else(
    以上false则执行该语句块

6for循环

var i,j= 0；
for(i <-1 to 2){
    for(j<- 1 to 2)
        println("("+i+","+j+")")
}

7：定义列表

定义string类型的列
 val fruit: List[String] = List("apple", "pears", "oranges")
#定义Int类型的列表
 val nums: List[Int]= List(1, 2， 3， 4， 5)
#定义Double类型的列表
 val double_nums: List[Double] = List(1.0, 2.5， 3.3)
#定义Nothing类型的列表
 val empty: List[Nothing] = List()
#根据初值自动推断列表的数据类型
val fruit2 = List("apple", "pears", "oranges")

8，定义与使用集合

def head: A
获取集合的第一个元素
def init: Set[A]
返回所有元素，除了最后一个
def last:A
获取集合的最后一个元素
def tail: Set[A]
返回所有元素，除了第一个
def+(elems: A): Set[A]
合并两个集合
def take(n: Int): List[A]
获取列表前n个元素
def contains(elem: Any): Boolean
判断集合中是否包含指定元素

9，映射

映射(Map)是一种可迭代的键值对结构，所有值都可以通过键获取，并且映射中键都是唯一的，定义如图2-31所示。
scala> val person: Map[String, Int]=Map("John"->21,"Betty"->20,"Mike"->22)person: Map[String, Int] = Map(John .> 21， Betty -> 20， Mike .> 22)

10元组

元组(Tuple)是一种类似于列表的结构，但与列表不同的是，元组可以包含不同类的元素。元组的值是通过将单个的值包含在圆括号中构成的。

11，函数组合器

map

foreach

filter

fatten

flatmap

groupBy

12Scala定义类

class Point(xc: Int, yc: Int){
    var x: Int= xc var y: Int = yc
    def move(dx: Int, dy: Int){
        x=x+dx 
        y=y -dy
        println("x轴的坐标为："+x)
        printIn("y轴的坐标为:"+y)
    }
}

13Scala读写文件

写文件

import java.io._
val pw = new PrintWriter(new File("/opt/test.txt"))

pw.printIn(I am learning Scalay
#也可以使用write()方法写入数据，pw.write("IamlearningScala")
pw.close

读

import scala.io.source
source. fromFile("/opt/test.txt").foreach(print)

14创建RDD

1：parallelize()

定义一个数
 val data = Array(1, 2， 3， 4， 5)
#使用parallelize()方法创建RDD 
val distData = sc. parallelize(data)
#查看RDD默认分区个数
 distData.partitions.size
#设置分区个数为4后创建RDD
 val distData = sc.parallelize(data, 4)
#再次查看RDD分区个数
distData.partitions.size

2：make()

定义一个序列seq
valseq-Seq((1,Seq("iteblog.com","sparkhosil.com")),
(3,Seq("itebolg.com","sparkhost2.com";I,
(2,Scq("itebloq.com","sparkhost3.com")))
#使用makeRDD()方法创建RDD val iteblog - sc.makeRDD(seq)
查看RDD的值
iteblog.collect
#查看分区个数
iteblog.partitioner iteblog.partitions.size
#根据位置信息查看每一个分区的值
iteblog.preferredlocations(iteblog.partitions(0))
iteblog.preferredLocations(iteblog.partitions(1))
iteblog.preferredLocations(iteblog.partitions(2))

3：外部创建RDD

HDFS

Linux

14map()方法的使用

#创建RD
val distData = sc.parallelize(List(1, 3， 45， 3， 76))

#map()方法求平方值
val sq_dist = distData. map(x =>x* x)

15sortBY()方法

创建RDD
val data = sc. parallelize(List((1, 3)， (45， 3)， (7， 6)))

#使用sortBy()方法对元组的第二个值进行降序排序，分区个数设置为1

val sort_data = data.sortBy(x=> x._2, false, 1)

16：collect()方法

#查看sq_dist 和 sort_data的结果

sq_dist.collect
sort_data.collect

17flatMap()方法

#创建RDD
val test = sc.parallelize(List("How are you", "I am fine", "What about you"ll
查看RDD
test.collect
#使用map分割字符串后，再查看RDD

test.map(x=>x.split("")).collect

#使用flatMap分割字符串后，再查看RDD

test.flatMap(x=>x.split("")).collect

18take()方法

创建RD
val data = sc.parallelize(1 to 10)
获取RDD的前5个元素
data.take(5)

19，union()方法

#创建RDD
val rddl = sc.parallelize(List(('a', 1)， ('b', 2)，('c', 3))

val rdd2 = sc.parallelize(List(('a', 1)，('d', 4)， ('e', 5))

#通过union()方法合并两个RDD

rddl.union(rdd2).collect

20，fillter()方法

#创建RDD
val rddl-sc.parallelize(List(('a,11.1b.2),(c',3)))

#通过filter()方法过滤其中每个元组第二个值小于等于1的元素

rddl.filter(_._2>1).collect

rdd1.filter(x=>x._2>1).collect

21，distinct()方法

创建RDD
val rdd = sc.makeRDD(List('a', 1)， ('a', 1)， ('b', 1)， ('c', 1))

使用distinct()方法对RDD进行去重

rdd.distinct().collect

22，创建键值对RDD

创建普通RD
val rdd asc.parallelizef
List("this is a test", "how are you", "I am fine", "can you tell me"))
建立键值对RDD
val words = rdd.map(x=> (x.split("")(0), x))
查看键值对RDD数据
words.collect

23，键值对方法

kes,values

reduceByKey

24