spark知识点

hive中 concat_ws(’_’,‘a’, cast(1 as string )) concat_ws是字符串连接，cast as 对类型进行转换
collect_set去除重复元素；collect_list不去除重复元素
进入spark
import spark
sql(“select * from 表名”).show()

spark的安装

1.vim spark-env.sh
export SCALA_HOME=
export JAVA_HOME=
export HADOOP_HOME=
export HADOOP_CONF_DIR=$HADOO{P}_{H}OME/etc/hadoopSPAR{K}_{M}ASTE{R}_{I}P=masterSPAR{K}_{L}OCA{L}_{D}IRS=/usr/local/src/spark-2.0.2-bin-hadoop2.6SPAR{K}_{D}RIVE{R}_{M}EMORY=1G2.vimslavesslave1slave23.vim./bashrcexportSCAL{A}_{H}OME=exportSPAR{K}_{H}OME=exportPATH=:$SCALA_HOME/bin:$SPARK_HOME/bin
4.将所有的配置好的master上的文件拷贝到slave1和slave2中
5.启动集群 start-all.sh

scala

1.scala word count
数据导入

import scala.io.Source
val lines=Source.fromfile("文件路径").getLines().toList
//将迭代器中的元素放入列表中进行返回 
//判断有多少行
lines.length
//lines:scala.io.BufferedSource=non-empty iterator lines=Source.fromfile("文件路径")
//理解Range:本质是一种特殊的Array数组
val a=Range(0,5) //左闭右开 步长为1  等价于 val a =0 until 5
val a=1 to 5 //左闭右闭  等价于 val a=1.to(5)
//将Range转化为list
val b=a.toList
//理解map
a.map(x=>x*2) //返回的类型为vector
//访问vector对象，使用方式通过将索引圆括号进行访问
//遍历vector 进行for循环
for(i<-b) print(i+"")
//理解_
//1.集合中的每一个元素
a.map(x=>x*2)==a.map(_*2)//true
//2.获取tuple中的元素
val s=("aa","bb")
s._1="aa"
s._2="bb"
//3.导入所有的包
import scala.io._
//4.变量的初始化
val a=1 //变量不可以进行更改赋值
var a=1 //变量可以进行更改
var name:String=_ //name:String=null
var score:Int=_ //score:Int=0
// 针对每一行数据，进行单词切割
lines.map(_.split(" ")) // 等价于lines.map(x=>x.split(" "))
//理解flatten函数 该函数进行压平展开
val lol = List(List(1,2), List(3,4))
lol: List[List[Int]] = List(List(1, 2), List(3, 4))
val result = lol.flatten
result: List[Int] = List(1, 2, 3, 4)
//flatMap函数先Map然后再进行flat
val lol = List(List(1,2), List(3,4))
var result = lol.flatten
println(result.map(_*2))
println(lol.flatMap(_.map(_*2))) //这两个输出是一样的
//通过两种方式对单词进行打散
lines.map(_.map(_.split(" "))).flatten
lines.flatMap(_.split(" "))
// 对每一个单词进行计数
lines.flatMap(_.split(" ")).map((_,1))
lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1) 
//返回的是Map形式，Map(forgotten->List((forgotten,1),(forgotten,1),(forgotten,1)))
//_1：forgotten  _2:List((forgotten,1),(forgotten,1),(forgotten,1))
//整个list的大小可以作为该单词出现的次数
lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).map(x=>(x._1,x._2.size))
等价于
lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).map(x=>(x._1,x._2.length))
//对第二个元素进行求和
var a1=List((1,2),(3,4),(5,6))
a1.map(_._2).sum() 
等价于
a1.map(_._2).reduce(_+_)
//reduce 理解
//reduce分为reduceLeft和reduceRight  reduce默认为reduceLeft
(1 to 9).reduceLeft( _ * _) //相当于1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 
(1 to 9).reduceLeft( _ + _) //相当于1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 
(1 to 9).reduce(_ + _) //默认是reduceLeft
//需求：不能通过上面的list大小计算单词出现的次数
lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).map(x=>(x._1,x._2.map(_._2).sum))
等价于
lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).map(x=>(x._1,x._2.map(_._2).reduce(_+_)))
//sortBy():函数从小到大排序 或者sortWith(_<_)  sortBy().reverse:从大到小排序 或者sortWith(_>_)
var b=List((3,4),(2,3))
b.sortBy(_._2)
//需求：获取单词出现频次的topN(前N个值)
lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).map(x=>(x._1,x._2.map(_._2).sum)).toList.sortBy(_._2).reverse.slice(0,N)
等价于
lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).reverse.slice(0,N)

iterator it(迭代器)：不是一个集合，可以用于访问集合的方法
it.next():返回迭代器中下一个元素，同时更新迭代器状态
it.hasNext():检查集合中是否存在元素