spark框架 jar开发java程序 spark java api

转载

clghxq 2024-05-07 12:14:43

文章标签 spark框架 jar开发java程序 spark java List 数组 文章分类 Spark 大数据

org.apache.spark.api.java

接口 JavaRDDLike<T,This 扩展 JavaRDDLike<T,This>>

所有超级接口：
java.io.Serializable
所有已知的实现类：
JavaDoubleRDD、JavaPairRDD、JavaRDD、JavaSchemaRDD

公共接口JavaRDDLike<T,This extends JavaRDDLike<T,This>> 
extends scala.Serializable

方法总结

方法

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

地图

<R>  JavaRDD <R> map( Function < T ,R> f)

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

mapPartitionsWithIndex

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

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

映射到双

<R>  JavaDoubleRDD  mapToDouble( DoubleFunction < T > f)

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

映射对

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

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

平面图

<U>  JavaRDD <U> flatMap( FlatMapFunction < T ,U> f)

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

flatMapToDouble

JavaDoubleRDD  flatMapToDouble( DoubleFlatMapFunction < T > f)

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

平面映射对

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

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

地图分区

<U>  JavaRDD <U> mapPartitions( FlatMapFunction <java.util.Iterator< T >,U> f)