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/StringBuilder.html below:

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

 

1. Alphabetic
2. By Inheritance

1. StringBuilder
2. Serializable
3. Serializable
4. ReusableBuilder
5. Builder
6. Growable
7. Clearable
8. StringLike
9. Ordered
10. Comparable
11. IndexedSeqOptimized
12. IndexedSeq
13. IndexedSeqLike
14. IndexedSeq
15. IndexedSeqLike
16. CharSequence
17. AbstractSeq
18. Seq
19. SeqLike
20. Cloneable
21. Cloneable
22. Cloneable
23. Iterable
24. Traversable
25. Mutable
26. AbstractSeq
27. Seq
28. SeqLike
29. GenSeq
30. GenSeqLike
31. PartialFunction
32. Function1
33. AbstractIterable
34. Iterable
35. IterableLike
36. Equals
37. GenIterable
38. GenIterableLike
39. AbstractTraversable
40. Traversable
41. GenTraversable
42. GenericTraversableTemplate
43. TraversableLike
44. GenTraversableLike
45. Parallelizable
46. TraversableOnce
47. GenTraversableOnce
48. FilterMonadic
49. HasNewBuilder
50. AnyRef
51. Any

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

1.  new StringBuilder(str: String)
2.  new StringBuilder(capacity: Int)
3.  new StringBuilder()
4.  new StringBuilder(initCapacity: Int, initValue: String)
5.  new StringBuilder(underlying: java.lang.StringBuilder)

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def *(n: Int): String
4.  def +(x: Char): StringBuilder.this.type
5.  def ++[B >: Char, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[StringBuilder, B, That]): That
6.  def ++:[B >: Char, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[StringBuilder, B, That]): That
7.  def ++:[B](that: TraversableOnce[B]): IndexedSeq[B]
8.  def ++=(s: String): StringBuilder.this.type
9.  def ++=(xs: TraversableOnce[Char]): StringBuilder.this.type
10.  def +:(elem: A): IndexedSeq[A]
11.  def +=(x: Char): StringBuilder.this.type
12.  def +=(elem1: Char, elem2: Char, elems: Char*): StringBuilder.this.type
13.  def ->[B](y: B): (StringBuilder, B)
14.  def :+(elem: A): IndexedSeq[A]
15.  def <(that: String): Boolean
16.  def <=(that: String): Boolean
17.  final def ==(arg0: Any): Boolean
18.  def >(that: String): Boolean
19.  def >=(that: String): Boolean
20.  def addString(b: scala.StringBuilder): scala.StringBuilder
21.  def addString(b: scala.StringBuilder, sep: String): scala.StringBuilder
22.  def addString(b: scala.StringBuilder, start: String, sep: String, end: String): scala.StringBuilder
23.  def aggregate[B](z: ⇒ B)(seqop: (B, Char) ⇒ B, combop: (B, B) ⇒ B): B
24.  def andThen[C](k: (Char) ⇒ C): PartialFunction[Int, C]
25.  def append(x: Char): StringBuilder
26.  def append(x: Double): StringBuilder
27.  def append(x: Float): StringBuilder
28.  def append(x: Long): StringBuilder
29.  def append(x: Int): StringBuilder
30.  def append(x: Short): StringBuilder
31.  def append(x: Byte): StringBuilder
32.  def append(x: Boolean): StringBuilder
33.  def append(sb: StringBuilder): StringBuilder
34.  def append(s: String): StringBuilder
35.  def append(x: Any): StringBuilder
36.  def appendAll(xs: Array[Char], offset: Int, len: Int): StringBuilder
37.  def appendAll(xs: Array[Char]): StringBuilder
38.  def appendAll(xs: TraversableOnce[Char]): StringBuilder
39.  def appendAll(xs: String): StringBuilder
40.  def apply(index: Int): Char
41.  def applyOrElse[A1 <: Int, B1 >: Char](x: A1, default: (A1) ⇒ B1): B1
42.  final def asInstanceOf[T0]: T0
43.  def canEqual(that: Any): Boolean
44.  def capacity: Int
45.  def capitalize: String
46.  def charAt(index: Int): Char
47.  def chars(): IntStream
48.  def clear(): Unit
49.  def clone(): StringBuilder
50.  def codePoints(): IntStream
51.  def collect[B](pf: PartialFunction[A, B]): IndexedSeq[B]
52.  def collectFirst[B](pf: PartialFunction[Char, B]): Option[B]
53.  def combinations(n: Int): Iterator[StringBuilder]
54.  def companion: GenericCompanion[IndexedSeq]
55.  def compare(other: String): Int
56.  def compareTo(that: String): Int
57.  def compose[A](g: (A) ⇒ Int): (A) ⇒ Char
58.  def contains[A1 >: Char](elem: A1): Boolean
59.  def containsSlice[B](that: GenSeq[B]): Boolean
60.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
61.  def copyToArray(xs: Array[A]): Unit
62.  def copyToArray(xs: Array[A], start: Int): Unit
63.  def copyToBuffer[B >: Char](dest: Buffer[B]): Unit
64.  def corresponds[B](that: GenSeq[B])(p: (Char, B) ⇒ Boolean): Boolean
65.  def count(p: (Char) ⇒ Boolean): Int
66.  def delete(start: Int, end: Int): StringBuilder
67.  def deleteCharAt(index: Int): StringBuilder
68.  def diff(that: collection.Seq[Char]): IndexedSeq[Char]
69.  def distinct: StringBuilder
70.  def drop(n: Int): StringBuilder
71.  def dropRight(n: Int): StringBuilder
72.  def dropWhile(p: (Char) ⇒ Boolean): StringBuilder
73.  def endsWith[B](that: GenSeq[B]): Boolean
74.  def ensureCapacity(newCapacity: Int): Unit
75.  def ensuring(cond: (StringBuilder) ⇒ Boolean, msg: ⇒ Any): StringBuilder
76.  def ensuring(cond: (StringBuilder) ⇒ Boolean): StringBuilder
77.  def ensuring(cond: Boolean, msg: ⇒ Any): StringBuilder
78.  def ensuring(cond: Boolean): StringBuilder
79.  final def eq(arg0: AnyRef): Boolean
80.  def equals(that: Any): Boolean
81.  def exists(p: (Char) ⇒ Boolean): Boolean
82.  def filter(p: (Char) ⇒ Boolean): StringBuilder
83.  def filterNot(p: (Char) ⇒ Boolean): StringBuilder
84.  def finalize(): Unit
85.  def find(p: (Char) ⇒ Boolean): Option[Char]
86.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): IndexedSeq[B]
87.  def flatten[B]: IndexedSeq[B]
88.  def fold[A1 >: Char](z: A1)(op: (A1, A1) ⇒ A1): A1
89.  def foldLeft[B](z: B)(op: (B, Char) ⇒ B): B
90.  def foldRight[B](z: B)(op: (Char, B) ⇒ B): B
91.  def forall(p: (Char) ⇒ Boolean): Boolean
92.  def foreach(f: (A) ⇒ Unit): Unit
93.  def format(args: Any*): String
94.  def formatLocal(l: Locale, args: Any*): String
95.  def formatted(fmtstr: String): String
96.  def genericBuilder[B]: Builder[B, IndexedSeq[B]]
97.  final def getClass(): Class[_]
98.  def groupBy[K](f: (Char) ⇒ K): immutable.Map[K, StringBuilder]
99.  def grouped(size: Int): Iterator[StringBuilder]
100.  def hasDefiniteSize: Boolean
101.  def hashCode(): Int
102.  def head: Char
103.  def headOption: Option[Char]
104.  def indexOf(str: String, fromIndex: Int): Int
105.  def indexOf(str: String): Int
106.  def indexOf(elem: Char, from: Int): Int
107.  def indexOf(elem: Char): Int
108.  def indexOfSlice[B >: Char](that: GenSeq[B], from: Int): Int
109.  def indexOfSlice[B >: Char](that: GenSeq[B]): Int
110.  def indexWhere(p: (Char) ⇒ Boolean, from: Int): Int
111.  def indexWhere(p: (Char) ⇒ Boolean): Int
112.  def indices: immutable.Range
113.  def init: StringBuilder
114.  def inits: Iterator[StringBuilder]
115.  def insert(index: Int, x: Char): StringBuilder
116.  def insert(index: Int, x: Double): StringBuilder
117.  def insert(index: Int, x: Float): StringBuilder
118.  def insert(index: Int, x: Long): StringBuilder
119.  def insert(index: Int, x: Int): StringBuilder
120.  def insert(index: Int, x: Short): StringBuilder
121.  def insert(index: Int, x: Byte): StringBuilder
122.  def insert(index: Int, x: Boolean): StringBuilder
123.  def insert(index: Int, x: String): StringBuilder
124.  def insert(index: Int, x: Any): StringBuilder
125.  def insertAll(index: Int, xs: Array[Char]): StringBuilder
126.  def insertAll(index: Int, xs: TraversableOnce[Char]): StringBuilder
127.  def insertAll(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder
128.  def intersect(that: collection.Seq[Char]): IndexedSeq[Char]
129.  def isDefinedAt(idx: Int): Boolean
130.  def isEmpty: Boolean
131.  final def isInstanceOf[T0]: Boolean
132.  final def isTraversableAgain: Boolean
133.  def iterator: Iterator[Char]
134.  def last: Char
135.  def lastIndexOf(str: String, fromIndex: Int): Int
136.  def lastIndexOf(str: String): Int
137.  def lastIndexOf(elem: Char, end: Int): Int
138.  def lastIndexOf(elem: Char): Int
139.  def lastIndexOfSlice[B >: Char](that: GenSeq[B], end: Int): Int
140.  def lastIndexOfSlice[B >: Char](that: GenSeq[B]): Int
141.  def lastIndexWhere(p: (Char) ⇒ Boolean, end: Int): Int
142.  def lastIndexWhere(p: (Char) ⇒ Boolean): Int
143.  def lastOption: Option[Char]
144.  def length: Int
145.  def lengthCompare(len: Int): Int
146.  def length_=(n: Int): Unit
147.  def lift: (Int) ⇒ Option[Char]
148.  def lines: Iterator[String]
149.  def linesIterator: Iterator[String]
150.  def linesWithSeparators: Iterator[String]
151.  def map[B](f: (A) ⇒ B): IndexedSeq[B]
152.  def mapResult[NewTo](f: (String) ⇒ NewTo): Builder[Char, NewTo]
153.  def max: A
154.  def maxBy[B](f: (A) ⇒ B): A
155.  def min: A
156.  def minBy[B](f: (A) ⇒ B): A
157.  def mkString: String
158.  def mkString(sep: String): String
159.  def mkString(start: String, sep: String, end: String): String
160.  final def ne(arg0: AnyRef): Boolean
161.  def newBuilder: GrowingBuilder[Char, StringBuilder]
162.  def nonEmpty: Boolean
163.  final def notify(): Unit
164.  final def notifyAll(): Unit
165.  def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
166.  def padTo(len: Int, elem: A): IndexedSeq[A]
167.  def par: ParSeq[Char]
168.  def parCombiner: Combiner[Char, ParSeq[Char]]
169.  def partition(p: (Char) ⇒ Boolean): (StringBuilder, StringBuilder)
170.  def patch(from: Int, that: GenSeq[A], replaced: Int): IndexedSeq[A]
171.  def permutations: Iterator[StringBuilder]
172.  def prefixLength(p: (Char) ⇒ Boolean): Int
173.  def product: A
174.  def r(groupNames: String*): Regex
175.  def r: Regex
176.  def reduce[A1 >: Char](op: (A1, A1) ⇒ A1): A1
177.  def reduceLeft[B >: Char](op: (B, Char) ⇒ B): B
178.  def reduceLeftOption[B >: Char](op: (B, Char) ⇒ B): Option[B]
179.  def reduceOption[A1 >: Char](op: (A1, A1) ⇒ A1): Option[A1]
180.  def reduceRight[B >: Char](op: (Char, B) ⇒ B): B
181.  def reduceRightOption[B >: Char](op: (Char, B) ⇒ B): Option[B]
182.  def replace(start: Int, end: Int, str: String): StringBuilder
183.  def replaceAllLiterally(literal: String, replacement: String): String
184.  def repr: StringBuilder
185.  def result(): String
186.  def reverse: StringBuilder
187.  def reverseContents(): StringBuilder
188.  def reverseIterator: Iterator[Char]
189.  def reverseMap[B](f: (A) ⇒ B): IndexedSeq[B]
190.  def reversed: List[Char]
191.  def runWith[U](action: (Char) ⇒ U): (Int) ⇒ Boolean
192.  def sameElements(that: GenIterable[A]): Boolean
193.  def scan[B >: Char, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[StringBuilder, B, That]): That
194.  def scanLeft[B, That](z: B)(op: (B, Char) ⇒ B)(implicit bf: CanBuildFrom[StringBuilder, B, That]): That
195.  def scanRight[B, That](z: B)(op: (Char, B) ⇒ B)(implicit bf: CanBuildFrom[StringBuilder, B, That]): That
196.  def segmentLength(p: (Char) ⇒ Boolean, from: Int): Int
197.  def seq: IndexedSeq[Char]
198.  def setCharAt(index: Int, ch: Char): Unit
199.  def setLength(len: Int): Unit
200.  def size: Int
201.  def sizeHint(coll: TraversableLike[_, _], delta: Int): Unit
202.  def sizeHint(coll: TraversableLike[_, _]): Unit
203.  def sizeHint(size: Int): Unit
204.  def sizeHintBounded(size: Int, boundingColl: TraversableLike[_, _]): Unit
205.  def sizeHintIfCheap: Int
206.  def slice(from: Int, until: Int): StringBuilder
207.  def sliding(size: Int, step: Int): Iterator[StringBuilder]
208.  def sliding(size: Int): Iterator[StringBuilder]
209.  def sortBy[B](f: (Char) ⇒ B)(implicit ord: math.Ordering[B]): StringBuilder
210.  def sortWith(lt: (Char, Char) ⇒ Boolean): StringBuilder
211.  def sorted[B >: Char](implicit ord: math.Ordering[B]): StringBuilder
212.  def span(p: (Char) ⇒ Boolean): (StringBuilder, StringBuilder)
213.  def split(separators: Array[Char]): Array[String]
214.  def split(separator: Char): Array[String]
215.  def splitAt(n: Int): (StringBuilder, StringBuilder)
216.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
217.  def startsWith[B](that: GenSeq[B]): Boolean
218.  def stringPrefix: String
219.  def stripLineEnd: String
220.  def stripMargin: String
221.  def stripMargin(marginChar: Char): String
222.  def stripPrefix(prefix: String): String
223.  def stripSuffix(suffix: String): String
224.  def subSequence(start: Int, end: Int): CharSequence
225.  def substring(start: Int, end: Int): String
226.  def substring(start: Int): String
227.  def sum: A
228.  final def synchronized[T0](arg0: ⇒ T0): T0
229.  def tail: StringBuilder
230.  def tails: Iterator[StringBuilder]
231.  def take(n: Int): StringBuilder
232.  def takeRight(n: Int): StringBuilder
233.  def takeWhile(p: (Char) ⇒ Boolean): StringBuilder
234.  def thisCollection: StringBuilder
235.  def to[Col[_]]: Col[A]
236.  def toArray: Array[Char]
237.  def toArray: Array[A]
238.  def toBoolean: Boolean
239.  def toBuffer[A1 >: Char]: Buffer[A1]
240.  def toByte: Byte
241.  def toCollection(repr: StringBuilder): StringBuilder
242.  def toCollection(repr: IndexedSeq[Char]): IndexedSeq[Char]
243.  def toDouble: Double
244.  def toFloat: Float
245.  def toIndexedSeq: immutable.IndexedSeq[Char]
246.  def toInt: Int
247.  def toIterable: collection.Iterable[Char]
248.  def toIterator: Iterator[Char]
249.  def toList: List[Char]
250.  def toLong: Long
251.  def toMap[T, U]: collection.Map[T, U]
252.  def toParArray: ParArray[T]
253.  def toSeq: collection.Seq[Char]
254.  def toSet[B >: Char]: immutable.Set[B]
255.  def toShort: Short
256.  def toStream: immutable.Stream[Char]
257.  def toString(): String
258.  def toTraversable: collection.Traversable[Char]
259.  def toVector: Vector[Char]
260.  def transform(f: (Char) ⇒ Char): StringBuilder.this.type
261.  def transpose[B](implicit asTraversable: (Char) ⇒ GenTraversableOnce[B]): IndexedSeq[IndexedSeq[B]]
262.  def union(that: collection.Seq[Char]): IndexedSeq[Char]
263.  def unzip[A1, A2](implicit asPair: (Char) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
264.  def unzip3[A1, A2, A3](implicit asTriple: (Char) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
265.  def update(i: Int, c: Char): Unit
266.  def updated(index: Int, elem: A): IndexedSeq[A]
267.  def view(from: Int, until: Int): IndexedSeqView[Char, IndexedSeq[Char]]
268.  def view: IndexedSeqView[Char, IndexedSeq[Char]]
269.  final def wait(): Unit
270.  final def wait(arg0: Long, arg1: Int): Unit
271.  final def wait(arg0: Long): Unit
272.  def withFilter(p: (Char) ⇒ Boolean): FilterMonadic[Char, StringBuilder]
273.  def zip[B](that: GenIterable[B]): IndexedSeq[(A, B)]
274.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): IndexedSeq[(A, B)]
275.  def zipWithIndex: IndexedSeq[(A, Int)]
276.  def →[B](y: B): (StringBuilder, B)

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