spark api 简单的chrome 翻译

接口 JavaRDDLike>

• 所有超级接口：

  java.io.Serializable

  所有已知的实现类：

  JavaDoubleRDD、JavaPairRDD、JavaRDD、JavaSchemaRDD

  ---

   

  公共接口JavaRDDLike> 
  extends scala.Serializable

• 方法总结

  方法 

  修饰符和类型	方法和说明
  U	aggregate(U zeroValue, Function2 seqOp, Function2 combOp) 使用给定的组合函数和中性的“零值”聚合每个分区的元素，然后聚合所有分区的结果。
  JavaPairRDD	cartesian(JavaRDDLike other) 返回这个 RDD 和另一个 RDD 的笛卡尔积，即所有元素对 (a, b) 的 RDD，其中 a is inthis和 b is in other。
  void	checkpoint() 将此 RDD 标记为检查点。
  scala.reflect.ClassTag	classTag()
  java.util.List	collect() 返回一个包含此 RDD 中所有元素的数组。
  java.util.List[]	collectPartitions(int[] partitionIds) 返回一个数组，该数组包含此 RDD 特定分区中的所有元素。
  SparkContext	context() 在SparkContext这RDD上创建。
  long	count() 返回 RDD 中元素的数量。
  PartialResult	countApprox(long timeout) :: 实验 :: count() 的近似版本在超时内返回可能不完整的结果，即使并非所有任务都已完成。
  PartialResult	countApprox(long timeout, double confidence) :: 实验 :: count() 的近似版本在超时内返回可能不完整的结果，即使并非所有任务都已完成。
  long	countApproxDistinct(double relativeSD) 返回 RDD 中不同元素的近似数量。
  java.util.Map	countByValue() 返回此 RDD 中每个唯一值的计数作为 (value, count) 对的映射。
  PartialResult>	countByValueApprox(long timeout) （实验性）countByValue() 的近似版本。
  PartialResult>	countByValueApprox(long timeout, double confidence) （实验性）countByValue() 的近似版本。
  T	first() 返回此 RDD 中的第一个元素。
  JavaRDD	flatMap(FlatMapFunction f) 通过首先将函数应用于此 RDD 的所有元素，然后展平结果，返回一个新的 RDD。
  JavaDoubleRDD	flatMapToDouble(DoubleFlatMapFunction f) 通过首先将函数应用于此 RDD 的所有元素，然后展平结果，返回一个新的 RDD。
  JavaPairRDD	flatMapToPair(PairFlatMapFunction f) 通过首先将函数应用于此 RDD 的所有元素，然后展平结果，返回一个新的 RDD。
  T	fold(T zeroValue, Function2 f) 使用给定的关联函数和中性的“零值”聚合每个分区的元素，然后聚合所有分区的结果。
  void	foreach(VoidFunction f) 将函数 f 应用于此 RDD 的所有元素。
  void	foreachPartition(VoidFunction> f) 将函数 f 应用于此 RDD 的每个分区。
  com.google.common.base.Optional	getCheckpointFile() 获取此 RDD 被检查点的文件的名称
  StorageLevel	getStorageLevel() 获取 RDD 的当前存储级别，如果没有设置，则获取 StorageLevel.NONE。
  JavaRDD>	glom() 返回通过将每个分区中的所有元素合并到一个数组中创建的 RDD。
  JavaPairRDD>	groupBy(Function f) 返回分组元素的 RDD。
  JavaPairRDD>	groupBy(Function f, int numPartitions) 返回分组元素的 RDD。
  int	id() 此 RDD 的唯一 ID（在其 SparkContext 中）。
  boolean	isCheckpointed() 返回此 RDD 是否已被检查点
  java.util.Iterator	iterator(Partition split, TaskContext taskContext) 此 RDD 的内部方法；如果适用，将从缓存中读取，或以其他方式计算它。
  JavaPairRDD	keyBy(Function f) 通过应用创建此 RDD 中元素的元组f。
  JavaRDD	map(Function f) 通过对这个 RDD 的所有元素应用一个函数来返回一个新的 RDD。
  JavaRDD	mapPartitions(FlatMapFunction,U> f) 通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。
  JavaRDD	mapPartitions(FlatMapFunction,U> f, boolean preservesPartitioning) 通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。
  JavaDoubleRDD	mapPartitionsToDouble(DoubleFlatMapFunction> f) 通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。
  JavaDoubleRDD	mapPartitionsToDouble(DoubleFlatMapFunction> f, boolean preservesPartitioning) 通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。
  JavaPairRDD	mapPartitionsToPair(PairFlatMapFunction,K2,V2> f) 通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。
  JavaPairRDD	mapPartitionsToPair(PairFlatMapFunction,K2,V2> f, boolean preservesPartitioning) 通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。
  JavaRDD	mapPartitionsWithIndex(Function2,java.util.Iterator> f, boolean preservesPartitioning) 通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD，同时跟踪原始分区的索引。
  JavaDoubleRDD	mapToDouble(DoubleFunction f) 通过对这个 RDD 的所有元素应用一个函数来返回一个新的 RDD。
  JavaPairRDD	mapToPair(PairFunction f) 通过对这个 RDD 的所有元素应用一个函数来返回一个新的 RDD。
  T	max(java.util.Comparator comp) 返回此 RDD 中由指定的 Comparator[T] 定义的最大元素。
  T	min(java.util.Comparator comp) 返回此 RDD 中由指定的 Comparator[T] 定义的最小元素。
  String	name()
  JavaRDD	pipe(java.util.List command) 将管道元素创建的 RDD 返回到分叉的外部进程。
  JavaRDD	pipe(java.util.List command, java.util.Map env) 将管道元素创建的 RDD 返回到分叉的外部进程。
  JavaRDD	pipe(String command) 将管道元素创建的 RDD 返回到分叉的外部进程。
  RDD	rdd()
  T	reduce(Function2 f) 使用指定的可交换和结合二元运算符减少此 RDD 的元素。
  void	saveAsObjectFile(String path) 将此 RDD 保存为序列化对象的 SequenceFile。
  void	saveAsTextFile(String path) 使用元素的字符串表示将此 RDD 保存为文本文件。
  void	saveAsTextFile(String path, Class codec) 使用元素的字符串表示将此 RDD 保存为压缩文本文件。
  java.util.List	splits() 此 RDD 中的一组分区。
  java.util.List	take(int num) 取 RDD 的前 num 个元素。
  java.util.List	takeOrdered(int num) 使用 T 的自然排序返回此 RDD 的前 K 个元素，同时保持顺序。
  java.util.List	takeOrdered(int num, java.util.Comparator comp) 返回此 RDD 中由指定的 Comparator[T] 定义的前 K 个元素并保持顺序。
  java.util.List	takeSample(boolean withReplacement, int num)
  java.util.List	takeSample(boolean withReplacement, int num, long seed)
  java.util.List	toArray() 已弃用。  从 Spark 1.0.0 开始，不推荐使用 toArray()，collect()改为使用
  String	toDebugString() 此 RDD 的描述及其用于调试的递归依赖项。
  java.util.Iterator	toLocalIterator() 返回包含此 RDD 中所有元素的迭代器。
  java.util.List	top(int num) 使用 T 的自然排序从这个 RDD 返回前 K 个元素。
  java.util.List	top(int num, java.util.Comparator comp) 返回此 RDD 中由指定的 Comparator[T] 定义的前 K 个元素。
  This	wrapRDD(RDD rdd)
  JavaPairRDD	zip(JavaRDDLike other) 用另一个 RDD 压缩这个 RDD，返回键值对，每个 RDD 中的第一个元素，每个 RDD 中的第二个元素，等等。
  JavaRDD	zipPartitions(JavaRDDLike other, FlatMapFunction2,java.util.Iterator,V> f) 用一个（或多个）RDD 压缩这个 RDD 的分区，并通过对压缩的分区应用一个函数来返回一个新的 RDD。
  JavaPairRDD	zipWithIndex() 使用其元素索引压缩此 RDD。
  JavaPairRDD	zipWithUniqueId() 使用生成的唯一长 ID 压缩此 RDD。

• 方法细节

  • 包裹RDD

    这个 wrapRDD( RDD < T >rdd)

  • 类标签

    scala.reflect.ClassTag< T > classTag()

  • 记录

    RDD < T >rdd()

  • 分裂

    java.util.List<分区> splits()

    此 RDD 中的一组分区。

  • 语境

    SparkContext 上下文 ()

    在SparkContext这RDD上创建。

  • ID

    内部标识（）

    此 RDD 的唯一 ID（在其 SparkContext 中）。

  • 获取存储级别

    StorageLevel  getStorageLevel()

    获取 RDD 的当前存储级别，如果没有设置，则获取 StorageLevel.NONE。

  • 迭代器

    java.util.Iterator< T > iterator( Partition  split,
                                  TaskContext  taskContext)

    此 RDD 的内部方法；如果适用，将从缓存中读取，或以其他方式计算它。这应该“不”由用户直接调用，但可用于 RDD 的自定义子类的实现者。

  • 地图

      JavaRDD  map( Function < T ,R> f)

    通过对这个 RDD 的所有元素应用一个函数来返回一个新的 RDD。

  • mapPartitionsWithIndex

      JavaRDD  mapPartitionsWithIndex( Function2 ,java.util.Iterator> f,
                                        布尔保留分区）

    通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD，同时跟踪原始分区的索引。

  • 映射到双

      JavaDoubleRDD  mapToDouble( DoubleFunction < T > f)

    通过对这个 RDD 的所有元素应用一个函数来返回一个新的 RDD。

  • 映射对

      JavaPairRDD  mapToPair( PairFunction < T ,K2,V2> f)

    通过对这个 RDD 的所有元素应用一个函数来返回一个新的 RDD。

  • 平面图

      JavaRDD  flatMap( FlatMapFunction < T ,U> f)

    通过首先将函数应用于此 RDD 的所有元素，然后展平结果，返回一个新的 RDD。

  • flatMapToDouble

    JavaDoubleRDD  flatMapToDouble( DoubleFlatMapFunction < T > f)

    通过首先将函数应用于此 RDD 的所有元素，然后展平结果，返回一个新的 RDD。

  • 平面映射对

      JavaPairRDD  flatMapToPair( PairFlatMapFunction < T ,K2,V2> f)

    通过首先将函数应用于此 RDD 的所有元素，然后展平结果，返回一个新的 RDD。

  • 地图分区

      JavaRDD  mapPartitions( FlatMapFunction ,U> f)

    通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。

  • 地图分区

      JavaRDD  mapPartitions( FlatMapFunction ,U> f,
                               布尔保留分区）

    通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。

  • mapPartitionsToDouble

    JavaDoubleRDD  mapPartitionsToDouble( DoubleFlatMapFunction > f)

    通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。

  • mapPartitionsToPair

      JavaPairRDD  mapPartitionsToPair( PairFlatMapFunction ,K2,V2> f)

    通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。

  • mapPartitionsToDouble

    JavaDoubleRDD  mapPartitionsToDouble( DoubleFlatMapFunction > f,
                                      布尔保留分区）

    通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。

  • mapPartitionsToPair

      JavaPairRDD  mapPartitionsToPair( PairFlatMapFunction ,K2,V2> f,
                                                 布尔保留分区）

    通过对这个 RDD 的每个分区应用一个函数来返回一个新的 RDD。

  • foreach分区

    void foreachPartition( VoidFunction > f)

    将函数 f 应用于此 RDD 的每个分区。

  • 格洛姆

    JavaRDD > glom()

    返回通过将每个分区中的所有元素合并到一个数组中创建的 RDD。

  • 笛卡尔

      JavaPairRDD < T ,U> 笛卡尔( JavaRDDLlike  other)

    返回这个 RDD 和另一个 RDD 的笛卡尔积，即所有元素对 (a, b) 的 RDD，其中 a is inthis和 b is in other。

  • 通过...分组

      JavaPairRDD > groupBy( Function < T ,K> f)

    返回分组元素的 RDD。每个组由一个键和一系列映射到该键的元素组成。

  • 通过...分组

      JavaPairRDD > groupBy( Function < T ,K> f,
                                         int numPartitions)

    返回分组元素的 RDD。每个组由一个键和一系列映射到该键的元素组成。

  • 管道

    JavaRDD  管道（字符串命令）

    将管道元素创建的 RDD 返回到分叉的外部进程。

  • 管道

    JavaRDD  管道（java.util.List 命令）

    将管道元素创建的 RDD 返回到分叉的外部进程。

  • 管道

    JavaRDD  管道（java.util.List 命令，
                       java.util.Map 环境）

    将管道元素创建的 RDD 返回到分叉的外部进程。

  • 压缩

      JavaPairRDD < T ,U> zip( JavaRDDLlike  other)

    用另一个 RDD 压缩这个 RDD，返回键值对，每个 RDD 中的第一个元素，每个 RDD 中的第二个元素，等等。假设两个 RDD 具有*相同数量的分区*和*相同数量的元素分区*（例如，一个是通过另一个上的地图制作的）。

  • zip分区

      JavaRDD  zipPartitions( JavaRDDLlike  other,
                                  FlatMapFunction2 ,java.util.Iterator,V> f)

    用一个（或多个）RDD 压缩这个 RDD 的分区，并通过对压缩的分区应用一个函数来返回一个新的 RDD。假设所有 RDD 具有*相同数量的分区*，但*不*要求它们在每个分区中具有相同数量的元素。

  • 带唯一标识的 zip

    JavaPairRDD < T ,Long> zipWithUniqueId()

    使用生成的唯一长 ID 压缩此 RDD。第 k 个分区中的项目将获得 ids k, n+k, 2*n+k, ...，其中 n 是分区数。所以可能存在差距，但这种方法不会触发火花作业，这与RDD.zipWithIndex().

  • 带索引的zip

    JavaPairRDD < T ,Long> zipWithIndex()

    使用其元素索引压缩此 RDD。排序首先基于分区索引，然后是每个分区内项目的排序。所以第一个分区中的第一项获得索引 0，最后一个分区中的最后一项获得最大索引。这类似于 Scala 的 zipWithIndex 但它使用 Long 而不是 Int 作为索引类型。当这个RDD包含多个分区时，该方法需要触发一个spark作业。

  • foreach

    void foreach( VoidFunction < T > f)

    将函数 f 应用于此 RDD 的所有元素。

  • 搜集

    java.util.List< T > collect()

    返回一个包含此 RDD 中所有元素的数组。

  • toLocalIterator

    java.util.Iterator< T > toLocalIterator()

    返回包含此 RDD 中所有元素的迭代器。

    迭代器将消耗与此 RDD 中最大分区一样多的内存。

  • 数组

    java.util.List< T > toArray()

    已弃用。 从 Spark 1.0.0 开始，不推荐使用 toArray()，collect()改为使用 返回一个包含此 RDD 中所有元素的数组。

  • 收集分区

    java.util.List< T >[] collectPartitions(int[] partitionIds)

    返回一个数组，该数组包含此 RDD 特定分区中的所有元素。

  • 降低

    T  reduce( Function2 < T , T , T > f)

    使用指定的可交换和结合二元运算符减少此 RDD 的元素。

  • 折叠

    T  fold( T  zeroValue,
          Function2 < T , T , T > f)

    使用给定的关联函数和中性的“零值”聚合每个分区的元素，然后聚合所有分区的结果。函数 op(t1, t2) 允许修改 t1 并将其作为结果值返回以避免对象分配；但是，它不应修改 t2。

  • 总计的

     U 聚合(U zeroValue,
                   Function2  seqOp,
                   Function2  combOp)

    使用给定的组合函数和中性的“零值”聚合每个分区的元素，然后聚合所有分区的结果。这个函数可以返回与这个 RDD 的类型 T 不同的结果类型 U。因此，我们需要一个将 T 合并到一个 U 的操作和一个合并两个 U 的操作，如 scala.TraversableOnce。这两个函数都允许修改并返回它们的第一个参数，而不是创建一个新的 U 以避免内存分配。

  • 数数

    长计数（）

    返回 RDD 中元素的数量。

  • 计数约

    PartialResult < BoundedDouble > countApprox(long timeout,
                                           双重信任）

    :: 实验 :: count() 的近似版本在超时内返回可能不完整的结果，即使并非所有任务都已完成。

  • 计数约

    PartialResult < BoundedDouble > countApprox(long timeout)

    :: 实验 :: count() 的近似版本在超时内返回可能不完整的结果，即使并非所有任务都已完成。

  • 按值计数

    java.util.Map< T ,Long> countByValue()

    返回此 RDD 中每个唯一值的计数作为 (value, count) 对的映射。最后的组合步骤在 master 本地发生，相当于运行单个 reduce 任务。

  • countByValueApprox

    PartialResult > countByValueApprox(long timeout,
                                                                   双重信任）

    （实验性）countByValue() 的近似版本。

  • countByValueApprox

    PartialResult > countByValueApprox(long timeout)

    （实验性）countByValue() 的近似版本。

  • 拿

    java.util.List< T >take(int num)

    取 RDD 的前 num 个元素。这当前会*一个*一个*地扫描分区，因此如果需要很多分区，它会很慢。在这种情况下，使用 collect() 来获取整个 RDD。

  • 取样

    java.util.List< T > takeSample(boolean withReplacement,
                               整数）

  • 取样

    java.util.List< T > takeSample(boolean withReplacement,
                               整数，
                               长种子）

  • 第一的

    Ť 第一（）

    返回此 RDD 中的第一个元素。

  • 另存为文本文件

    void saveAsTextFile（字符串路径）

    使用元素的字符串表示将此 RDD 保存为文本文件。

  • 另存为文本文件

    void saveAsTextFile(字符串路径，
                      类 编解码器）

    使用元素的字符串表示将此 RDD 保存为压缩文本文件。

  • 另存为对象文件

    void saveAsObjectFile(字符串路径)

    将此 RDD 保存为序列化对象的 SequenceFile。

  • 键按

      JavaPairRDD  keyBy( Function < T ,K> f)

    通过应用创建此 RDD 中元素的元组f。

  • 检查站

    无效检查点（）

    将此 RDD 标记为检查点。它将保存到使用 SparkContext.setCheckpointDir() 设置的检查点目录内的文件中，并且将删除对其父 RDD 的所有引用。必须在此 RDD 上执行任何作业之前调用此函数。强烈建议将此 RDD 持久化在内存中，否则将其保存在文件中将需要重新计算。

  • 是检查点

    布尔值 isCheckpointed()

    返回此 RDD 是否已被检查点

  • 获取检查点文件

    com.google.common.base.Optional getCheckpointFile()

    获取此 RDD 被检查点的文件的名称

  • 调试字符串

    字符串 toDebugString()

    此 RDD 的描述及其用于调试的递归依赖项。

  • 最佳

    java.util.List< T >top(int num,
                        java.util.Comparator< T > comp)

    返回此 RDD 中由指定的 Comparator[T] 定义的前 K 个元素。

    参数：

    num - 要返回的顶级元素的数量

    comp - 定义顺序的比较器

    返回：

    顶部元素的数组

  • 最佳

    java.util.List< T >top(int num)

    使用 T 的自然排序从这个 RDD 返回前 K 个元素。

    参数：

    num - 要返回的顶级元素的数量

    返回：

    顶部元素的数组

  • 下单

    java.util.List< T > takeOrdered(int num,
                                java.util.Comparator< T > comp)

    返回此 RDD 中由指定的 Comparator[T] 定义的前 K 个元素并保持顺序。

    参数：

    num - 要返回的顶级元素的数量

    comp - 定义顺序的比较器

    返回：

    顶部元素的数组

  • 最大限度

    T  max(java.util.Comparator< T > comp)

    返回此 RDD 中由指定的 Comparator[T] 定义的最大元素。

    参数：

    comp - 定义排序的比较器

    返回：

    RDD 的最大值

  • 分钟

    T  min(java.util.Comparator< T > comp)

    返回此 RDD 中由指定的 Comparator[T] 定义的最小元素。

    参数：

    comp - 定义排序的比较器

    返回：

    RDD 的最小值

  • 下单

    java.util.List< T > takeOrdered(int num)

    使用 T 的自然排序返回此 RDD 的前 K 个元素，同时保持顺序。

    参数：

    num - 要返回的顶级元素的数量

    返回：

    顶部元素的数组

  • countApproxDistinct

    long countApproxDistinct(double relativeSD)

    返回 RDD 中不同元素的近似数量。

    近似的精度可以通过相对标准偏差 (relativeSD) 参数来控制，该参数也控制使用的内存量。较低的值会导致更准确的计数，但会增加内存占用，反之亦然。relativeSD 的默认值为 0.05。

  • name

    字符串名称()