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

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

Scala Standard Library 2.13.10 - scala.collection.mutable.PriorityQueue



1. Alphabetic
2. By Inheritance

1. PriorityQueue
2. Serializable
3. Cloneable
4. Cloneable
5. Builder
6. Growable
7. Clearable
8. StrictOptimizedIterableOps
9. AbstractIterable
10. Iterable
11. AbstractIterable
12. Iterable
13. IterableFactoryDefaults
14. IterableOps
15. IterableOnceOps
16. IterableOnce
17. AnyRef
18. Any

1. by iterableOnceExtensionMethods
2. by any2stringadd
3. by StringFormat
4. by Ensuring
5. by ArrowAssoc

1. Public
2. Protected

1.  final def !=(arg0: Any): Boolean
2.  final def ##: Int
3.  def +(other: String): String
4.  def ++(xs: IterableOnce[A]): PriorityQueue[A]
5.  final def ++[B >: A](suffix: IterableOnce[B]): Iterable[B]
6.  final def ++=(xs: IterableOnce[A]): PriorityQueue.this.type
7.  final def +=(elem: A): PriorityQueue.this.type
8.  def ->[B](y: B): (PriorityQueue[A], B)
9.  final def ==(arg0: Any): Boolean
10.  def addAll(xs: IterableOnce[A]): PriorityQueue.this.type
11.  def addOne(elem: A): PriorityQueue.this.type
12.  final def addString(b: StringBuilder): b.type
13.  final def addString(b: StringBuilder, sep: String): b.type
14.  def addString(b: StringBuilder, start: String, sep: String, end: String): b.type
15.  final def asInstanceOf[T0]: T0
16.  def className: String
17.  def clear(): Unit
18.  def clone(): PriorityQueue[A]
19.  final def coll: PriorityQueue.this.type
20.  def collect[B](pf: PartialFunction[A, B]): Iterable[B]
21.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
22.  def concat[B >: A](suffix: IterableOnce[B]): Iterable[B]
23.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
24.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
25.  def copyToArray[B >: A](xs: Array[B]): Int
26.  def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean
27.  def count(p: (A) => Boolean): Int
28.  def dequeue(): A
29.  def dequeueAll[A1 >: A]: immutable.Seq[A1]
30.  def drop(n: Int): PriorityQueue[A]
31.  def dropRight(n: Int): PriorityQueue[A]
32.  def dropWhile(p: (A) => Boolean): PriorityQueue[A]
33.  def empty: PriorityQueue[A]
34.  def enqueue(elems: A*): Unit
35.  def ensuring(cond: (PriorityQueue[A]) => Boolean, msg: => Any): PriorityQueue[A]
36.  def ensuring(cond: (PriorityQueue[A]) => Boolean): PriorityQueue[A]
37.  def ensuring(cond: Boolean, msg: => Any): PriorityQueue[A]
38.  def ensuring(cond: Boolean): PriorityQueue[A]
39.  final def eq(arg0: AnyRef): Boolean
40.  def equals(arg0: AnyRef): Boolean
41.  def exists(p: (A) => Boolean): Boolean
42.  def filter(pred: (A) => Boolean): PriorityQueue[A]
43.  def filterImpl(pred: (A) => Boolean, isFlipped: Boolean): PriorityQueue[A]
44.  def filterNot(pred: (A) => Boolean): PriorityQueue[A]
45.  def finalize(): Unit
46.  def find(p: (A) => Boolean): Option[A]
47.  def fixDown(as: Array[AnyRef], m: Int, n: Int): Boolean
48.  def fixUp(as: Array[AnyRef], m: Int): Unit
49.  def flatMap[B](f: (A) => IterableOnce[B]): Iterable[B]
50.  def flatten[B](implicit toIterableOnce: (A) => IterableOnce[B]): Iterable[B]
51.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
52.  def foldLeft[B](z: B)(op: (B, A) => B): B
53.  def foldRight[B](z: B)(op: (A, B) => B): B
54.  def forall(p: (A) => Boolean): Boolean
55.  def foreach[U](f: (A) => U): Unit
56.  def fromSpecific(coll: IterableOnce[A]): PriorityQueue[A]
57.  final def getClass(): Class[_ <: AnyRef]
58.  def groupBy[K](f: (A) => K): immutable.Map[K, PriorityQueue[A]]
59.  def groupMap[K, B](key: (A) => K)(f: (A) => B): immutable.Map[K, Iterable[B]]
60.  def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(reduce: (B, B) => B): immutable.Map[K, B]
61.  def grouped(size: Int): Iterator[PriorityQueue[A]]
62.  def hashCode(): Int
63.  def head: A
64.  def headOption: Option[A]
65.  def init: PriorityQueue[A]
66.  def inits: Iterator[PriorityQueue[A]]
67.  def isEmpty: Boolean
68.  final def isInstanceOf[T0]: Boolean
69.  def isTraversableAgain: Boolean
70.  def iterableFactory: IterableFactory[Iterable]
71.  def iterator: Iterator[A]
72.  def knownSize: Int
73.  def last: A
74.  def lastOption: Option[A]
75.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[A, B, PriorityQueue.this.type]
76.  def length: Int
77.  def map[B](f: (A) => B): Iterable[B]
78.  def mapInPlace(f: (A) => A): PriorityQueue.this.type
79.  def mapResult[NewTo](f: (PriorityQueue[A]) => NewTo): Builder[A, NewTo]
80.  def max[B >: A](implicit ord: math.Ordering[B]): A
81.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
82.  def maxByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
83.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
84.  def min[B >: A](implicit ord: math.Ordering[B]): A
85.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
86.  def minByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
87.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
88.  final def mkString: String
89.  final def mkString(sep: String): String
90.  final def mkString(start: String, sep: String, end: String): String
91.  final def ne(arg0: AnyRef): Boolean
92.  def newSpecificBuilder: Builder[A, PriorityQueue[A]]
93.  def nonEmpty: Boolean
94.  final def notify(): Unit
95.  final def notifyAll(): Unit
96.  implicit val ord: math.Ordering[A]
97.  def partition(p: (A) => Boolean): (PriorityQueue[A], PriorityQueue[A])
98.  def partitionMap[A1, A2](f: (A) => Either[A1, A2]): (Iterable[A1], Iterable[A2])
99.  def product[B >: A](implicit num: math.Numeric[B]): B
100.  def reduce[B >: A](op: (B, B) => B): B
101.  def reduceLeft[B >: A](op: (B, A) => B): B
102.  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
103.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
104.  def reduceRight[B >: A](op: (A, B) => B): B
105.  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
106.  def result(): PriorityQueue[A]
107.  def reverse: PriorityQueue[A]
108.  def reverseIterator: Iterator[A]
109.  def reversed: collection.Iterable[A]
110.  def scan[B >: A](z: B)(op: (B, B) => B): Iterable[B]
111.  def scanLeft[B](z: B)(op: (B, A) => B): Iterable[B]
112.  def scanRight[B](z: B)(op: (A, B) => B): Iterable[B]
113.  def size: Int
114.  def sizeCompare(that: collection.Iterable[_]): Int
115.  def sizeCompare(otherSize: Int): Int
116.  final def sizeHint(coll: IterableOnce[_], delta: Int = 0): Unit
117.  def sizeHint(size: Int): Unit
118.  final def sizeHintBounded(size: Int, boundingColl: collection.Iterable[_]): Unit
119.  final def sizeIs: SizeCompareOps
120.  def slice(from: Int, until: Int): PriorityQueue[A]
121.  def sliding(size: Int, step: Int): Iterator[PriorityQueue[A]]
122.  def sliding(size: Int): Iterator[PriorityQueue[A]]
123.  def span(p: (A) => Boolean): (PriorityQueue[A], PriorityQueue[A])
124.  def splitAt(n: Int): (PriorityQueue[A], PriorityQueue[A])
125.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S
126.  final def strictOptimizedCollect[B, C2](b: Builder[B, C2], pf: PartialFunction[A, B]): C2
127.  final def strictOptimizedConcat[B >: A, C2](that: IterableOnce[B], b: Builder[B, C2]): C2
128.  final def strictOptimizedFlatMap[B, C2](b: Builder[B, C2], f: (A) => IterableOnce[B]): C2
129.  final def strictOptimizedFlatten[B, C2](b: Builder[B, C2])(implicit toIterableOnce: (A) => IterableOnce[B]): C2
130.  final def strictOptimizedMap[B, C2](b: Builder[B, C2], f: (A) => B): C2
131.  final def strictOptimizedZip[B, C2](that: IterableOnce[B], b: Builder[(A, B), C2]): C2
132.  def stringPrefix: String
133.  def sum[B >: A](implicit num: math.Numeric[B]): B
134.  final def synchronized[T0](arg0: => T0): T0
135.  def tail: PriorityQueue[A]
136.  def tails: Iterator[PriorityQueue[A]]
137.  def take(n: Int): PriorityQueue[A]
138.  def takeRight(n: Int): PriorityQueue[A]
139.  def takeWhile(p: (A) => Boolean): PriorityQueue[A]
140.  def tapEach[U](f: (A) => U): PriorityQueue[A]
141.  def to[C1](factory: Factory[A, C1]): C1
142.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
143.  final def toBuffer[B >: A]: Buffer[B]
144.  def toIndexedSeq: immutable.IndexedSeq[A]
145.  def toList: immutable.List[A]
146.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
147.  def toQueue: Queue[A]
148.  def toSeq: immutable.Seq[A]
149.  def toSet[B >: A]: immutable.Set[B]
150.  def toString(): String
151.  def toVector: immutable.Vector[A]
152.  def transpose[B](implicit asIterable: (A) => collection.Iterable[B]): Iterable[Iterable[B]]
153.  def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (Iterable[A1], Iterable[A2])
154.  def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
155.  def view: View[A]
156.  final def wait(): Unit
157.  final def wait(arg0: Long, arg1: Int): Unit
158.  final def wait(arg0: Long): Unit
159.  def withFilter(p: (A) => Boolean): WithFilter[A, [_]Iterable[_]]
160.  def writeReplace(): AnyRef
161.  def zip[B](that: IterableOnce[B]): Iterable[(A, B)]
162.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): Iterable[(A1, B)]
163.  def zipWithIndex: Iterable[(A, Int)]

1.  def ++:[B >: A](that: IterableOnce[B]): Iterable[B]
2.  final def +=(elem1: A, elem2: A, elems: A*): PriorityQueue.this.type
3.  def /:[B](z: B)(op: (B, A) => B): B
4.  final def /:[B](z: B)(op: (B, A) => B): B
5.  def :\[B](z: B)(op: (A, B) => B): B
6.  final def :\[B](z: B)(op: (A, B) => B): B
7.  def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
8.  def collectFirst[B](f: PartialFunction[A, B]): Option[B]
9.  def companion: IterableFactory[[_]Iterable[_]]
10.  def copyToBuffer(dest: Buffer[A]): Unit
11.  final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
12.  def count(f: (A) => Boolean): Int
13.  def exists(f: (A) => Boolean): Boolean
14.  def filter(f: (A) => Boolean): Iterator[A]
15.  def find(p: (A) => Boolean): Option[A]
16.  def flatMap[B](f: (A) => IterableOnce[B]): IterableOnce[B]
17.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
18.  def foldLeft[B](z: B)(op: (B, A) => B): B
19.  def foldRight[B](z: B)(op: (A, B) => B): B
20.  def forall(f: (A) => Boolean): Boolean
21.  def foreach[U](f: (A) => U): Unit
22.  def formatted(fmtstr: String): String
23.  def hasDefiniteSize: Boolean
24.  def isEmpty: Boolean
25.  def map[B](f: (A) => B): IterableOnce[B]
26.  def max(implicit ord: math.Ordering[A]): A
27.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
28.  def min(implicit ord: math.Ordering[A]): A
29.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
30.  def mkString: String
31.  def mkString(sep: String): String
32.  def mkString(start: String, sep: String, end: String): String
33.  def nonEmpty: Boolean
34.  def orderedCompanion: PriorityQueue.type
35.  def product(implicit num: math.Numeric[A]): A
36.  def reduce(f: (A, A) => A): A
37.  def reduceLeft(f: (A, A) => A): A
38.  def reduceLeftOption(f: (A, A) => A): Option[A]
39.  def reduceOption(f: (A, A) => A): Option[A]
40.  def reduceRight(f: (A, A) => A): A
41.  def reduceRightOption(f: (A, A) => A): Option[A]
42.  final def repr: PriorityQueue[A]
43.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
44.  def seq: PriorityQueue.this.type
45.  def size: Int
46.  def sum(implicit num: math.Numeric[A]): A
47.  def to[C1](factory: Factory[A, C1]): C1
48.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
49.  def toBuffer[B >: A]: Buffer[B]
50.  def toIndexedSeq: collection.IndexedSeq[A]
51.  final def toIterable: collection.Iterable[A]
52.  final def toIterable: PriorityQueue.this.type
53.  def toIterator: Iterator[A]
54.  final def toIterator: Iterator[A]
55.  def toList: immutable.List[A]
56.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
57.  def toSeq: immutable.Seq[A]
58.  def toSet[B >: A]: immutable.Set[B]
59.  def toStream: immutable.Stream[A]
60.  final def toStream: immutable.Stream[A]
61.  final def toTraversable: collection.Traversable[A]
62.  final def toTraversable: collection.Traversable[A]
63.  def toVector: immutable.Vector[A]
64.  def view(from: Int, until: Int): View[A]
65.  def withFilter(f: (A) => Boolean): Iterator[A]
66.  def →[B](y: B): (PriorityQueue[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