RDDAPIScalaParallelImpl

Instance Constructors

new RDDAPIScalaParallelImpl(data: ParSeq[T])(implicit arg0: ClassTag[T])

Type Members

type InternalCollection = ParSeq[T]

Definition Classes
RDDAPIScalaParallelImpl → RDDAPIScalaBase

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(other: RDDAPI[T]): RDDAPI[T]

Definition Classes
RDDAPI
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def aggregate[U](zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

Definition Classes
RDDAPIScalaBase → RDDAPI
final def asInstanceOf[T0]: T0

Definition Classes
Any
def cache(): RDDAPI[T]

Definition Classes
RDDAPIScalaParallelImpl → RDDAPI
def cartesian[U](other: RDDAPI[U])(implicit arg0: ClassTag[U]): RDDAPI[(T, U)]

Definition Classes
RDDAPIScalaBase → RDDAPI
def checkpoint(): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def coalesce(numPartitions: Int, shuffle: Boolean, partitionCoalescer: Option[PartitionCoalescer])(implicit ord: Ordering[T]): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def collect(): Array[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def count(): Long

Definition Classes
RDDAPIScalaBase → RDDAPI
def countByValue()(implicit kct: ClassTag[T], vct: ClassTag[Int], ord: Ordering[T] = null): GenMap[T, Long]

Definition Classes
RDDAPI
def create[U](data: ParSeq[U])(implicit arg0: ClassTag[U]): RDDAPIScalaBase[U]

Attributes
protected
def diff(data: InternalCollection, rddScala: RDDAPIScalaBase[T]): RDDAPI[T]

Attributes
protected
Definition Classes
RDDAPIScalaParallelImpl → RDDAPIScalaBase
def distinct(): RDDAPI[T]

Definition Classes
RDDAPIScalaParallelImpl → RDDAPI
def distinct(numPartitions: Int)(implicit ord: Ordering[T]): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(obj: Any): Boolean

Definition Classes
RDDAPI → AnyRef → Any
def filter(p: (T) ⇒ Boolean): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def first(): T

Definition Classes
RDDAPI
def flatMap[U](func: (T) ⇒ TraversableOnce[U])(implicit arg0: ClassTag[U]): RDDAPI[U]

Definition Classes
RDDAPIScalaBase → RDDAPI
def fold(zeroValue: T)(op: (T, T) ⇒ T): T

Definition Classes
RDDAPIScalaBase → RDDAPI
def foreach(f: (T) ⇒ Unit): Unit

Definition Classes
RDDAPIScalaBase → RDDAPI
def foreachPartition(f: (Iterator[T]) ⇒ Unit): Unit

Definition Classes
RDDAPIScalaBase → RDDAPI
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K](f: (T) ⇒ K, p: Partitioner)(implicit kt: ClassTag[K], ord: Ordering[K]): RDDAPI[(K, GenIterable[T])]

Definition Classes
RDDAPIScalaBase → RDDAPI
def groupBy[K](f: (T) ⇒ K, numPartitions: Int)(implicit kt: ClassTag[K]): RDDAPI[(K, GenIterable[T])]

Definition Classes
RDDAPIScalaBase → RDDAPI
def groupBy[K](f: (T) ⇒ K)(implicit kt: ClassTag[K]): RDDAPI[(K, GenIterable[T])]

Definition Classes
RDDAPIScalaBase → RDDAPI
def hashCode(): Int

Definition Classes
AnyRef → Any
def head(n: Int): Array[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def head(): T

Definition Classes
RDDAPIScalaBase → RDDAPI
def intersect(data: InternalCollection, rddScala: RDDAPIScalaBase[T]): RDDAPI[T]

Attributes
protected
Definition Classes
RDDAPIScalaParallelImpl → RDDAPIScalaBase
def intersection(other: RDDAPI[T], partitioner: Partitioner)(implicit ord: Ordering[T]): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def intersection(other: RDDAPI[T], numPartitions: Int): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def intersection(other: RDDAPI[T]): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def isEmpty: Boolean

Definition Classes
RDDAPIScalaBase → RDDAPI
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def keyBy[K](f: (T) ⇒ K)(implicit ct: ClassTag[K], kvct: ClassTag[(K, T)]): RDDAPI[(K, T)]

Definition Classes
RDDAPI
def map[That](map: (T) ⇒ That)(implicit arg0: ClassTag[That]): RDDAPI[That]

Definition Classes
RDDAPIScalaBase → RDDAPI
def max()(implicit ord: Ordering[T]): T

Definition Classes
RDDAPIScalaBase → RDDAPI
def min()(implicit ord: Ordering[T]): T

Definition Classes
RDDAPIScalaBase → RDDAPI
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def parallelize[That](d: GenIterable[That])(implicit arg0: ClassTag[That]): RDD[That]

Attributes
protected
Definition Classes
RDDAPI
def parallelize[That](d: Seq[That])(implicit arg0: ClassTag[That]): RDD[That]

Attributes
protected
Definition Classes
RDDAPI
def partitions: Array[Partition]

Definition Classes
RDDAPIScalaBase → RDDAPI
def persist(): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def persist(newLevel: StorageLevel): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def randomSplit(weights: Array[Double], seed: Long): Array[RDDAPI[T]]

Definition Classes
RDDAPIScalaBase → RDDAPI
def reduce(func: (T, T) ⇒ T): T

Definition Classes
RDDAPIScalaBase → RDDAPI
def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def sortBy[K](f: (T) ⇒ K, ascending: Boolean, numPartitions: Int)(implicit ord: Ordering[K], ctag: ClassTag[K]): RDDAPI[T]

Definition Classes
RDDAPIScalaParallelImpl → RDDAPI
lazy val spark: SparkSession

Attributes
protected
Definition Classes
RDDAPI
def subtract(other: RDDAPI[T], partitioner: Partitioner)(implicit ord: Ordering[T]): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def subtract(other: RDDAPI[T], numPartitions: Int): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def subtract(other: RDDAPI[T]): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(n: Int): Array[T]

Definition Classes
RDDAPI
def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]

Definition Classes
RDDAPIScalaParallelImpl → RDDAPI
def takeSample(withReplacement: Boolean, num: Int, seed: Long): Array[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def toDataSet(implicit enc: Encoder[T]): DataSetAPI[T]

Definition Classes
RDDAPIScalaParallelImpl → RDDAPIScalaBase → RDDAPI
def toString(): String

Definition Classes
RDDAPI → AnyRef → Any
def top(num: Int)(implicit ord: Ordering[T]): Array[T]

Definition Classes
RDDAPIScalaParallelImpl → RDDAPI
def union(data: InternalCollection, rddScala: RDDAPIScalaBase[T]): RDDAPI[T]

Attributes
protected
Definition Classes
RDDAPIScalaParallelImpl → RDDAPIScalaBase
def union(other: RDDAPI[T]): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
def unpersist(blocking: Boolean): RDDAPI[T]

Definition Classes
RDDAPIScalaBase → RDDAPI
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def zip[U](other: RDDAPI[U])(implicit arg0: ClassTag[U]): RDDAPI[(T, U)]

Definition Classes
RDDAPIScalaBase → RDDAPI
def zipWithIndex(): RDDAPI[(T, Long)]

Definition Classes
RDDAPIScalaBase → RDDAPI

Related Doc: package rdd

class RDDAPIScalaParallelImpl[T] extends RDDAPIScalaBase[T]

Instance Constructors

new RDDAPIScalaParallelImpl(data: ParSeq[T])(implicit arg0: ClassTag[T])

Type Members

type InternalCollection = ParSeq[T]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: RDDAPI[T]): RDDAPI[T]

final def ==(arg0: Any): Boolean

def aggregate[U](zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

final def asInstanceOf[T0]: T0

def cache(): RDDAPI[T]

def cartesian[U](other: RDDAPI[U])(implicit arg0: ClassTag[U]): RDDAPI[(T, U)]

def checkpoint(): RDDAPI[T]

def clone(): AnyRef

def coalesce(numPartitions: Int, shuffle: Boolean, partitionCoalescer: Option[PartitionCoalescer])(implicit ord: Ordering[T]): RDDAPI[T]

def collect(): Array[T]

def count(): Long

def countByValue()(implicit kct: ClassTag[T], vct: ClassTag[Int], ord: Ordering[T] = null): GenMap[T, Long]

def create[U](data: ParSeq[U])(implicit arg0: ClassTag[U]): RDDAPIScalaBase[U]

def diff(data: InternalCollection, rddScala: RDDAPIScalaBase[T]): RDDAPI[T]

def distinct(): RDDAPI[T]

def distinct(numPartitions: Int)(implicit ord: Ordering[T]): RDDAPI[T]

final def eq(arg0: AnyRef): Boolean

def equals(obj: Any): Boolean

def filter(p: (T) ⇒ Boolean): RDDAPI[T]

def finalize(): Unit

def first(): T

def flatMap[U](func: (T) ⇒ TraversableOnce[U])(implicit arg0: ClassTag[U]): RDDAPI[U]

def fold(zeroValue: T)(op: (T, T) ⇒ T): T

def foreach(f: (T) ⇒ Unit): Unit

def foreachPartition(f: (Iterator[T]) ⇒ Unit): Unit

final def getClass(): Class[_]

def groupBy[K](f: (T) ⇒ K, p: Partitioner)(implicit kt: ClassTag[K], ord: Ordering[K]): RDDAPI[(K, GenIterable[T])]

def groupBy[K](f: (T) ⇒ K, numPartitions: Int)(implicit kt: ClassTag[K]): RDDAPI[(K, GenIterable[T])]

def groupBy[K](f: (T) ⇒ K)(implicit kt: ClassTag[K]): RDDAPI[(K, GenIterable[T])]

def hashCode(): Int

def head(n: Int): Array[T]

def head(): T

def intersect(data: InternalCollection, rddScala: RDDAPIScalaBase[T]): RDDAPI[T]

def intersection(other: RDDAPI[T], partitioner: Partitioner)(implicit ord: Ordering[T]): RDDAPI[T]

def intersection(other: RDDAPI[T], numPartitions: Int): RDDAPI[T]

def intersection(other: RDDAPI[T]): RDDAPI[T]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def keyBy[K](f: (T) ⇒ K)(implicit ct: ClassTag[K], kvct: ClassTag[(K, T)]): RDDAPI[(K, T)]

def map[That](map: (T) ⇒ That)(implicit arg0: ClassTag[That]): RDDAPI[That]

def max()(implicit ord: Ordering[T]): T

def min()(implicit ord: Ordering[T]): T

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parallelize[That](d: GenIterable[That])(implicit arg0: ClassTag[That]): RDD[That]

def parallelize[That](d: Seq[That])(implicit arg0: ClassTag[That]): RDD[That]

def partitions: Array[Partition]

def persist(): RDDAPI[T]

def persist(newLevel: StorageLevel): RDDAPI[T]

def randomSplit(weights: Array[Double], seed: Long): Array[RDDAPI[T]]

def reduce(func: (T, T) ⇒ T): T

def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDDAPI[T]

def sortBy[K](f: (T) ⇒ K, ascending: Boolean, numPartitions: Int)(implicit ord: Ordering[K], ctag: ClassTag[K]): RDDAPI[T]

lazy val spark: SparkSession

def subtract(other: RDDAPI[T], partitioner: Partitioner)(implicit ord: Ordering[T]): RDDAPI[T]

def subtract(other: RDDAPI[T], numPartitions: Int): RDDAPI[T]

def subtract(other: RDDAPI[T]): RDDAPI[T]

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

def take(n: Int): Array[T]

def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]

def takeSample(withReplacement: Boolean, num: Int, seed: Long): Array[T]

def toDataSet(implicit enc: Encoder[T]): DataSetAPI[T]

def toString(): String

def top(num: Int)(implicit ord: Ordering[T]): Array[T]

def union(data: InternalCollection, rddScala: RDDAPIScalaBase[T]): RDDAPI[T]

def union(other: RDDAPI[T]): RDDAPI[T]

def unpersist(blocking: Boolean): RDDAPI[T]

final def wait(): Unit

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