JavaTransformableRDD

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addColumnsFrom(other: JavaTransformableRDD): JavaTransformableRDD

Zips the other JavaTransformableRDD with this TransformableRDD and returns a new JavaTransformableRDD with current file format.

def aggregate[U](zeroValue: U)(seqOp: Function2[U, String, U], combOp: Function2[U, U, U]): U

final def asInstanceOf[T0]: T0

def cache(): JavaRDD[String]

def cartesian[U](other: JavaRDDLike[U, _]): JavaPairRDD[String, U]

def checkpoint(): Unit

implicit val classTag: ClassTag[String]

def clone(): AnyRef

def clusters(columnIndex: Int, clusteringAlgorithm: ClusteringAlgorithm): JavaClusters

Returns Clusters that has all cluster of text of @columnIndex according to @algorithm

def coalesce(numPartitions: Int, shuffle: Boolean): JavaRDD[String]

def coalesce(numPartitions: Int): JavaRDD[String]

def collect(): List[String]

def collectAsync(): JavaFutureAction[List[String]]

def collectPartitions(partitionIds: Array[Int]): Array[List[String]]

def context: SparkContext

def count(): Long

def countApprox(timeout: Long): PartialResult[BoundedDouble]

def countApprox(timeout: Long, confidence: Double): PartialResult[BoundedDouble]

def countApproxDistinct(relativeSD: Double): Long

def countAsync(): JavaFutureAction[Long]

def countByValue(): Map[String, Long]

def countByValueApprox(timeout: Long): PartialResult[Map[String, BoundedDouble]]

def countByValueApprox(timeout: Long, confidence: Double): PartialResult[Map[String, BoundedDouble]]

def deduplicate: JavaTransformableRDD

Returns a new JavaTransformableRDD containing unique duplicate records of this JavaTransformableRDD by considering all the columns as primary key.

def deduplicate(primaryKeyColumns: List[Integer]): JavaTransformableRDD

Returns a new JavaTransformableRDD containing unique duplicate records of this JavaTransformableRDD by considering the given columns as primary key.

def distinct(numPartitions: Int): JavaRDD[String]

def distinct(): JavaRDD[String]

def drop(columnIndex: Int): JavaTransformableRDD

Returns a new JavaTransformableRDD by dropping the @columnIndex

def duplicates: JavaTransformableRDD

Returns a new JavaTransformableRDD containing unique duplicate records of this JavaTransformableRDD by considering all the columns as primary key.

def duplicates(primaryKeyColumns: List[Integer]): JavaTransformableRDD

Returns a new JavaTransformableRDD containing unique duplicate records of this JavaTransformableRDD by considering the given columns as primary key.

def duplicatesAt(columnIndex: Int): JavaRDD[String]

Returns a new JavaRDD[String] containing the duplicate values at the specified column

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: Function[String, Boolean]): JavaRDD[String]

def finalize(): Unit

def first(): String

def flag(symbol: String, markerPredicate: MarkerPredicate): JavaTransformableRDD

Returns a new JavaTransformableRDD that contains records flagged by @symbol based on the evaluation of @markerPredicate

def flatMap[U](f: FlatMapFunction[String, U]): JavaRDD[U]

def flatMapToDouble(f: DoubleFlatMapFunction[String]): JavaDoubleRDD

def flatMapToPair[K2, V2](f: PairFlatMapFunction[String, K2, V2]): JavaPairRDD[K2, V2]

def fold(zeroValue: String)(f: Function2[String, String, String]): String

def foreach(f: VoidFunction[String]): Unit

def foreachAsync(f: VoidFunction[String]): JavaFutureAction[Void]

def foreachPartition(f: VoidFunction[Iterator[String]]): Unit

def foreachPartitionAsync(f: VoidFunction[Iterator[String]]): JavaFutureAction[Void]

def getCheckpointFile(): Optional[String]

final def getClass(): Class[_]

def getNumPartitions: Int

def getStorageLevel: StorageLevel

def glom(): JavaRDD[List[String]]

def groupBy[U](f: Function[String, U], numPartitions: Int): JavaPairRDD[U, Iterable[String]]

def groupBy[U](f: Function[String, U]): JavaPairRDD[U, Iterable[String]]

def hashCode(): Int

def id: Int

def impute(columnIndex: Int, strategy: ImputationStrategy): JavaTransformableRDD

Returns a new JavaTransformableRDD by imputing missing values of the @columnIndex using the @strategy

def impute(columnIndex: Int, strategy: ImputationStrategy, missingHints: List[String]): JavaTransformableRDD

Returns a new JavaTransformableRDD by imputing missing values and @missingHints of the @columnIndex using the @strategy

def intersection(other: JavaRDD[String]): JavaRDD[String]

def isCheckpointed: Boolean

def isEmpty(): Boolean

final def isInstanceOf[T0]: Boolean

def iterator(split: Partition, taskContext: TaskContext): Iterator[String]

def keyBy[U](f: Function[String, U]): JavaPairRDD[U, String]

def listFacets(columnIndexes: List[Integer]): TextFacets

Returns a new TextFacet containing the facets of @columnIndexes

def listFacets(columnIndex: Int): TextFacets

Returns a new TextFacet containing the cardinal values of @columnIndex

def map[R](f: Function[String, R]): JavaRDD[R]

def mapByFlag(symbol: String, symbolColumnIndex: Int, function: Function[String, String]): JavaTransformableRDD

Returns a new JavaTransformableRDD by applying the function on all rows marked as @flag

def mapPartitions[U](f: FlatMapFunction[Iterator[String], U], preservesPartitioning: Boolean): JavaRDD[U]

def mapPartitions[U](f: FlatMapFunction[Iterator[String], U]): JavaRDD[U]

def mapPartitionsToDouble(f: DoubleFlatMapFunction[Iterator[String]], preservesPartitioning: Boolean): JavaDoubleRDD

def mapPartitionsToDouble(f: DoubleFlatMapFunction[Iterator[String]]): JavaDoubleRDD

def mapPartitionsToPair[K2, V2](f: PairFlatMapFunction[Iterator[String], K2, V2], preservesPartitioning: Boolean): JavaPairRDD[K2, V2]

def mapPartitionsToPair[K2, V2](f: PairFlatMapFunction[Iterator[String], K2, V2]): JavaPairRDD[K2, V2]

def mapPartitionsWithIndex[R](f: Function2[Integer, Iterator[String], Iterator[R]], preservesPartitioning: Boolean): JavaRDD[R]

def mapToDouble[R](f: DoubleFunction[String]): JavaDoubleRDD

def mapToPair[K2, V2](f: PairFunction[String, K2, V2]): JavaPairRDD[K2, V2]

def max(comp: Comparator[String]): String

def mergeColumns(columnIndexes: List[Integer], separator: String = " ", retainColumns: Boolean = false): JavaTransformableRDD

Returns a new JavaTransformableRDD by merging @columnIndexes

def mergeColumns(columnIndexes: List[Integer]): JavaTransformableRDD

Returns a new JavaTransformableRDD by merging @columnIndexes with default separator

def min(comp: Comparator[String]): String

def multiplyColumns(firstColumn: Int, secondColumn: Int): JavaDoubleRDD

Returns a JavaDoubleRDD which is a product of the values in @firstColumn and @secondColumn

def name(): String

final def ne(arg0: AnyRef): Boolean

def normalize(columnIndex: Int, normalizer: NormalizationStrategy): JavaTransformableRDD

Returns a new JavaTransformableRDD by normalizing values of the given column using different Normalizers

final def notify(): Unit

final def notifyAll(): Unit

def numberOfColumns: Int

Returns number of column in this rdd

def partitioner: Optional[Partitioner]

def partitions: List[Partition]

def persist(newLevel: StorageLevel): JavaRDD[String]

def pipe(command: List[String], env: Map[String, String]): JavaRDD[String]

def pipe(command: List[String]): JavaRDD[String]

def pipe(command: String): JavaRDD[String]

def pivotByCount(pivotalColumn: Int, independentColumnIndexes: List[Integer]): PivotTable[Integer]

Generates a PivotTable by pivoting data in the pivotalColumn

def randomSplit(weights: Array[Double], seed: Long): Array[JavaRDD[String]]

def randomSplit(weights: Array[Double]): Array[JavaRDD[String]]

def reduce(f: Function2[String, String, String]): String

def removeRows(rowPurger: RowPurger): JavaTransformableRDD

Returns a new JavaTransformableRDD containing only the elements that satisfy the matchInDictionary.

def repartition(numPartitions: Int): JavaRDD[String]

def replaceValues(cluster: JavaCluster, newValue: String, columnIndex: Int): JavaTransformableRDD

Returns a new JavaTransformableRDD by replacing the @cluster's text with specified @newValue

def sample(withReplacement: Boolean, fraction: Double, seed: Long): JavaRDD[String]

def sample(withReplacement: Boolean, fraction: Double): JavaRDD[String]

def saveAsObjectFile(path: String): Unit

def saveAsTextFile(path: String, codec: Class[_ <: CompressionCodec]): Unit

def saveAsTextFile(path: String): Unit

def select(columnIndex: Int): JavaRDD[String]

Returns a JavaRDD of given column

def select(columnIndexes: List[Integer]): JavaTransformableRDD

Returns a new JavaTransformableRDD containing values of @columnIndexes

def setName(name: String): JavaRDD[String]

def smooth(columnIndex: Int, smoothingMethod: SmoothingMethod): JavaDoubleRDD

Returns a new JavaDoubleRDD containing smoothed values of @columnIndex using @smoothingMethod

def sortBy[S](f: Function[String, S], ascending: Boolean, numPartitions: Int): JavaRDD[String]

def splitByDelimiter(columnIndex: Int, delimiter: String, retainColumn: Boolean, maxSplit: Int): JavaTransformableRDD

Returns a new JavaTransformableRDD by splitting the @column by the delimiter provided

def splitByDelimiter(columnIndex: Int, delimiter: String, retainColumn: Boolean): JavaTransformableRDD

Returns a new JavaTransformableRDD by splitting the @column by the delimiter provided

def splitByFieldLength(columnIndex: Int, fieldLengths: List[Integer], retainColumn: Boolean): JavaTransformableRDD

Returns a JavaTransformableRDD by splitting the @column according to the specified lengths

def subtract(other: JavaRDD[String], p: Partitioner): JavaRDD[String]

def subtract(other: JavaRDD[String], numPartitions: Int): JavaRDD[String]

def subtract(other: JavaRDD[String]): JavaRDD[String]

final def synchronized[T0](arg0: ⇒ T0): T0

def take(num: Int): List[String]

def takeAsync(num: Int): JavaFutureAction[List[String]]

def takeOrdered(num: Int): List[String]

def takeOrdered(num: Int, comp: Comparator[String]): List[String]

def takeSample(withReplacement: Boolean, num: Int, seed: Long): List[String]

def takeSample(withReplacement: Boolean, num: Int): List[String]

def toDebugString(): String

def toDoubleRDD(columnIndex: Int): JavaDoubleRDD

Returns a JavaDoubleRdd of given column index

def toLocalIterator(): Iterator[String]

def toString(): String

def top(num: Int): List[String]

def top(num: Int, comp: Comparator[String]): List[String]

def treeAggregate[U](zeroValue: U, seqOp: Function2[U, String, U], combOp: Function2[U, U, U]): U

def treeAggregate[U](zeroValue: U, seqOp: Function2[U, String, U], combOp: Function2[U, U, U], depth: Int): U

def treeReduce(f: Function2[String, String, String]): String

def treeReduce(f: Function2[String, String, String], depth: Int): String

def union(other: JavaRDD[String]): JavaRDD[String]

def unique(columnIndex: Int): JavaRDD[String]

Returns a new JavaRDD containing the unique elements in the specified column

def unpersist(blocking: Boolean): JavaRDD[String]

def unpersist(): JavaRDD[String]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wrapRDD(rdd: RDD[String]): JavaRDD[String]

def zip[U](other: JavaRDDLike[U, _]): JavaPairRDD[String, U]

def zipPartitions[U, V](other: JavaRDDLike[U, _], f: FlatMapFunction2[Iterator[String], Iterator[U], V]): JavaRDD[V]

def zipWithIndex(): JavaPairRDD[String, Long]

def zipWithUniqueId(): JavaPairRDD[String, Long]

def splits: List[Partition]

def toArray(): List[String]