spark中用于添加元组的reduceByKey
在Spark中，reduceByKey是一个用于添加元组的转换操作。它根据键对元组进行分组，并对每个键对应的值进行聚合操作，最终返回一个新的键值对RDD。
reduceByKey的工作原理是将具有相同键的值进行合并，并将结果作为新的键值对返回。它通过并行处理数据集的不同分区来实现高效的聚合操作。
reduceByKey的优势在于它能够在数据处理过程中减少数据的传输量，从而提高计算效率。它适用于需要对具有相同键的值进行聚合操作的场景，比如统计每个键对应的值的总和、平均值等。
在腾讯云的产品中，与Spark相关的产品是腾讯云的Tencent Spark，它是一种基于开源Spark的大数据处理平台。Tencent Spark提供了一系列的服务和工具，用于支持Spark应用程序的开发、部署和管理。您可以通过以下链接了解更多关于Tencent Spark的信息：
总结：reduceByKey是Spark中用于添加元组的转换操作，它能够对具有相同键的值进行聚合操作，并返回一个新的键值对RDD。腾讯云的相关产品是Tencent Spark，它是一种基于开源Spark的大数据处理平台。
相关·内容
下面是我在reduceByKey上试用的代码：
import org.apache.spark.rdd.RDD
import org.apache.spark.SparkContext._
import org.apache.spark.SparkContext
import scala.math.random
import org.apache.spark._
import org.apache.spark.storage.StorageLevel
object MapReduce {
def main(args: Array[String]) {
val sc = new
浏览 0提问于2014-06-06得票数 8
我想使用一个((String，String)，BigDecimal) RDD作为一个PairRDD，这样我就可以使用reduceByKey函数了。Spark不会将RDD识别为PairRDD。有没有办法用RDD实现reduce功能？ scala> jrdd2
jrdd2: org.apache.spark.rdd.RDD[((String, String), java.math.BigDecimal)] = MapPartitionsRDD[33] at map at <console>:30
scala> val jrdd3 = jrdd2.reduceBykey(
浏览 9提问于2019-05-15得票数 0
它的sad.My火花版本是2.1.1，Scala版本是2.11
import org.apache.spark.SparkContext._
import com.mufu.wcsa.component.dimension.{DimensionKey, KeyTrait}
import com.mufu.wcsa.log.LogRecord
import org.apache.spark.rdd.RDD
object PV {
//
def stat[C <: LogRecord,K <:DimensionKey](statTrait: KeyTrait[C ,K],log
浏览 0提问于2017-08-10得票数 9
回答已采纳
当我调用RDD.mapValues(...).reduceByKey(...)时，我的代码不会编译。但是当我倒序时，RDD.reduceByKey(...).mapValues(...)，代码确实编译了。类型似乎匹配。
一个完整的最小复制示例是：
def test[E]() =
new SparkContext().textFile("")
.keyBy(_ ⇒ 0L)
.mapValues(_.asInstanceOf[E])
.reduceByKey((x, _) ⇒ x)
编译错误与中的编译错误相同，但其补救措施没有
浏览 0提问于2018-03-21得票数 0
回答已采纳
1回答
我使用以下代码将Spark-Streaming的输出存储到ElasticSearch。我想把火花流的输出映射到正确的名称i.e (Key, OsName, PlatFormName, Mobile, BrowserName, Count)。但是，正如您目前看到的，它是映射在ES中，如_1或_2等。此外，我还想在ES中索引数据之前添加一些过滤器，即(if PlatFormName = "ubuntu" then index the data)。那我该怎么做呢？
val realTimeAgg = lines.map{ x => ((x.key, x.os, x.platf
浏览 1提问于2016-05-19得票数 1
回答已采纳
我在使用Spark reduceByKey / groupByKey函数时遇到了问题。
我有一双(datetime, [a1, b1, c1, d1]), (datetime, [a2, b2, c2, d2]) ...格式的RDD
我想按键对这些元素进行分组(这里与datetime相同)，并获得与元素最小值列表相对应的输出值。
在我的示例中，输出将是：
(datetime, [min(a1,a2), min(b1,b2), min(c1,c2), min(d1,d2)])
我试过了：
reduceByKey(lambda (a, b): [min(x) for x in zip(a, b)]
浏览 3提问于2016-08-23得票数 0
2回答
如何将此示例scala spark代码转换为apache flink？
reduceByKey( (x, y) => (x._1 + y._1, ( (x._2) ++ y._2) ) )
我意识到reduceByKey在flink中并不存在，但它显示了我正在努力实现的目标。
谢谢你的帮助！
浏览 3提问于2015-12-08得票数 2
在Spark中，为什么CountbyKey()是作为动作而不是转换来实现的。我认为它的功能类似于Reducebykey或combinebykey。有没有什么特别的原因让它实现为Action..
浏览 1提问于2019-04-12得票数 2
1回答
有没有办法测量Spark中每个运算符的运行时间
例如，我有以下字数统计代码：
val counts = textFile.flatMap(line => line.split(" "))
.map(word => (word, 1))
.reduceByKey(_ + _)
如何分别测量每个map/flatMap/reduceByKey运算符的运行时？
浏览 0提问于2018-03-12得票数 1
我正在为CCA175做准备，我使用的是spark最老的版本，Spark 1.3.0。
如下所示，我在映射时将元素转换为浮点数，但在减少它时显示了编译时错误。
scala> val revenuePerDay = ordersJoinOrderItems.map(x => (x._2._1, (x._1, (x._2._2).toFloat)))
revenuePerDay: org.apache.spark.rdd.RDD[(String, (Int, Float))] =
MapPartitionsRDD[21] at map at <cons
浏览 0提问于2016-09-03得票数 1
我在spark中运行reduceByKey。我的程序是spark最简单的例子：
val counts = textFile.flatMap(line => line.split(" ")).repartition(20000).
.map(word => (word, 1))
.reduceByKey(_ + _, 10000)
counts.saveAsTextFile("hdfs://...")
但它总是会耗尽内存...
我使用50台服务器，每台服务器35个执行器，每台服务器14
浏览 0提问于2015-07-01得票数 8
我是很新的火花编程。我正在尝试将地图和reduceByKey实现到以下15个字段的数据集。
rdd=sc.parallelize([
("West", "Apple", 2.0, 10,2.0, 10,2.0, 10,2.0, 10,2.0, 10,2.0,2.0, 10),
("West", "Apple", 3.0, 10,2.0, 10,2.0, 10,2.0, 10,2.0, 10,2.0, 10,2.0])
这是我的map函数，在这里我试图创建一个包含多个键和值的元组。
rdd1 = rdd.map(lambda
浏览 1提问于2015-08-27得票数 1
2回答
(u'142578', (u'The-North-side-9890', (u' 12457896', 45.0)))
(u'124578', (u'The-West-side-9091', (u' 14578217', 0.0)))
通过使用这个Spark，我加入了两个基于is的(key，(value_left，value_right))。
所以我想要输出像
The-North-side-9890,12457896,45.0
The-West-side-9091,14578217,0.0
浏览 4提问于2015-12-15得票数 4
回答已采纳
1回答
带字典的PySpark约简键
、、、、
为什么Spark强制从元组列表中构建RDD，以便在进行还原键转换的情况下？
reduce_rdd = sc.parallelize([{'k1': 1}, {'k2': 2}, {'k1': -2}, {'k3': 4}, {'k2': -5}, {'k1': 4}])
print(reduce_rdd.reduceByKey(lambda x, y: x + y).take(100))
错误：
for k, v in iterator:
ValueError: need more than 1 v
浏览 0提问于2018-01-18得票数 1
我是Spark和Scala的新手。我对reduceByKey函数在Spark中的工作方式感到困惑。假设我们有以下代码：
val lines = sc.textFile("data.txt")
val pairs = lines.map(s => (s, 1))
val counts = pairs.reduceByKey((a, b) => a + b)
映射函数很清晰:s是键，它指向data.txt中的行，1是值。
但是，我不知道reduceByKey在内部是如何工作的？"a“是否指向关键字？或者，"a“是否指向"s"？那么a+ b
浏览 42提问于2015-05-10得票数 66
回答已采纳
因此，在Spark中，当一个应用程序启动时，就会创建一个包含该应用程序的数据集(例如，WordCount的words数据集)的RDD。
到目前为止，我所理解的是，RDD是WordCount中这些单词的集合，以及对这些数据集所做的操作(例如，map、reduceByKey等)。
然而，afaik，Spark也有HadoopPartition (或一般的:分区)，它由每个执行器从HDFS读取。我相信驱动程序中的RDD也包含所有这些分区。
那么，Spark中的执行者之间是如何划分的呢？是否每个执行器都将这些子数据集作为单个RDD获取，与驱动程序中的RDD相比，RDD包含的数据更少，还是每个执行器只处
浏览 1提问于2016-04-11得票数 0
我目前正在自学Spark programming，并试图用PySpark重新编写一个现有的Python应用程序。然而，我仍然对如何在PySpark中使用常规Python对象感到困惑。
我了解Spark中的分布式数据结构，如RDD、DataFrame、Datasets、vector等。Spark有自己的转换操作和动作操作，如.map()、.reduceByKey()来操作这些对象。但是，如果我在PySpark中创建传统的Python数据对象，比如数组、列表、元组或字典，会怎么样呢？它们将只存储在我的驱动程序节点的内存中，对吗？如果我把它们转换成RDD，我还能用典型的Python函数做操作吗？
如
浏览 34提问于2017-03-01得票数 1
回答已采纳
Spark SQL中Group By子句的底层实现是什么？我知道Spark支持下面两种类型的Group by操作，即GroupByKey和ReduceByKey。ReduceByKey是一种map side reduce，它提供了比GroupByKey更好的性能。
在我们的应用程序代码中，我们在Spark Dataframe上使用Spark SQL，而不是直接创建RDDs。所以，我想到了这个问题，Spark SQL中的GroupBy是做GroupByKey还是ReduceByKey，还是别的什么。
浏览 0提问于2019-08-30得票数 1
2回答
在scala中，我见过reduceByKey((x: Int , y Int) => x + y)，但我想将一个值作为字符串进行迭代，并进行一些比较。我们可以通过reduceByKey(x: String , y: String)使用reduceByKey吗？
代码：
val sparkConf = new SparkConf().setMaster("local").setAppName("Spark AVRO Read")
val sc = new SparkContext(sparkConf)
val inPath= "/home/0537
浏览 3提问于2016-05-04得票数 1
如何从下面的火花作业输出中删除括号"(“和")”？
当我尝试使用PigScript读取火花输出时，它会产生一个问题。
我的代码：
scala> val words = Array("HI","HOW","ARE")
words: Array[String] = Array(HI, HOW, ARE)
scala> val wordsRDD = sc.parallelize(words)
wordsRDD: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD
浏览 6提问于2016-12-30得票数 4
回答已采纳
正在尝试从源运行。
这一行：
val wordCounts = textFile.flatMap(line => line.split(" ")).map(word => (word, 1)).reduceByKey((a, b) => a + b)
抛出错误
value reduceByKey is not a member of org.apache.spark.rdd.RDD[(String, Int)]
val wordCounts = logData.flatMap(line => line.split(" ")).map(
浏览 0提问于2014-05-30得票数 25
回答已采纳
你好~我对火花感兴趣。我在火花壳中使用下面的代码。
val data = sc.parallelize(Array(Array(1,2,3), Array(2,3,4), Array(1,2,1))
res6: org.apache.spark.rdd.RDD[Array[Int]] = ParallelCollectionRDD[0] at parallelize at <console>:26
data.map(x => (x(d), 1)).reduceByKey((x,y) => x + y).sortBy(_._1)
res9: Array[(Int, In
浏览 0提问于2016-10-25得票数 1
回答已采纳
1回答
我是apache spark的新手，不知道我是误解了reduceByKey还是遇到了bug。我使用spark-1.4.1-bin-hadoop1构建，因为spark-1.4.1-bin-hadoop2中的python Cassandra接口有问题。
reduceByKey(lambda x，y: y)返回最后一个元组的第一个值，但是reduceByKey(lambda x，y: x)抛出异常。
尝试使用reduceByKey(lambda x，y: x+y)通过键对值求和，但该语句抛出与x相同的异常。
代码片段：
import sys
from pyspark import SparkCon
浏览 4提问于2015-09-24得票数 0
1回答
我有多个rdd，并且希望通过加入它来获得常用的单词，并获得最小数量的.So，我加入并通过下面的代码获得它：
from pyspark import SparkContext
sc = SparkContext("local", "Join app")
x = sc.parallelize([("spark", 1), ("hadoop", 4)])
y = sc.parallelize([("spark", 2), ("hadoop", 5)])
joined = x.join(y).map(lam
浏览 1提问于2019-09-24得票数 0
回答已采纳
已经有了一个类似的问题，但它使用的是Maven，而我使用的是sbt。而且，没有一个解决方案对我有效。
我正在使用Spark2.4.0，Scala2.11.12和IntelliJ IDEA 2019.1
我的build.sbt看起来像：
libraryDependencies ++= Seq(
"com.groupon.sparklint" %% "sparklint-spark212" % "1.0.12" excludeAll ExclusionRule(organization = "org.apache.spark"
浏览 0提问于2019-04-28得票数 1
回答已采纳
在此中，大多数答案都介绍了groupByKey + reduceGroups策略。然而，我没有发现任何关于为什么spark删除reduceByKey接口的评论。有评论说，Spark的Catalyst Optimizer可以降低一些计算，这可能解释了为什么。然而，根据作者和我的测试，Dataset的groupByKey + reduceGroups策略比reduceByKey慢得多。
那么为什么要删除reduceByKey，我如何才能找到替代它的方法呢？
浏览 45提问于2019-08-05得票数 0
回答已采纳
在下面的代码中，我试图组合值：
val rdd: org.apache.spark.rdd.RDD[((String), Double)] =
sc.parallelize(List(
(("a"), 1.0),
(("a"), 3.0),
(("a"), 2.0)
))
val reduceByKey = rdd.reduceByKey((a , b) => String.valueOf(a) + String.valueOf(b))
reduceByValue应该包含(a，1,3
浏览 10提问于2014-12-17得票数 3
回答已采纳
1回答
无键PySpark计数群
、、、
我有一个星星之火RDD对象(使用pyspark)，并且我正在尝试获得与SQL的等价的
SELECT MY_FIELD COUNT(*) GROUP BY MY_FIELD
因此，我尝试了以下代码：
my_groupby_count = myRDD.map(lambda x: x.type).reduceByKey(lambda x, y: x + y).collect()
# 'type' is the name of the field inside the RDD row
但是我得到了一个错误，我不知道该如何处理：
-----------------------------
浏览 0提问于2020-11-16得票数 0
回答已采纳
我试图使用Scala在Spark中创建一些简单的自定义聚合操作符。
我创建了一个简单的操作符层次结构，具有以下超类：
sealed abstract class Aggregator(val name: String) {
type Key = Row // org.apache.spark.sql.Row
type Value
...
}
我还有一个配套的对象，它每次构造适当的聚合器。注意每个操作符都可以指定它想要的值类型。
现在的问题是当我试图调用combineByKey
val agg = Aggregator("SUM")
val res = rdd
浏览 1提问于2018-05-13得票数 1
回答已采纳
就功能而言，Apache Spark中的reduce和reduceByKey有什么不同？为什么reduceByKey是一种转换而reduce是一种操作？
浏览 3提问于2017-12-22得票数 16
最近，我有了将数据存储在keyValue对中的场景，并遇到了一个函数reduceByKey(_ ++ _)。这是更多的速记语法。我不明白这究竟是甚麽意思。
例：reduceBykey(_ + _)的意思是reduceByKey((a,b)=>(a+b))
所以reduceByKey(_ ++ _)的意思是？
我能够使用reduceByKey(_ ++ _)从数据中创建密钥值对。
val y = sc.textFile("file:///root/My_Spark_learning/reduced.txt")
y.map(value=>value.split(
浏览 1提问于2017-05-23得票数 6
回答已采纳
我的rdd中的每个值都是一个元组：
temp = clustering.map(lambda x: (x[0][0], (1,1)))
temp.take(10)
[(0, (1, 1)),
(0, (1, 1)),
(6, (1, 1)),
(0, (1, 1)),
(0, (1, 1)),
(0, (1, 1)),
(0, (1, 1)),
(0, (1, 1)),
(7, (1, 1)),
(0, (1, 1))]
然后尝试通过key减少它：
temp.reduceByKey(lambda a,b: (a[1]+b[1])).collect()
并得到了这个错误：
浏览 0提问于2019-09-19得票数 0
1回答
我只在一个具有Spark的节点上运行Parallelism = 1，以便将其性能与单线程应用程序进行比较。我想知道Spark是否仍然在使用Shuffle，尽管它不是并行运行的。因此，如果执行以下命令：
val counts = text_file.flatMap(line => line.split(" "))
.map(word => (word, 1))
.reduceByKey(_+_)
我从获得以下输出：
counts: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[10]
浏览 1提问于2015-12-13得票数 3
回答已采纳
2回答
下面的代码执行集合类型的单词计数：org.apache.spark.rdd.RDD[(String, List[(String, Int)])]
val words : org.apache.spark.rdd.RDD[(String, List[(String, Int)])] = sc.parallelize( List(("a" , List( ("test" , 1) , ("test" , 1)))) )
val missingLabels : RDD[(String, Int)] = words.flatMap(m => m._
浏览 1提问于2015-04-10得票数 0
回答已采纳
1回答
我只是想学习PySpark，但对下面两个RDDs之间的区别感到困惑，我知道一个是类型集，一个是列表，但都是RDDs。
rdd = sc.parallelize([('a', 1), ('b', 1), ('a', 3)])
type(rdd)
和
rdd = sc.parallelize(['a, 1', 'b, 1', 'a, 3'])
type(rdd)
处理地图和缩减功能的代码：
priceMap= s.map(lambda o: (o.split(",")[0], float
浏览 1提问于2020-11-12得票数 0
回答已采纳
我有一个包含以下数据的Spark数据帧(我使用spark-csv加载数据)：
key,value
1,10
2,12
3,0
1,20
有没有类似于spark RDD reduceByKey的东西，它可以返回Spark DataFrame为：(基本上，对相同的键值进行求和)
key,value
1,30
2,12
3,0
(我可以将数据转换为RDD并执行reduceByKey操作，但是有没有更好的Spark DataFrame API方法呢？)
浏览 1提问于2015-12-13得票数 11
回答已采纳
我刚开始学Python。我正在使用一个API来构建一个IDFs模型，但是我在lambda函数中遇到了一些错误，我无法解决这些错误。这是生成以色列国防军的类：
class Idfs(DocumentFrequencies, Model):
def build(self, corpus):
log.info('Counting documents in corpus...')
N = float(corpus.count())
dfs = super(Idfs, self).build(corpus)
lo
浏览 0提问于2018-05-17得票数 1
回答已采纳
GroupBy vs ReduceBy: GroupBy是不是很糟糕？如果GroupByKey是那么糟糕，并且它产生的输出与ReduceByKey相同，那么为什么spark要创建这个函数？GroupByKey应该有一个用例，它消耗更多的网络带宽和更多的混洗，但在某些情况下仍然比ReduceBy和AggregateBy有用。如果一点用处都没有，那么这个函数应该在即将发布的版本中从Spark中删除。
浏览 0提问于2019-01-03得票数 0
我正在用spark-scala做一些基本的处理
要求显示每个组织中的员工数量。
我已经通过使用groupByKey和Mapvalues达到了相同的要求，我还通过创建一个数组作为数组((CTS，1) (CTS,1)，(TCS,1))，然后在其上应用reduceByKey((x，y) => x+y)来达到相同的要求。两者都产生了正确的预期结果。
现在我正在尝试下面的逻辑风格。我想使用reduceByKey，但我不想使用硬编码值为1的KeyValueRDD来实现员工计数。
请帮助我更改下面的代码，以获得预期的输出。另外，我想知道为什么我在代码中得到了错误的输出
因为reduceByKey是可交
浏览 3提问于2017-02-18得票数 0
回答已采纳
我正在我的虚拟机(Ubuntu 12.04)上运行一个spark(1.2.1)独立集群。我可以成功地运行als.py和pi.py等示例。但是我不能运行workcount.py示例，因为会出现连接错误。
bin/spark-submit --master spark://192.168.1.211:7077 /examples/src/main/python/wordcount.py ~/Documents/Spark_Examples/wordcount.py
错误信息如下：
15/03/13 22:26:02 INFO BlockManagerMasterActor: Re
浏览 0提问于2015-03-13得票数 0
我无法访问包中的SparkConf。但是我已经导入了import org.apache.spark.SparkConf。我的代码是：
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.stre
浏览 0提问于2015-12-05得票数 2
回答已采纳
1回答
我想上些关于电火花输入法的课。
我的平台在下面。
Red Hat Enterprise Linux Server release 6.8 (Santiago)
spark version 1.6.2
python 2.6
我在模块basic_lib.py中定义了def，如下所示。
def selectRowByTimeStamp(x,y):
if x._1 > y._1:
return x
return y
下面是我的主要代码片段
df2 = df2.map(lambda x: (x._2, x))
rdd = df2.reduceByKey(ba
浏览 3提问于2016-09-17得票数 1
回答已采纳
在spark中，人们也可以使用spark api函数来编写sql查询。应该始终使用ReduceByKey而不是groupbykey，因为它可以防止更多的混洗。 我想知道，当您通过注册数据帧来使用sql查询时，我们如何使用reduceby？在sql查询中，只有group by，没有reduce。在内部，使用reduceBykey比使用group by更优化吗？
浏览 21提问于2020-09-07得票数 0
1回答
下面是我使用Scala在spark.streaming中获取Flume事件和进程的代码。
当尝试使用reduceBykey函数时，我得到以下编译错误：
value reduceByKey is not a member of org.apache.spark.streaming.dstream.DStream[(String, Int)]
为什么？
我们是否需要以除此以外的任何特定方式处理水槽流？
我不认为这是一个依赖问题，我有其他简单的应用程序在使用reduceBykey的同一个Eclipse中工作。
package com.deloitte.spark.learning
impo
浏览 0提问于2015-09-18得票数 1
回答已采纳
1回答
我正在编写一个在HDFS上运行的Spark应用程序，输出是一个RDD，我必须将其保存到RocksDB。但我不知道如何让RocksDB与HDFS和Spark一起工作。请给我一些关于如何在HDFS上设置RocksDB并将其与Spark集成的说明 我们已经访问了网站https://github.com/facebook/rocksdb/tree/master/hdfs，但是我们找不到hdfs.h和libhdfs，所以我们不知道如何继续。 var sq = Seq[RDD[(String, Array[String])]]()
for (file <- files) {
val fi
浏览 76提问于2019-10-07得票数 0
我想知道为什么在使用reduceByKey函数计算每个给定名称(键)中每个列表中所有字符的总长度时，会出现类型错误。
data = [("Cassavetes, Frank", 'Orange'),
("Cassavetes, Frank", 'Pineapple'),
("Knight, Shirley (I)", 'Apple'),
("Knight, Shirley (I)", 'Blueberries'),
("Knight, Shirley (I)&
浏览 6提问于2021-03-17得票数 1
回答已采纳
在的例子中
// Perform word count.
val wordCounts = (tableData
.map(entry => convertToTuple(entry._2))
.reduceByKey(_ + _))
// Write data back into a new BigQuery table.
// IndirectBigQueryOutputFormat discards keys, so set key to null.
(wordCounts
.map(pair => (null, convertToJson(pai
浏览 2提问于2017-10-07得票数 1
我在集群上分区了一个RDD，并且我想在每个分区上分别执行reduceByKey。我不希望分区上的reduceByKey结果合并在一起。我想阻止Spark在集群中对reduceByKey的中间结果进行混洗。
下面的代码不能工作，但我想要这样的东西：
myPairedRDD.mapPartitions({iter => iter.reduceByKey((x, y) => x + y)})
我如何才能做到这一点？
浏览 0提问于2018-05-11得票数 1
我是一个spark的新手，我正在尝试使用以下spark函数执行group by和count：
Dataset<Row> result = dataset
.groupBy("column1", "column2")
.count();
但我在上读到，使用group by不是一个好主意，因为它没有组合器，这反过来会影响spark作业的运行效率。相反，应该使用reduceByKey函数进行聚合操作。
所以我尝试使用reduceByKey函数，但它不适用于dataset。相反，数据集使用reduce(ReduceFuncti
浏览 9提问于2018-08-15得票数 2
回答已采纳
每个分区的初始内容是在Spark中的洗牌(例如，如果我们执行reduceByKey)结束后更改，还是Spark只是将数据读入内存而不更改分区？
浏览 6提问于2016-11-29得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
