Scala Standard Library 2.13.15 - scala.collection.StringOps (original) (raw)

final class StringOps extends AnyVal

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. StringOps
2. AnyVal
3. Any

Implicitly

1. by any2stringadd

2. by StringFormat

3. by Ensuring

4. by ArrowAssoc

5. Hide All

6. Show All

Visibility

1. Public
2. Protected

Instance Constructors

1.  new StringOps(s: String)

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##: Int
3.  def *(n: Int): String
4.  def +(other: String): String
5.  def ++(xs: String): String
6.  def ++(suffix: IterableOnce[Char]): String
7.  def ++[B >: Char](suffix: Iterable[B]): immutable.IndexedSeq[B]
8.  def ++:(prefix: String): String
9.  def ++:[B >: Char](prefix: IterableOnce[B]): immutable.IndexedSeq[B]
10.  def +:(c: Char): String
11.  def +:[B >: Char](elem: B): immutable.IndexedSeq[B]
12.  def ->[B](y: B): (StringOps, B)
13.  def :+(c: Char): String
14.  def :+[B >: Char](elem: B): immutable.IndexedSeq[B]
15.  def :++(suffix: String): String
16.  def :++[B >: Char](suffix: IterableOnce[B]): immutable.IndexedSeq[B]
17.  def <(that: String): Boolean
18.  def <=(that: String): Boolean
19.  final def ==(arg0: Any): Boolean
20.  def >(that: String): Boolean
21.  def >=(that: String): Boolean
22.  final def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): b.type
23.  final def addString(b: mutable.StringBuilder, sep: String): b.type
24.  final def addString(b: mutable.StringBuilder): b.type
25.  def appended(c: Char): String
26.  def appended[B >: Char](elem: B): immutable.IndexedSeq[B]
27.  def appendedAll(suffix: String): String
28.  def appendedAll[B >: Char](suffix: IterableOnce[B]): immutable.IndexedSeq[B]
29.  def apply(i: Int): Char
30.  final def asInstanceOf[T0]: T0
31.  def capitalize: String
32.  def charStepper: IntStepper with EfficientSplit
33.  def codePointStepper: IntStepper with EfficientSplit
34.  def collect[B](pf: PartialFunction[Char, B]): immutable.IndexedSeq[B]
35.  def collect(pf: PartialFunction[Char, Char]): String
36.  def combinations(n: Int): Iterator[String]
37.  def compare(that: String): Int
38.  def concat(suffix: String): String
39.  def concat(suffix: IterableOnce[Char]): String
40.  def concat[B >: Char](suffix: IterableOnce[B]): immutable.IndexedSeq[B]
41.  def contains(elem: Char): Boolean
42.  def copyToArray(xs: Array[Char], start: Int, len: Int): Int
43.  def copyToArray(xs: Array[Char], start: Int): Int
44.  def copyToArray(xs: Array[Char]): Int
45.  def count(p: (Char) => Boolean): Int
46.  def diff[B >: Char](that: Seq[B]): String
47.  def distinct: String
48.  def distinctBy[B](f: (Char) => B): String
49.  def drop(n: Int): String
50.  def dropRight(n: Int): String
51.  def dropWhile(p: (Char) => Boolean): String
52.  def ensuring(cond: (StringOps) => Boolean, msg: => Any): StringOps
53.  def ensuring(cond: (StringOps) => Boolean): StringOps
54.  def ensuring(cond: Boolean, msg: => Any): StringOps
55.  def ensuring(cond: Boolean): StringOps
56.  def exists(p: (Char) => Boolean): Boolean
57.  def filter(pred: (Char) => Boolean): String
58.  def filterNot(pred: (Char) => Boolean): String
59.  def find(p: (Char) => Boolean): Option[Char]
60.  def flatMap(f: (Char) => String): String
61.  def flatMap[B](f: (Char) => IterableOnce[B]): immutable.IndexedSeq[B]
62.  def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1
63.  def foldLeft[B](z: B)(op: (B, Char) => B): B
64.  def foldRight[B](z: B)(op: (Char, B) => B): B
65.  def forall(p: (Char) => Boolean): Boolean
66.  def foreach[U](f: (Char) => U): Unit
67.  def format(args: Any*): String
68.  def formatLocal(l: Locale, args: Any*): String
69.  def getClass(): Class[_ <: AnyVal]
70.  def groupBy[K](f: (Char) => K): immutable.Map[K, String]
71.  def grouped(size: Int): Iterator[String]
72.  def head: Char
73.  def headOption: Option[Char]
74.  def indexWhere(p: (Char) => Boolean, from: Int = 0): Int
75.  def indices: Range
76.  def init: String
77.  def inits: Iterator[String]
78.  def intersect[B >: Char](that: Seq[B]): String
79.  final def isInstanceOf[T0]: Boolean
80.  def iterator: Iterator[Char]
81.  def knownSize: Int
82.  def last: Char
83.  def lastIndexWhere(p: (Char) => Boolean, end: Int = Int.MaxValue): Int
84.  def lastOption: Option[Char]
85.  def lazyZip[B](that: Iterable[B]): LazyZip2[Char, B, String]
86.  def lengthCompare(len: Int): Int
87.  def lengthIs: Int
88.  def linesIterator: Iterator[String]
89.  def linesWithSeparators: Iterator[String]
90.  def map(f: (Char) => Char): String
91.  def map[B](f: (Char) => B): immutable.IndexedSeq[B]
92.  final def mkString: String
93.  final def mkString(sep: String): String
94.  final def mkString(start: String, sep: String, end: String): String
95.  def nonEmpty: Boolean
96.  def padTo(len: Int, elem: Char): String
97.  def padTo[B >: Char](len: Int, elem: B): immutable.IndexedSeq[B]
98.  def partition(p: (Char) => Boolean): (String, String)
99.  def partitionMap(f: (Char) => Either[Char, Char]): (String, String)
100.  def patch(from: Int, other: String, replaced: Int): String
101.  def patch(from: Int, other: IterableOnce[Char], replaced: Int): String
102.  def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): immutable.IndexedSeq[B]
103.  def permutations: Iterator[String]
104.  def prepended(c: Char): String
105.  def prepended[B >: Char](elem: B): immutable.IndexedSeq[B]
106.  def prependedAll(prefix: String): String
107.  def prependedAll[B >: Char](prefix: IterableOnce[B]): immutable.IndexedSeq[B]
108.  def r: Regex
109.  def reverse: String
110.  def reverseIterator: Iterator[Char]
111.  def size: Int
112.  def sizeCompare(otherSize: Int): Int
113.  def sizeIs: Int
114.  def slice(from: Int, until: Int): String
115.  def sliding(size: Int, step: Int = 1): Iterator[String]
116.  def sortBy[B](f: (Char) => B)(implicit ord: Ordering[B]): String
117.  def sortWith(lt: (Char, Char) => Boolean): String
118.  def sorted[B >: Char](implicit ord: Ordering[B]): String
119.  def span(p: (Char) => Boolean): (String, String)
120.  def split(separators: Array[Char]): Array[String]
121.  def split(separator: Char): Array[String]
122.  def splitAt(n: Int): (String, String)
123.  def stepper: IntStepper with EfficientSplit
124.  def stripLineEnd: String
125.  def stripMargin: String
126.  def stripMargin(marginChar: Char): String
127.  def stripPrefix(prefix: String): String
128.  def stripSuffix(suffix: String): String
129.  def tail: String
130.  def tails: Iterator[String]
131.  def take(n: Int): String
132.  def takeRight(n: Int): String
133.  def takeWhile(p: (Char) => Boolean): String
134.  def toArray[B >: Char](implicit tag: ClassTag[B]): Array[B]
135.  def toBoolean: Boolean
136.  def toBooleanOption: Option[Boolean]
137.  def toByte: Byte
138.  def toByteOption: Option[Byte]
139.  def toDouble: Double
140.  def toDoubleOption: Option[Double]
141.  def toFloat: Float
142.  def toFloatOption: Option[Float]
143.  def toInt: Int
144.  def toIntOption: Option[Int]
145.  def toLong: Long
146.  def toLongOption: Option[Long]
147.  def toShort: Short
148.  def toShortOption: Option[Short]
149.  def toString(): String
150.  def updated(index: Int, elem: Char): String
151.  def view: StringView
152.  def withFilter(p: (Char) => Boolean): StringOps.WithFilter

Ungrouped