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

Showing content from https://www.scala-lang.org/api/2.13.4/scala/collection/ArrayOps.html below:

Scala Standard Library 2.13.4 - scala.collection.ArrayOps



1. Alphabetic
2. By Inheritance

1. ArrayOps
2. AnyVal
3. Any

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

1. Public
2. Protected

1.  new ArrayOps(xs: Array[A])

1.  final def !=(arg0: Any): Boolean
2.  final def ##: Int
3.  def +(other: String): String
4.  final def ++[B >: A](xs: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
5.  final def ++[B >: A](xs: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
6.  final def ++:[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
7.  final def ++:[B >: A](prefix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
8.  final def +:[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
9.  def ->[B](y: B): (ArrayOps[A], B)
10.  final def :+[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
11.  final def :++[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
12.  final def :++[B >: A](suffix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
13.  final def ==(arg0: Any): Boolean
14.  def appended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
15.  def appendedAll[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
16.  def appendedAll[B >: A](suffix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
17.  final def asInstanceOf[T0]: T0
18.  def collect[B](pf: PartialFunction[A, B])(implicit arg0: ClassTag[B]): Array[B]
19.  def collectFirst[B](f: PartialFunction[A, B]): Option[B]
20.  def combinations(n: Int): Iterator[Array[A]]
21.  final def concat[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
22.  final def concat[B >: A](suffix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
23.  def contains(elem: A): Boolean
24.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
25.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
26.  def copyToArray[B >: A](xs: Array[B]): Int
27.  def count(p: (A) => Boolean): Int
28.  def diff[B >: A](that: Seq[B]): Array[A]
29.  def distinct: Array[A]
30.  def distinctBy[B](f: (A) => B): Array[A]
31.  def drop(n: Int): Array[A]
32.  def dropRight(n: Int): Array[A]
33.  def dropWhile(p: (A) => Boolean): Array[A]
34.  def endsWith[B >: A](that: Iterable[B]): Boolean
35.  def endsWith[B >: A](that: Array[B]): Boolean
36.  def ensuring(cond: (ArrayOps[A]) => Boolean, msg: => Any): ArrayOps[A]
37.  def ensuring(cond: (ArrayOps[A]) => Boolean): ArrayOps[A]
38.  def ensuring(cond: Boolean, msg: => Any): ArrayOps[A]
39.  def ensuring(cond: Boolean): ArrayOps[A]
40.  def exists(p: (A) => Boolean): Boolean
41.  def filter(p: (A) => Boolean): Array[A]
42.  def filterNot(p: (A) => Boolean): Array[A]
43.  def find(p: (A) => Boolean): Option[A]
44.  def flatMap[BS, B](f: (A) => BS)(implicit asIterable: (BS) => Iterable[B], m: ClassTag[B]): Array[B]
45.  def flatMap[B](f: (A) => IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
46.  def flatten[B](implicit asIterable: (A) => IterableOnce[B], m: ClassTag[B]): Array[B]
47.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
48.  def foldLeft[B](z: B)(op: (B, A) => B): B
49.  def foldRight[B](z: B)(op: (A, B) => B): B
50.  def forall(p: (A) => Boolean): Boolean
51.  def foreach[U](f: (A) => U): Unit
52.  def formatted(fmtstr: String): String
53.  def getClass(): Class[_ <: AnyVal]
54.  def groupBy[K](f: (A) => K): immutable.Map[K, Array[A]]
55.  def groupMap[K, B](key: (A) => K)(f: (A) => B)(implicit arg0: ClassTag[B]): immutable.Map[K, Array[B]]
56.  def grouped(size: Int): Iterator[Array[A]]
57.  def head: A
58.  def headOption: Option[A]
59.  def indexOf(elem: A, from: Int = 0): Int
60.  def indexWhere(p: (A) => Boolean, from: Int = 0): Int
61.  def indices: immutable.Range
62.  def init: Array[A]
63.  def inits: Iterator[Array[A]]
64.  def intersect[B >: A](that: Seq[B]): Array[A]
65.  def isEmpty: Boolean
66.  final def isInstanceOf[T0]: Boolean
67.  def iterator: Iterator[A]
68.  def knownSize: Int
69.  def last: A
70.  def lastIndexOf(elem: A, end: Int = xs.length - 1): Int
71.  def lastIndexWhere(p: (A) => Boolean, end: Int = xs.length - 1): Int
72.  def lastOption: Option[A]
73.  def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Array[A]]
74.  def lengthCompare(len: Int): Int
75.  def lengthIs: Int
76.  def map[B](f: (A) => B)(implicit ct: ClassTag[B]): Array[B]
77.  def mapInPlace(f: (A) => A): Array[A]
78.  def nonEmpty: Boolean
79.  def padTo[B >: A](len: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
80.  def partition(p: (A) => Boolean): (Array[A], Array[A])
81.  def partitionMap[A1, A2](f: (A) => Either[A1, A2])(implicit arg0: ClassTag[A1], arg1: ClassTag[A2]): (Array[A1], Array[A2])
82.  def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int)(implicit arg0: ClassTag[B]): Array[B]
83.  def permutations: Iterator[Array[A]]
84.  def prepended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
85.  def prependedAll[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
86.  def prependedAll[B >: A](prefix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
87.  def reverse: Array[A]
88.  def reverseIterator: Iterator[A]
89.  def scan[B >: A](z: B)(op: (B, B) => B)(implicit arg0: ClassTag[B]): Array[B]
90.  def scanLeft[B](z: B)(op: (B, A) => B)(implicit arg0: ClassTag[B]): Array[B]
91.  def scanRight[B](z: B)(op: (A, B) => B)(implicit arg0: ClassTag[B]): Array[B]
92.  def size: Int
93.  def sizeCompare(otherSize: Int): Int
94.  def sizeIs: Int
95.  def slice(from: Int, until: Int): Array[A]
96.  def sliding(size: Int, step: Int = 1): Iterator[Array[A]]
97.  def sortBy[B](f: (A) => B)(implicit ord: math.Ordering[B]): Array[A]
98.  def sortWith(lt: (A, A) => Boolean): Array[A]
99.  def sorted[B >: A](implicit ord: math.Ordering[B]): Array[A]
100.  def span(p: (A) => Boolean): (Array[A], Array[A])
101.  def splitAt(n: Int): (Array[A], Array[A])
102.  def startsWith[B >: A](that: IterableOnce[B], offset: Int = 0): Boolean
103.  def startsWith[B >: A](that: Array[B], offset: Int): Boolean
104.  def startsWith[B >: A](that: Array[B]): Boolean
105.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S with EfficientSplit
106.  def tail: Array[A]
107.  def tails: Iterator[Array[A]]
108.  def take(n: Int): Array[A]
109.  def takeRight(n: Int): Array[A]
110.  def takeWhile(p: (A) => Boolean): Array[A]
111.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
112.  def toIndexedSeq: immutable.IndexedSeq[A]
113.  final def toSeq: immutable.Seq[A]
114.  def toString(): String
115.  def transpose[B](implicit asArray: (A) => Array[B]): Array[Array[B]]
116.  def unzip[A1, A2](implicit asPair: (A) => (A1, A2), ct1: ClassTag[A1], ct2: ClassTag[A2]): (Array[A1], Array[A2])
117.  def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3), ct1: ClassTag[A1], ct2: ClassTag[A2], ct3: ClassTag[A3]): (Array[A1], Array[A2], Array[A3])
118.  def updated[B >: A](index: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
119.  def view: IndexedSeqView[A]
120.  def withFilter(p: (A) => Boolean): ArrayOps.WithFilter[A]
121.  def zip[B](that: IterableOnce[B]): Array[(A, B)]
122.  def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Array[(A1, B)]
123.  def zipWithIndex: Array[(A, Int)]

1.  def →[B](y: B): (ArrayOps[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