A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://www.scala-lang.org/api/2.13.10/scala/collection/immutable/TreeSet.html below:

Scala Standard Library 2.13.10 - scala.collection.immutable.TreeSet

final class TreeSet[A] extends AbstractSet[A] with SortedSet[A] with SortedSetOps[A, TreeSet, TreeSet[A]] with StrictOptimizedSortedSetOps[A, TreeSet, TreeSet[A]] with SortedSetFactoryDefaults[A, TreeSet, Set] with DefaultSerializable



Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TreeSet
  2. DefaultSerializable
  3. Serializable
  4. StrictOptimizedSortedSetOps
  5. StrictOptimizedSetOps
  6. StrictOptimizedSortedSetOps
  7. StrictOptimizedSetOps
  8. StrictOptimizedIterableOps
  9. SortedSet
  10. SortedSetOps
  11. SortedSet
  12. SortedSetFactoryDefaults
  13. SortedSetOps
  14. SortedOps
  15. AbstractSet
  16. Set
  17. SetOps
  18. Iterable
  19. AbstractSet
  20. Set
  21. Equals
  22. SetOps
  23. Function1
  24. AbstractIterable
  25. Iterable
  26. IterableFactoryDefaults
  27. IterableOps
  28. IterableOnceOps
  29. IterableOnce
  30. AnyRef
  31. Any
Implicitly
  1. by iterableOnceExtensionMethods
  2. by any2stringadd
  3. by StringFormat
  4. by Ensuring
  5. by ArrowAssoc
Visibility
  1. Public
  2. Protected
Instance Constructors
  1.  new TreeSet()(implicit ordering: Ordering[A])
Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##: Int
  3.  final def &(that: collection.Set[A]): TreeSet[A]
  4.  final def &~(that: collection.Set[A]): TreeSet[A]
  5.  final def +(elem: A): TreeSet[A]
  6.  final def ++(that: IterableOnce[A]): TreeSet[A]
  7.  final def ++[B >: A](suffix: IterableOnce[B]): Set[B]
  8.  final def -(elem: A): TreeSet[A]
  9.  final def --(that: IterableOnce[A]): TreeSet[A]
  10.  def ->[B](y: B): (TreeSet[A], B)
  11.  final def ==(arg0: Any): Boolean
  12.  final def addString(b: mutable.StringBuilder): b.type
  13.  final def addString(b: mutable.StringBuilder, sep: String): b.type
  14.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): b.type
  15.  def andThen[A](g: (Boolean) => A): (A) => A
  16.  final def apply(elem: A): Boolean
  17.  final def asInstanceOf[T0]: T0
  18.  def canEqual(that: Any): Boolean
  19.  def className: String
  20.  def clone(): AnyRef
  21.  final def coll: TreeSet.this.type
  22.  def collect[B](pf: PartialFunction[A, B])(implicit ev: Ordering[B]): TreeSet[B]
  23.  def collect[B](pf: PartialFunction[A, B]): Set[B]
  24.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
  25.  def compose[A](g: (A) => A): (A) => Boolean
  26.  def concat(that: IterableOnce[A]): TreeSet[A]
  27.  def concat[B >: A](suffix: IterableOnce[B]): Set[B]
  28.  def contains(elem: A): Boolean
  29.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
  30.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
  31.  def copyToArray[B >: A](xs: Array[B]): Int
  32.  def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean
  33.  def count(p: (A) => Boolean): Int
  34.  def diff(that: collection.Set[A]): TreeSet[A]
  35.  def drop(n: Int): TreeSet[A]
  36.  def dropRight(n: Int): TreeSet[A]
  37.  def dropWhile(p: (A) => Boolean): TreeSet[A]
  38.  def empty: TreeSet[A]
  39.  def ensuring(cond: (TreeSet[A]) => Boolean, msg: => Any): TreeSet[A]
  40.  def ensuring(cond: (TreeSet[A]) => Boolean): TreeSet[A]
  41.  def ensuring(cond: Boolean, msg: => Any): TreeSet[A]
  42.  def ensuring(cond: Boolean): TreeSet[A]
  43.  final def eq(arg0: AnyRef): Boolean
  44.  def equals(obj: Any): Boolean
  45.  def excl(elem: A): TreeSet[A]
  46.  def exists(p: (A) => Boolean): Boolean
  47.  def filter(f: (A) => Boolean): TreeSet[A]
  48.  def filterImpl(pred: (A) => Boolean, isFlipped: Boolean): TreeSet[A]
  49.  def filterNot(pred: (A) => Boolean): TreeSet[A]
  50.  def finalize(): Unit
  51.  def find(p: (A) => Boolean): Option[A]
  52.  def firstKey: A
  53.  def flatMap[B](f: (A) => IterableOnce[B])(implicit ev: Ordering[B]): TreeSet[B]
  54.  def flatMap[B](f: (A) => IterableOnce[B]): Set[B]
  55.  def flatten[B](implicit toIterableOnce: (A) => IterableOnce[B]): Set[B]
  56.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  57.  def foldLeft[B](z: B)(op: (B, A) => B): B
  58.  def foldRight[B](z: B)(op: (A, B) => B): B
  59.  def forall(p: (A) => Boolean): Boolean
  60.  def foreach[U](f: (A) => U): Unit
  61.  def fromSpecific(coll: IterableOnce[A]): TreeSet[A]
  62.  final def getClass(): Class[_ <: AnyRef]
  63.  def groupBy[K](f: (A) => K): Map[K, TreeSet[A]]
  64.  def groupMap[K, B](key: (A) => K)(f: (A) => B): Map[K, Set[B]]
  65.  def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(reduce: (B, B) => B): Map[K, B]
  66.  def grouped(size: Int): Iterator[TreeSet[A]]
  67.  def hashCode(): Int
  68.  def head: A
  69.  def headOption: Option[A]
  70.  def incl(elem: A): TreeSet[A]
  71.  def init: TreeSet[A]
  72.  def inits: Iterator[TreeSet[A]]
  73.  def intersect(that: collection.Set[A]): TreeSet[A]
  74.  def isEmpty: Boolean
  75.  final def isInstanceOf[T0]: Boolean
  76.  def isTraversableAgain: Boolean
  77.  def iterableFactory: IterableFactory[Set]
  78.  def iterator: Iterator[A]
  79.  def iteratorFrom(start: A): Iterator[A]
  80.  def knownSize: Int
  81.  def last: A
  82.  def lastKey: A
  83.  def lastOption: Option[A]
  84.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[A, B, TreeSet.this.type]
  85.  def map[B](f: (A) => B)(implicit ev: Ordering[B]): TreeSet[B]
  86.  def map[B](f: (A) => B): Set[B]
  87.  def max[A1 >: A](implicit ord: Ordering[A1]): A
  88.  def maxBefore(key: A): Option[A]
  89.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
  90.  def maxByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
  91.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
  92.  def min[A1 >: A](implicit ord: Ordering[A1]): A
  93.  def minAfter(key: A): Option[A]
  94.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
  95.  def minByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
  96.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
  97.  final def mkString: String
  98.  final def mkString(sep: String): String
  99.  final def mkString(start: String, sep: String, end: String): String
  100.  final def ne(arg0: AnyRef): Boolean
  101.  def newSpecificBuilder: Builder[A, TreeSet[A]]
  102.  def nonEmpty: Boolean
  103.  final def notify(): Unit
  104.  final def notifyAll(): Unit
  105.  implicit val ordering: Ordering[A]
  106.  def partition(p: (A) => Boolean): (TreeSet[A], TreeSet[A])
  107.  def partitionMap[A1, A2](f: (A) => Either[A1, A2]): (Set[A1], Set[A2])
  108.  def product[B >: A](implicit num: math.Numeric[B]): B
  109.  def range(from: A, until: A): TreeSet[A]
  110.  def rangeFrom(from: A): TreeSet[A]
  111.  def rangeImpl(from: Option[A], until: Option[A]): TreeSet[A]
  112.  def rangeTo(to: A): TreeSet[A]
  113.  def rangeUntil(until: A): TreeSet[A]
  114.  def reduce[B >: A](op: (B, B) => B): B
  115.  def reduceLeft[B >: A](op: (B, A) => B): B
  116.  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
  117.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
  118.  def reduceRight[B >: A](op: (A, B) => B): B
  119.  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
  120.  def removedAll(that: IterableOnce[A]): TreeSet[A]
  121.  def reversed: collection.Iterable[A]
  122.  def scan[B >: A](z: B)(op: (B, B) => B): Set[B]
  123.  def scanLeft[B](z: B)(op: (B, A) => B): Set[B]
  124.  def scanRight[B](z: B)(op: (A, B) => B): Set[B]
  125.  def size: Int
  126.  def sizeCompare(that: collection.Iterable[_]): Int
  127.  def sizeCompare(otherSize: Int): Int
  128.  final def sizeIs: SizeCompareOps
  129.  def slice(from: Int, until: Int): TreeSet[A]
  130.  def sliding(size: Int, step: Int): Iterator[TreeSet[A]]
  131.  def sliding(size: Int): Iterator[TreeSet[A]]
  132.  def sortedIterableFactory: TreeSet
  133.  def span(p: (A) => Boolean): (TreeSet[A], TreeSet[A])
  134.  def splitAt(n: Int): (TreeSet[A], TreeSet[A])
  135.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S with EfficientSplit
  136.  final def strictOptimizedCollect[B, C2](b: Builder[B, C2], pf: PartialFunction[A, B]): C2
  137.  final def strictOptimizedConcat[B >: A, C2](that: IterableOnce[B], b: Builder[B, C2]): C2
  138.  final def strictOptimizedFlatMap[B, C2](b: Builder[B, C2], f: (A) => IterableOnce[B]): C2
  139.  final def strictOptimizedFlatten[B, C2](b: Builder[B, C2])(implicit toIterableOnce: (A) => IterableOnce[B]): C2
  140.  final def strictOptimizedMap[B, C2](b: Builder[B, C2], f: (A) => B): C2
  141.  final def strictOptimizedZip[B, C2](that: IterableOnce[B], b: Builder[(A, B), C2]): C2
  142.  def stringPrefix: String
  143.  def subsetOf(that: collection.Set[A]): Boolean
  144.  def subsets(): Iterator[TreeSet[A]]
  145.  def subsets(len: Int): Iterator[TreeSet[A]]
  146.  def sum[B >: A](implicit num: math.Numeric[B]): B
  147.  final def synchronized[T0](arg0: => T0): T0
  148.  def tail: TreeSet[A]
  149.  def tails: Iterator[TreeSet[A]]
  150.  def take(n: Int): TreeSet[A]
  151.  def takeRight(n: Int): TreeSet[A]
  152.  def takeWhile(p: (A) => Boolean): TreeSet[A]
  153.  def tapEach[U](f: (A) => U): TreeSet[A]
  154.  def to[C1](factory: Factory[A, C1]): C1
  155.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  156.  final def toBuffer[B >: A]: Buffer[B]
  157.  def toIndexedSeq: IndexedSeq[A]
  158.  def toList: List[A]
  159.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): Map[K, V]
  160.  def toSeq: Seq[A]
  161.  def toSet[B >: A]: Set[B]
  162.  def toString(): String
  163.  def toVector: Vector[A]
  164.  def transpose[B](implicit asIterable: (A) => collection.Iterable[B]): Set[Set[B]]
  165.  final def union(that: collection.Set[A]): TreeSet[A]
  166.  def unsorted: Set[A]
  167.  def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (Set[A1], Set[A2])
  168.  def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
  169.  def view: View[A]
  170.  final def wait(): Unit
  171.  final def wait(arg0: Long, arg1: Int): Unit
  172.  final def wait(arg0: Long): Unit
  173.  def withFilter(p: (A) => Boolean): SortedSetOps.WithFilter[A, [x]Set[x], [X]TreeSet[X]]
  174.  def writeReplace(): AnyRef
  175.  def zip[B](that: IterableOnce[B])(implicit ev: Ordering[(A, B)]): TreeSet[(A, B)]
  176.  def zip[B](that: IterableOnce[B]): Set[(A, B)]
  177.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): Set[(A1, B)]
  178.  def zipWithIndex: Set[(A, Int)]
  179.  final def |(that: collection.Set[A]): TreeSet[A]
Deprecated Value Members
  1.  def +(elem1: A, elem2: A, elems: A*): TreeSet[A]
  2.  def ++:[B >: A](that: IterableOnce[B]): Set[B]
  3.  def -(elem1: A, elem2: A, elems: A*): TreeSet[A]
  4.  def /:[B](z: B)(op: (B, A) => B): B
  5.  final def /:[B](z: B)(op: (B, A) => B): B
  6.  def :\[B](z: B)(op: (A, B) => B): B
  7.  final def :\[B](z: B)(op: (A, B) => B): B
  8.  def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
  9.  def collectFirst[B](f: PartialFunction[A, B]): Option[B]
  10.  def companion: IterableFactory[[_]Set[_]]
  11.  def compare(k0: A, k1: A): Int
  12.  def copyToBuffer(dest: Buffer[A]): Unit
  13.  final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
  14.  def count(f: (A) => Boolean): Int
  15.  def exists(f: (A) => Boolean): Boolean
  16.  def filter(f: (A) => Boolean): Iterator[A]
  17.  def find(p: (A) => Boolean): Option[A]
  18.  def flatMap[B](f: (A) => IterableOnce[B]): IterableOnce[B]
  19.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  20.  def foldLeft[B](z: B)(op: (B, A) => B): B
  21.  def foldRight[B](z: B)(op: (A, B) => B): B
  22.  def forall(f: (A) => Boolean): Boolean
  23.  def foreach[U](f: (A) => U): Unit
  24.  def formatted(fmtstr: String): String
  25.  final def from(from: A): TreeSet[A]
  26.  def hasDefiniteSize: Boolean
  27.  def isEmpty: Boolean
  28.  def keysIteratorFrom(start: A): Iterator[A]
  29.  def map[B](f: (A) => B): IterableOnce[B]
  30.  def max(implicit ord: math.Ordering[A]): A
  31.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
  32.  def min(implicit ord: math.Ordering[A]): A
  33.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
  34.  def mkString: String
  35.  def mkString(sep: String): String
  36.  def mkString(start: String, sep: String, end: String): String
  37.  def nonEmpty: Boolean
  38.  def product(implicit num: math.Numeric[A]): A
  39.  def reduce(f: (A, A) => A): A
  40.  def reduceLeft(f: (A, A) => A): A
  41.  def reduceLeftOption(f: (A, A) => A): Option[A]
  42.  def reduceOption(f: (A, A) => A): Option[A]
  43.  def reduceRight(f: (A, A) => A): A
  44.  def reduceRightOption(f: (A, A) => A): Option[A]
  45.  final def repr: TreeSet[A]
  46.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
  47.  def seq: TreeSet.this.type
  48.  def size: Int
  49.  def sum(implicit num: math.Numeric[A]): A
  50.  def to[C1](factory: Factory[A, C1]): C1
  51.  final def to(to: A): TreeSet[A]
  52.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  53.  def toBuffer[B >: A]: Buffer[B]
  54.  def toIndexedSeq: collection.IndexedSeq[A]
  55.  final def toIterable: collection.Iterable[A]
  56.  final def toIterable: TreeSet.this.type
  57.  def toIterator: Iterator[A]
  58.  final def toIterator: Iterator[A]
  59.  def toList: List[A]
  60.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): Map[K, V]
  61.  def toSeq: Seq[A]
  62.  def toSet[B >: A]: Set[B]
  63.  def toStream: Stream[A]
  64.  final def toStream: Stream[A]
  65.  final def toTraversable: collection.Traversable[A]
  66.  final def toTraversable: collection.Traversable[A]
  67.  def toVector: Vector[A]
  68.  final def until(until: A): TreeSet[A]
  69.  def view(from: Int, until: Int): View[A]
  70.  def withFilter(f: (A) => Boolean): Iterator[A]
  71.  def →[B](y: B): (TreeSet[A], B)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4