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

Showing content from http://www.scala-lang.org/api/2.12.19/scala/Array.html below:

Scala Standard Library 2.12.19 - scala.Array

 

1. Alphabetic
2. By Inheritance

1. Array
2. Cloneable
3. Serializable
4. AnyRef
5. Any

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

1.  new Array(_length: Int)

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

1.  def /:[B](z: B)(op: (B, T) ⇒ B): B
2.  def :\[B](z: B)(op: (T, B) ⇒ B): B
3.  def formatted(fmtstr: String): String

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