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

Showing content from http://www.scala-lang.org/api/2.12.15/scala/collection/mutable/ArrayOps.html below:

Scala Standard Library 2.12.15 - scala.collection.mutable.ArrayOps

 

1. Alphabetic
2. By Inheritance

1. ArrayOps
2. CustomParallelizable
3. ArrayLike
4. IndexedSeqOptimized
5. IndexedSeqOptimized
6. IndexedSeqLike
7. IndexedSeqLike
8. SeqLike
9. GenSeqLike
10. IterableLike
11. GenIterableLike
12. TraversableLike
13. GenTraversableLike
14. Parallelizable
15. TraversableOnce
16. GenTraversableOnce
17. FilterMonadic
18. HasNewBuilder
19. Equals
20. Any

1. by CollectionsHaveToParArray
2. by MonadOps
3. by any2stringadd
4. by StringFormat
5. by Ensuring
6. by ArrowAssoc
7. by alternateImplicit

1.  abstract def apply(idx: Int): T
2.  abstract def getClass(): Class[_]
3.  abstract def length: Int
4.  abstract def newBuilder: Builder[T, Array[T]]
5.  abstract def update(idx: Int, elem: T): Unit

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  def ++[B >: T, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
5.  def ++:[B >: T, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
6.  def ++:[B](that: TraversableOnce[B]): Array[B]
7.  def +:[B >: T](elem: B)(implicit arg0: ClassTag[B]): Array[B]
8.  def +:(elem: A): Array[A]
9.  def ->[B](y: B): (ArrayOps[T], B)
10.  def :+[B >: T](elem: B)(implicit arg0: ClassTag[B]): Array[B]
11.  def :+(elem: A): Array[A]
12.  final def ==(arg0: Any): Boolean
13.  def addString(b: scala.StringBuilder): scala.StringBuilder
14.  def addString(b: scala.StringBuilder, sep: String): scala.StringBuilder
15.  def addString(b: scala.StringBuilder, start: String, sep: String, end: String): scala.StringBuilder
16.  def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
17.  final def asInstanceOf[T0]: T0
18.  def canEqual(that: Any): Boolean
19.  def collect[B](pf: PartialFunction[A, B]): Array[B]
20.  def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
21.  def combinations(n: Int): Iterator[Array[T]]
22.  def contains[A1 >: T](elem: A1): Boolean
23.  def containsSlice[B](that: GenSeq[B]): Boolean
24.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
25.  def copyToArray(xs: Array[A]): Unit
26.  def copyToArray(xs: Array[A], start: Int): Unit
27.  def copyToBuffer[B >: T](dest: Buffer[B]): Unit
28.  def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
29.  def count(p: (T) ⇒ Boolean): Int
30.  def deep: collection.IndexedSeq[Any]
31.  def diff(that: collection.Seq[T]): Array[T]
32.  def distinct: Array[T]
33.  def drop(n: Int): Array[T]
34.  def dropRight(n: Int): Array[T]
35.  def dropWhile(p: (T) ⇒ Boolean): Array[T]
36.  def endsWith[B](that: GenSeq[B]): Boolean
37.  def ensuring(cond: (ArrayOps[T]) ⇒ Boolean, msg: ⇒ Any): ArrayOps[T]
38.  def ensuring(cond: (ArrayOps[T]) ⇒ Boolean): ArrayOps[T]
39.  def ensuring(cond: Boolean, msg: ⇒ Any): ArrayOps[T]
40.  def ensuring(cond: Boolean): ArrayOps[T]
41.  def equals(that: Any): Boolean
42.  def exists(p: (T) ⇒ Boolean): Boolean
43.  def filter(p: (T) ⇒ Boolean): Array[T]
44.  def filterNot(p: (T) ⇒ Boolean): Array[T]
45.  def find(p: (T) ⇒ Boolean): Option[T]
46.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
47.  def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
48.  def fold[A1 >: T](z: A1)(op: (A1, A1) ⇒ A1): A1
49.  def foldLeft[B](z: B)(op: (B, T) ⇒ B): B
50.  def foldRight[B](z: B)(op: (T, B) ⇒ B): B
51.  def forall(p: (T) ⇒ Boolean): Boolean
52.  def foreach(f: (A) ⇒ Unit): Unit
53.  def formatted(fmtstr: String): String
54.  def groupBy[K](f: (T) ⇒ K): immutable.Map[K, Array[T]]
55.  def grouped(size: Int): Iterator[Array[T]]
56.  def hasDefiniteSize: Boolean
57.  def hashCode(): Int
58.  def head: T
59.  def headOption: Option[T]
60.  def indexOf(elem: T, from: Int): Int
61.  def indexOf(elem: T): Int
62.  def indexOfSlice[B >: T](that: GenSeq[B], from: Int): Int
63.  def indexOfSlice[B >: T](that: GenSeq[B]): Int
64.  def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
65.  def indexWhere(p: (T) ⇒ Boolean): Int
66.  def indices: immutable.Range
67.  def init: Array[T]
68.  def inits: Iterator[Array[T]]
69.  def intersect(that: collection.Seq[T]): Array[T]
70.  def isDefinedAt(idx: Int): Boolean
71.  def isEmpty: Boolean
72.  final def isInstanceOf[T0]: Boolean
73.  final def isTraversableAgain: Boolean
74.  def iterator: Iterator[T]
75.  def last: T
76.  def lastIndexOf(elem: T, end: Int): Int
77.  def lastIndexOf(elem: T): Int
78.  def lastIndexOfSlice[B >: T](that: GenSeq[B], end: Int): Int
79.  def lastIndexOfSlice[B >: T](that: GenSeq[B]): Int
80.  def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
81.  def lastIndexWhere(p: (T) ⇒ Boolean): Int
82.  def lastOption: Option[T]
83.  def lengthCompare(len: Int): Int
84.  def map[B](f: (A) ⇒ B): Array[B]
85.  def max: A
86.  def maxBy[B](f: (A) ⇒ B): A
87.  def min: A
88.  def minBy[B](f: (A) ⇒ B): A
89.  def mkString: String
90.  def mkString(sep: String): String
91.  def mkString(start: String, sep: String, end: String): String
92.  def nonEmpty: Boolean
93.  def padTo(len: Int, elem: A): Array[A]
94.  def par: ParArray[T]
95.  def parCombiner: Combiner[T, ParArray[T]]
96.  def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
97.  def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
98.  def permutations: Iterator[Array[T]]
99.  def prefixLength(p: (T) ⇒ Boolean): Int
100.  def product: A
101.  def reduce[A1 >: T](op: (A1, A1) ⇒ A1): A1
102.  def reduceLeft[B >: T](op: (B, T) ⇒ B): B
103.  def reduceLeftOption[B >: T](op: (B, T) ⇒ B): Option[B]
104.  def reduceOption[A1 >: T](op: (A1, A1) ⇒ A1): Option[A1]
105.  def reduceRight[B >: T](op: (T, B) ⇒ B): B
106.  def reduceRightOption[B >: T](op: (T, B) ⇒ B): Option[B]
107.  def repr: Array[T]
108.  def reverse: Array[T]
109.  def reverseIterator: Iterator[T]
110.  def reverseMap[B](f: (A) ⇒ B): Array[B]
111.  def reversed: List[T]
112.  def sameElements(that: GenIterable[A]): Boolean
113.  def scan[B >: T, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
114.  def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
115.  def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
116.  def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
117.  def seq: IndexedSeq[T]
118.  def size: Int
119.  def sizeHintIfCheap: Int
120.  def slice(from: Int, until: Int): Array[T]
121.  def sliding(size: Int, step: Int): Iterator[Array[T]]
122.  def sliding(size: Int): Iterator[Array[T]]
123.  def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
124.  def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
125.  def sorted[B >: T](implicit ord: math.Ordering[B]): Array[T]
126.  def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
127.  def splitAt(n: Int): (Array[T], Array[T])
128.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
129.  def startsWith[B](that: GenSeq[B]): Boolean
130.  def stringPrefix: String
131.  def sum: A
132.  def tail: Array[T]
133.  def tails: Iterator[Array[T]]
134.  def take(n: Int): Array[T]
135.  def takeRight(n: Int): Array[T]
136.  def takeWhile(p: (T) ⇒ Boolean): Array[T]
137.  def thisCollection: IndexedSeq[T]
138.  def to[Col[_]]: Col[A]
139.  def toArray: Array[A]
140.  def toBuffer[A1 >: T]: Buffer[A1]
141.  def toCollection(repr: Array[T]): IndexedSeq[T]
142.  def toIndexedSeq: immutable.IndexedSeq[T]
143.  def toIterable: collection.Iterable[T]
144.  def toIterator: Iterator[T]
145.  def toList: List[T]
146.  def toMap[T, U]: collection.Map[T, U]
147.  def toParArray: ParArray[T]
148.  def toSeq: collection.Seq[T]
149.  def toSet[B >: T]: immutable.Set[B]
150.  def toStream: immutable.Stream[T]
151.  def toString(): String
152.  def toTraversable: collection.Traversable[T]
153.  def toVector: Vector[T]
154.  def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
155.  def union(that: collection.Seq[T]): Array[T]
156.  def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
157.  def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
158.  def updated(index: Int, elem: A): Array[A]
159.  def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
160.  def view: IndexedSeqView[T, Array[T]]
161.  def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
162.  def zip[B](that: GenIterable[B]): Array[(A, B)]
163.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
164.  def zipWithIndex: Array[(A, Int)]
165.  def →[B](y: B): (ArrayOps[T], B)

1.  def /:[B](z: B)(op: (B, T) ⇒ B): B
2.  def :\[B](z: B)(op: (T, B) ⇒ B): 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