具体搞spark4.26

启动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                                                     //返回最长的那个字符串
}

}