spark graphx 图操作函数示例（全）

最新推荐文章于 2020-11-26 13:50:38 发布
最新推荐文章于 2020-11-26 13:50:38 发布
阅读量2.4k 收藏 6
点赞数 1
分类专栏： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zht245648124/article/details/86667616
版权
  1. 求最大度数
  2. 取出前5个节点
  3. pageRank算法找出最重要的节点
  4. mapTriplets的用法，对图的边属性进行增加，与mapEdges区别为同时对三元组进行转换
  5. mapEdges操作，只能对边的属性进行操作（不能拿到对象的相关信息）
  6. mapVertices操作，只能对节点进行操作
  7. 使用aggregateMessages操作，计算每个节点的出度（join）
  8. 使用aggregateMessages操作，计算每个节点的入度（rightOuterJoin）
  9. 使用aggregateMessages计算每个节点与根节点的距离
  10. 使用Pregel计算每个节点与根节点的距离
  11. 官网的aggregateMessages例子
  12. Spark Graphx图计算案例实战之aggregateMessages求社交网络中的最大年纪追求者和平均年纪！
  13. 生成Gexf的xml文件
package com.spark.scala

import org.apache.spark.graphx._
import org.apache.spark.graphx.util.GraphGenerators
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.mutable

/**
  * 求最大度数
  */
object Test2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val graph = GraphLoader.edgeListFile(sc, "E:\\测试文本\\cit-HepTh\\Cit-HepTh.txt")
    val degreeRdd = graph.inDegrees
    val tuple: (VertexId, Int) = degreeRdd.reduce((a, b) => if (a._2 > b._2) a else b)

    println(tuple)
    // res: (9711200,2414)

  }
}

/**
  * 取出前5个节点
  */
object Test3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val graph = GraphLoader.edgeListFile(sc, "E:\\测试文本\\cit-HepTh\\Cit-HepTh.txt")
    println(graph.vertices.take(5).toBuffer)
  }
}

/**
  * pageRank算法找出最重要的节点
  */
object Test4 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val graph = GraphLoader.edgeListFile(sc, "E:\\测试文本\\cit-HepTh\\Cit-HepTh.txt")
    val res: Graph[Double, Double] = graph.pageRank(0.001)
    //    val vertices: Array[(VertexId, Double)] = res.vertices.take(5)
    println(res.vertices.reduce((a, b) => if (a._2 > b._2) a else b))

  }
}

/**
  * mapTriplets的用法，对图的边属性进行增加，与mapEdges区别为同时对三元组进行转换
  */
object MapTriplets {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val trip = myGraph.mapTriplets(t => {
      (t.attr, t.attr == "is-friends-with" && t.srcAttr.toLowerCase.contains("a"))
    })

    val triplets: RDD[EdgeTriplet[String, (String, Boolean)]] = trip.triplets
    println(triplets.collect().toBuffer)
//    ArrayBuffer(((1,Ann),(2,Bill),(is-friends-with,true)), ((2,Bill),(3,Charles),(is-friends-with,false)), ((3,Charles),(4,Diane),(is-friends-with,true)), ((4,Diane),(5,Went to gym this morning),(Likes-status,false)), ((3,Charles),(5,Went to gym this morning),(Wrote- status,false)))

  }
}

/**
  * mapEdges操作，只能对边的属性进行操作（不能拿到对象的相关信息）
  */
object MapEdges {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val graph1 = myGraph.mapEdges(e => {
      (e.attr, e.attr == "is-friends-with" && e.srcId == 1)
    })

    val triplets: RDD[EdgeTriplet[String, (String, Boolean)]] = graph1.triplets
    println(triplets.collect().toBuffer)
//    ArrayBuffer(((1,Ann),(2,Bill),(is-friends-with,true)), ((2,Bill),(3,Charles),(is-friends-with,false)), ((3,Charles),(4,Diane),(is-friends-with,false)), ((4,Diane),(5,Went to gym this morning),(Likes-status,false)), ((3,Charles),(5,Went to gym this morning),(Wrote- status,false)))

  }
}

/**
  * mapVertices操作，只能对节点进行操作
  */
object MapVertices {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val graph1 = myGraph.mapVertices((vId: VertexId, attr: String) => {
      (attr, vId == 1)
    })

    val triplets: RDD[EdgeTriplet[(String, Boolean), String]] = graph1.triplets
    println(triplets.collect().toBuffer)
  }
}

/**
  * 使用aggregateMessages操作，计算每个节点的出度（join）
  */
object AggregateMessages {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val vertices1: VertexRDD[Int] = myGraph.aggregateMessages[Int](_.sendToSrc(1), _ + _)

    val vertice2: RDD[(VertexId, (Int, String))] = vertices1.join(myGraph.vertices)

    val vertice3: RDD[(String, Int)] = vertice2.map(_._2.swap)

    println(vertice3.collect().toBuffer)
//    ArrayBuffer((Ann,1), (Bill,1), (Charles,2), (Diane,1))

  }
}

/**
  * 使用aggregateMessages操作，计算每个节点的入度（rightOuterJoin）
  */
object AggregateMessages2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val vertices1: VertexRDD[Int] = myGraph.aggregateMessages[Int](_.sendToSrc(1), _ + _)

    val vertice2: RDD[(VertexId, (Option[Int], String))] = vertices1.rightOuterJoin(myGraph.vertices).cache()

    val vertice3: RDD[(String, Option[Int])] = vertice2.map(_._2.swap)

    val vertice4: RDD[(String, PartitionID)] = vertice2.map(x => (x._2._2, x._2._1.getOrElse(0)))

    println(vertice3.collect().toBuffer)
//    ArrayBuffer((Ann,Some(1)), (Bill,Some(1)), (Charles,Some(2)), (Diane,Some(1)), (Went to gym this morning,None))


    println(vertice4.collect().toBuffer)
//    ArrayBuffer((Ann,1), (Bill,1), (Charles,2), (Diane,1), (Went to gym this morning,0))

  }
}

/**
  * 使用aggregateMessages计算每个节点与根节点的距离
  */
object AggregateMessages3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)
    val initGraph: Graph[Int, String] = myGraph.mapVertices((vId, attr) => {
      0
    })
    val graphRes: Graph[PartitionID, String] = proopagateEdgeCount(initGraph)
    val buffer: mutable.Buffer[(VertexId, PartitionID)] = graphRes.vertices.collect.toBuffer

    println(buffer)
//    ArrayBuffer((1,0), (2,1), (3,2), (4,3), (5,4))
  }

  def sendMsg(ec: EdgeContext[Int, String, Int]) = {
    ec.sendToDst(ec.srcAttr + 1)
  }

  def mergeMsg(a: Int, b: Int): Int = {
    math.max(a, b)
  }

  def proopagateEdgeCount(g: Graph[Int, String]): Graph[Int, String] = {
    println("vertice--" + g.vertices.collect.toBuffer)

    val vertice1: VertexRDD[Int] = g.aggregateMessages[Int](sendMsg, mergeMsg)

    println("vertice1--" + vertice1.collect.toBuffer)

    val g2: Graph[Int, String] = Graph(vertice1, g.edges).cache()

    val vertice3: RDD[(VertexId, (Int, Int))] = g2.vertices.join(g.vertices)

    println("vertice3--" + vertice3.collect.toBuffer)

    val vertice4: RDD[Int] = vertice3.map(x => x._2._1 - x._2._2)

    val i: PartitionID = vertice4.reduce(_ + _)

    if (i > 0) {
      proopagateEdgeCount(g2)
    } else {
      g
    }

  }
}

/**
  * 使用Pregel计算每个节点与根节点的距离
  */
object PregelTest {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val value: Graph[PartitionID, String] = myGraph.mapVertices((vId, attr) => 0)

    val g1 : Graph[Int,String] = (Pregel(value, 0, activeDirection = EdgeDirection.Out) // --注意最外层必须要有（）
    (
      (id: VertexId, vd: Int, a: Int) => math.max(vd, a),
      (et: EdgeTriplet[Int, String]) => Iterator((et.dstId, et.srcAttr + 1)),
      (a: Int, b: Int) => math.max(a, b)
    ))

    println(g1.vertices.collect.toBuffer)
    //    ArrayBuffer((1,0), (2,1), (3,2), (4,3), (5,4))

  }
}

/**
  * 官网的aggregateMessages例子
  */
object AggregateMessages4 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)


    // Create a graph with "age" as the vertex property.
    // Here we use a random graph for simplicity.
    val graph: Graph[Double, Int] =
    GraphGenerators.logNormalGraph(sc, numVertices = 100).mapVertices((id, _) => id.toDouble)

    // Compute the number of older followers and their total age
    val olderFollowers: VertexRDD[(Int, Double)] = graph.aggregateMessages[(Int, Double)](
      triplet => { // Map Function
        if (triplet.srcAttr > triplet.dstAttr) {
          // Send message to destination vertex containing counter and age
          triplet.sendToDst((1, triplet.srcAttr))
        }
      },
      // Add counter and age
      (a, b) => (a._1 + b._1, a._2 + b._2) // Reduce Function
    )
    // Divide total age by number of older followers to get average age of older followers
    val avgAgeOfOlderFollowers: VertexRDD[Double] =
      olderFollowers.mapValues((id, value) =>
        value match {
          case (count, totalAge) => totalAge / count
        })
    // Display the results
    avgAgeOfOlderFollowers.collect.foreach(println(_))
  }
}

/**
  * Spark Graphx图计算案例实战之aggregateMessages求社交网络中的最大年纪追求者和平均年纪！
  */
object AggregateMessages5 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val tempVertice = sc.textFile("E:\\测试文本\\users.txt").map(line => {
      val arr: Array[String] = line.split(",")
      (arr(0).toLong, arr(1).toDouble)
    })

    val graph1: Graph[Int, Int] = GraphLoader.edgeListFile(sc,"E:\\测试文本\\followers.txt").cache()

    //重要方法，对已有的图进行顶点属性替换操作
    val graph2 = graph1.outerJoinVertices(tempVertice)(
      (vId,attr,option) => {
      option.getOrElse(0.0)
    } )

    val graph3 = graph1.joinVertices(tempVertice)((vId,attr,u) => {
      attr
    })

    // 进行聚合求出每个节点追随者的个数和总追随者总的年龄
    val vertice2 : VertexRDD[(Int, Double)]= graph2.aggregateMessages[(Int, Double)](
      ec => ec.sendToDst((1,ec.srcAttr)),
      (a,b) => (a._1 + b._1, a._2 + b._2)
    )

    // 对年龄求平均值
    val aveAgeRDD : VertexRDD[Double]= vertice2.mapValues((vId,tuple) => tuple._2/tuple._1)
    
    println(aveAgeRDD.collect.toBuffer)
//    ArrayBuffer((4,37.0), (6,29.0), (2,23.0), (1,32.5), (3,33.0), (7,29.5))

    // 进行聚合求出年龄最大的追随者
   val maxAgeRDD = graph2.aggregateMessages[(VertexId,Double)](
      ec => ec.sendToDst((ec.srcId,ec.srcAttr)),
     (a,b) => if (a._2 > b._2) a else b
    )

    println("max age--" + maxAgeRDD.collect.toBuffer)
//    max age--ArrayBuffer((4,(5,37.0)), (6,(7,29.0)), (2,(1,23.0)), (1,(2,34.0)), (3,(5,37.0)), (7,(6,33.0)))

    //    val pw=new java.io.PrintWriter("E:\\测试文本\\myGraph.gexf")
//    pw.write(ToGexf.toGexf(graph2))
//    pw.close


    /*println("tempVertice--" + tempVertice.collect().toBuffer)
//    tempVertice--ArrayBuffer((1,23.0), (2,34.0), (3,26.0), (4,31.0), (6,33.0), (7,29.0), (5,37.0))

    println("graph1--" + graph1.vertices.collect().toBuffer)
//    graph1--ArrayBuffer((4,1), (6,1), (2,1), (1,1), (3,1), (7,1), (5,1))

    println("graph2--" + graph2.vertices.collect().toBuffer)
//    graph2--ArrayBuffer((4,31.0), (6,33.0), (2,34.0), (1,23.0), (3,26.0), (7,29.0), (5,37.0))

    println("graph3--" + graph3.vertices.collect().toBuffer)
//    graph3--ArrayBuffer((4,1), (6,1), (2,1), (1,1), (3,1), (7,1), (5,1))*/
  }
}

/**
  * 生成Gexf的xml文件
  */
object ToGexf {
  def toGexf[VD,ED](g:Graph[VD,ED]) : String = {
    val string = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
      "<gexf xmlns=\"http://www.gexf.net/1.2draft\" version=\"1.2\">\n" +
      " <graph mode=\"static\" defaultedgetype=\"directed\">\n" +
      " <nodes>\n" +
      g.vertices.map(v => " <node id=\"" + v._1 + "\" label=\"" +
        v._2 + "\" />\n").collect.mkString +
      " </nodes>\n" +
      " <edges>\n" +
      g.edges.map(e => " <edge source=\"" + e.srcId +
        "\" target=\"" + e.dstId + "\" label=\"" + e.attr +
        "\" />\n").collect.mkString +
      " </edges>\n" +
      " </graph>\n" +
      "</gexf>"
    return string
  }
}
IT社团
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sparkGraphX 图操作：GranphX的map操作（mapVertices、mapEdges、mapTriplets）
weixin_43087913的博客
06-07 296
def mapVertices[VD2](map:(VertexId, VD)=> VD2): Graph[VD2, ED] def mapEdges[ED2](map: Edge[ED] => ED2): Graph[VD, ED2] def mapTriplets[ED2](map: EdgeTriplet[VD, ED] => ED2): Graph[VD, ED2]
graphx-algorithm:在 GraphX 和 Spark 风格中实现的图算法
06-10
graphx-算法 在 GraphX 和 Spark 风格中实现的图算法 集成开发环境 IntelliJ IDEA >= 14 Scala SDK == 2.10.5 火花 1.3.0 GraphX 2.1.0 Apache Maven >= 3.3.1 开发目录 算法的实现放置在包org.apache.spark.graphx.iiot 。 其他修改/添加的文件如下： org.apache.spark.graphx.GraphLoaderPlus Spark 项目示例 Spark 文档 Scala 文档 算法
Spark入门实战系列--9.Spark图计算GraphX介绍及实例
yyy
09-16 1768
1、GraphX介绍 1.1 GraphX应用背景 Spark GraphX是一个分布式图处理框架，它是基于Spark平台提供对图计算和图挖掘简洁易用的而丰富的接口，极大的方便了对分布式图处理的需求。 众所周知·，社交网络中人与人之间有很多关系链，例如Twitter、Facebook、微博和微信等，这些都是大数据产生的地方都需要图计算，现在的图处理基本都是分布式的图处理，而并非单机处理。Sp
Spark GraphX图计算实例
赵昕彧
12-19 436
航空数据简单计算 数据格式 dom – 月中第几天 (day of month) dow – 周中第几天 (day of week) carrier – 航空公司 tail_num – 飞机注册号 fl_num – 航班号 origin_id – 起飞机场编号 origin – 起飞机场 dest_id – 到达机场编号 dest – 到达机场 crs_dep_time – 预计起飞时间 d...
Spark_GraphX大规模图计算和图挖掘
12-05
Spark_GraphX大规模图计算和图挖掘
graphx解决图中心
BookLing的博客
09-15 3426
图的中心点所谓图的中心点，就是到其他点的距离之和最小的点，可以将它近似看做图。如果将该点看作根节点，那么各层顶点到根节点的距离之和也是最小的。示例下图中的中心点是哪个呢？图中各点到其他点距离之和分别是{1-> 14, 2->14, 3->9, 4->8 , 5->13, 6->12, 7->12}。很明显到其他距离最小的点是4(距离之和为8)，所以4是该图的中心点。 以4为根节点形成的最小生成树图
深入Spark GraphX：图计算的利器
最新发布
07-28
### 深入Spark GraphX：图计算的利器 #### 引言 随着大数据时代的到来，数据科学家们面临着越来越复杂的任务。其中，图计算作为一项关键的技术，在处理诸如社交网络、交通网络、分子结构等复杂关系时发挥着不可替代...
Spark-Scala-Maven-示例：Spark，Scala项目的示例Maven配置
02-03
Spark的核心特性包括支持批处理、交互式查询（通过Spark SQL）、实时流处理（通过Spark Streaming）以及机器学习库（MLlib）和图形处理（GraphX）。 Scala是Spark的主要编程语言，它是一种静态类型的多范式编程语言...
learning-spark:学习编写 Spark 示例
06-02
5. GraphX：用于图计算，提供了一种API来表示和操作图数据。 四、Spark开发环境搭建 要开始Spark编程，首先需要安装Scala和Spark，然后设置环境变量，创建Spark项目并导入必要的依赖。对于初学者，推荐使用IDEA或...
Spark真实世界：Spark真实世界练习和示例
02-20
此外，教程可能还会涉及其他主题，比如Spark的YARN或Mesos集群管理，以及如何使用Spark的图形处理库GraphX进行图计算。通过实践这些示例，学习者不仅能掌握Spark的基本用法，还能了解到如何在实际项目中解决复杂的...
ndegree.zip
02-04
GraphX是Apache Spark的一个模块，专门用于图形处理，它提供了一个高级接口，用于构建和操作图数据结构。GraphX将图表示为顶点集合和边集合，这两个集合都是RDD（弹性分布式数据集）的实例，因此可以利用Spark的并行...
大数据spark实验报告
05-12
Spark的GraphX组件支持图数据处理。实验可能涉及构建图模型、执行PageRank算法以评估节点重要性，或使用BFS（广度优先搜索）探索图结构。 ### 性能优化 实验还可能涉及性能调优，如减少shuffle操作、利用Spark SQL...
spark-intro-training:《Spark入门》培训项目示例
05-30
5. **GraphX**：用于处理图形数据的API，它提供了一种统一的方式来表示和操作图数据，支持图算法的高效执行。 在`spark-intro-training-master`这个项目中，你可能会接触到以下关键概念和实践操作： - **Spark ...
spark-3.2.4-bin-hadoop3.2-scala2.13 安装包
08-28
8. **生态系统**: Spark的生态非常丰富，包括DataFrame/Dataset API、Spark SQL、Spark Streaming、GraphX（图计算）、MLlib（机器学习库）和SparkR（R语言接口）。这些组件可以组合使用，满足各种大数据处理需求。 ...
spark-2.4.0-bin-hadoop2.7.tgz
05-29
5. **GraphX**：Spark的图计算框架，用于处理图数据和执行图算法，如PageRank、社区检测等。 6. **Spark R**：Spark与R语言的集成，允许R用户利用Spark的大数据处理能力。 7. **PySpark**：Python接口，让Python...
Spark Graphx常用函数
菜鸟也学大数据的博客
11-26 400
Spark Graph定义 object SparkGraph { def main(args: Array[String]): Unit = { val spark: SparkSession = SparkSession.builder().master("local").appName("Graph").getOrCreate() val sc: SparkContext = spark.sparkContext //创建Vertices //注意元组的顶点的数据类
第八章：在Spark集群上掌握比较重要的图操作之Property Operators（1）
sdujava2011
07-16 550
本部分的内容专注于集群上Property Operator的内容，其中比较重要的就是mapVertices、mapEdges和mapTriplets，即对顶点进行map、对边进行map、对Triplets进行map，在Graph中其方法分别如下所示：       首先来看一下graph实例中的10个元素的具体的值：   可以看到这个10个顶点元素中每个顶
Spark GraphX图计算入门基础
BigData_Hubert的博客
10-13 1625
spark 系列 Spark 核心原理及运行架构 Spark RDD详解 Spark 常用算子大全 Spark SQL 详解 Spark GraphX 图计算入门基础 Spark GraphX图计算入门基础spark 系列前言Spark GraphX 简介GraphX应用背景GraphX 核心APIGraphX 特点Spark GraphX 实现原理两种视图存储模式计算模式GraphX实例 前言 前面几篇博客已经为大家介绍了 Spark 的基础框架、RDD、核心 SparkCore 和 Spark
Spark中文手册8：spark GraphX编程指南（1）
木东的博客
12-15 1390
1.什么是GraphX？ 2.如何将Spark和GraphX引入到项目中？ 3.从一个图中取出顶点特征加入到另外一个图中如何实现？ Spark中文手册-编程指南 Spark之一个快速的例子Spark之基本概念 Spark之基本概念 Spark之基本概念（2） Spark之基本概念（3） Spark-sql由入门到精通 Spark-sql由入门到精通续
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值