启动IntellihJ IDEA命令 idea.sh
我是在platform setting中进行了设置 而不是针对project setting进行
object可以在class下面选进去
local模式没问题
接下来hellohello集群模式
file-----project structure-----artifact------+ -----jar----from moddules with dependencies----hellohello---更改名字。。。jar 打包的时候需要把 scala spark的jar包去除,从200M减小到了4.1M hellohello测试成功!!!
在spark的bin目录下:
./spark-submit --master spark://SparkMaster:7077 --class HelloHello /root/IdeaProjects/HelloHello/out/artifacts/HelloHelloJar_jar/HelloHello.jar
src文件夹下新建main 再在main下面新建scala 在scala下建立scala object
IntelliJ IDEA 红色标注为错误!
为什么没有run -------原因在于没有加入main函数
<Spark MLlib机器学习实践> 2
第三章 RDD详解
RDD是什么? Resilient Distributed Databases 弹性分布式数据集合 RDD实质上市存储在不同节点计算机中的数据集,可以并行存储 并行计算 提高运算效率
弹性分为2方面:1.数据的存储方式弹性 既可以是内存 也可以是磁盘 2.指的是容错性 在某一个节点处出现计算错误,RDD会在不同的节点处重试---检查节点 和 更新记录
RDD应用API详解
1. 使用aggregate方法对给定的数据集进行方法设定
2. parallelize 该方法有两个参数,第二个参数表示,将数据放在多少个数据节点中存放
3. 提前计算的cache方法
4. foreach(println) 是一个专门用来打印未进行Action操作的数据的专门方法,可以对数据进行提早计算。
5. 笛卡尔操作的cartesian方法
6. 分片存储的coalesce方法
7. repartition方法 与coalesce方法作用类似
8.以value计算的countByValue方法 : 计算数据集中某个数据出现的个数,并将其以map的形式返回
9.以key计算的countByKey方法: countByKey是计算数组中元数据键值对key出现的个数
10. 除去数据集中重复项的distinct方法
11. 过滤数据的filter方法
12.以行为单位操作数据的flatMap方法,对数据集进行整体操作的一个特殊方法
13 以单个数据为目标进行操作的map方法
14 分组数据的groupBy方法 https://blog.csdn.net/guotong1988/article/details/50556871 [可参考]
15 生成键值对的KeyBy方法 为原本数据集中的每一个个体增加一个key,从而和原来的数据一起形成键值对
16 同时对两个数据进行处理的reduce方法 与map不同的是它在处理时需要两个参数 对传入的数据进行合并处理 还可以传入一个已经定义的方法作为数据处理方法
17 对数据进行重新排序的sortBy方法
18. 合并压缩的zip方法 双重键值对
import org.apache.spark.{SparkConf, SparkContext}
object HelloSpark {
def main(args: Array[String]) {
val conf = new SparkConf().setMaster("local").setAppName("HelloSpark") //创建环境变量
val sc = new SparkContext(conf) //创建环境变量实例
// val data = sc.textFile("/root/wc.txt") //读取文件
// data.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).collect().foreach(println) //word计数
// val arr = sc.parallelize(Array(1,2,3,4,5,6),2)//输入数组数据集,将内存数据读入spark
// val result = arr.aggregate(0)(math.max(_, _), _ + _) //使用aggregate方法
// println(result) //打印结果
// val arr = sc.parallelize(Array("abc","b","c","d","e","f")) //创建数据集
// val result = arr.aggregate("")((value,word) => value + word, _ + _) //调用计算方法
// println(result) //打印结果
// val arr = sc.parallelize(Array("abc","b","c","d","e","f")) //设定数据集
// println(arr) //打印结果
// println("----------------") //分隔符
// arr.foreach(println) //打印结果
// var arr = sc.parallelize(Array(1,2,3,4,5,6)) //创建第一个数组
// var arr2 = sc.parallelize(Array(6,5,4,3,2,1)) //创建第二个数据
// val result = arr.cartesian(arr2) //进行笛卡尔计算
// result.foreach(print) //打印结果
// val arr = sc.parallelize(Array(1,2,3,4,6,7)) //创建数据集
// val arr2 = arr.coalesce(2,true) //将数据重新分区
// val result = arr.aggregate(0)(math.max(_, _), _ + _) //计算数据值
// println(result) //打印结果
// val result2 = arr2.aggregate(0)(math.max(_, _), _ + _) //计算重新分区数据值
// println(result2) //打印结果
// val arr = sc.parallelize(Array(1,2,3,4,5,6)) //创建数据集
// val arr2 = arr.repartition(3) //重新分区
// println(arr2.partitions.length) //打印分区数
// val arr = sc.parallelize(Array(1,2,3,4,5,6)) //创建数据集
// val result = arr.countByValue() //调用方法计算个数
// result.foreach(print) //打印结果
// var arr = sc.parallelize(Array((1, "cool"), (2, "good"), (1, "bad"), (1, "fine"))) //创建数据集
// val result = arr.countByKey() //进行计数
// result.foreach(print) //打印结果
// var arr = sc.parallelize(Array(("cool"), ("good"), ("bad"), ("fine"),("good"),("cool"))) //创建数据集
// val result = arr.distinct() //进行去重操作
// result.foreach(println) //打印最终结果
// var arr = sc.parallelize(Array(1,2,3,4,5)) //创建数据集
// val result = arr.filter(_ >= 3) //进行筛选工作
// result.foreach(println) //打印最终结果
// var arr = sc.parallelize(Array(1,2,3,4,5)) //创建数据集
// val result = arr.flatMap(x => List(x + 1)).collect() //进行数据集计算
// result.foreach(println) //打印结果
// var arr = sc.parallelize(Array(1,2,3,4,5)) //创建数据集
// val result = arr.map(x => List(x + 1)).collect() //进行单个数据计算
// result.foreach(println)
// val arr = sc.parallelize(Array(1,2,3,4,5)) //创建数据集
// //val result = arr.groupBy(myFilter(_)).collect //设置第一个分组
//
// val result = arr.groupBy(x=>{if(x<3)"small" else "big"}).collect
//
// result.foreach(println)
arr.groupBy(myFilter2(_),2)
//var str = sc.parallelize(Array("one","two","three","four","five")) //创建数据集
// val str2 = str.keyBy(word => word.size) //设置配置方法
// str2.foreach(println) //打印结果
// var str = sc.parallelize(Array("one","two","three","four","five")) //创建数据集
// val result = str.reduce(_ + _) //进行数据拟合
// result.foreach(print) //打印数据结果
//var str = sc.parallelize(Array("one","two","three","four","five")) //创建数据集
// val result = str.reduce(myFun) //进行数据拟合
// result.foreach(print) //打印结果
//var str = sc.parallelize(Array((5,"b"),(6,"a"),(1,"f"),(3,"d"),(4,"c"),(2,"e"))) //创建数据集
// str = str.sortBy(word => word._1,true) //按第一个数据排序
// val str2 = str.sortBy(word => word._2,true) //按第二个数据排序
// str.foreach(print) //打印输出结果
// str2.foreach(print) //打印输出结果
val arr1 = Array(1,2,3,4,5,6) //创建数据集1
val arr2 = Array("a","b","c","d","e","f") //创建数据集1
val arr3 = Array("g","h","i","j","k","l") //创建数据集1
val arr4 = arr1.zip(arr2).zip(arr3) //进行亚述算法
arr4.foreach(print) //打印结果
}
// def myFilter(num: Int): Unit = { //自定义方法
// num >= 3 //条件
// }
// def myFilter2(num: Int): Unit = { //自定义方法
// num < 3 //条件
// }
def myFun(str1:String,str2:String):String = { //创建方法
var str = str1 //设置确定方法
if(str2.size >= str.size){ //比较长度
str = str2 //替换
}
return str //返回最长的那个字符串
}
}