Scala Standard Library 2.13.1 - scala.Char (original) (raw)

abstract final class Char extends AnyVal

 

Ordering

1. Alphabetic
2. By Inheritance

Implicitly

1. by char2Character

2. by charWrapper

3. by char2double

4. by char2float

5. by char2long

6. by char2int

7. by any2stringadd

8. by StringFormat

9. by Ensuring

10. by ArrowAssoc

11. Hide All

12. Show All

Visibility

1. Public
2. Protected

Abstract Value Members

1.  abstract def !=(x: Double): Boolean
2.  abstract def !=(x: Float): Boolean
3.  abstract def !=(x: Long): Boolean
4.  abstract def !=(x: Int): Boolean
5.  abstract def !=(x: Char): Boolean
6.  abstract def !=(x: Short): Boolean
7.  abstract def !=(x: Byte): Boolean
8.  abstract def %(x: Double): Double
9.  abstract def %(x: Float): Float
10.  abstract def %(x: Long): Long
11.  abstract def %(x: Int): Int
12.  abstract def %(x: Char): Int
13.  abstract def %(x: Short): Int
14.  abstract def %(x: Byte): Int
15.  abstract def &(x: Long): Long
16.  abstract def &(x: Int): Int
17.  abstract def &(x: Char): Int
18.  abstract def &(x: Short): Int
19.  abstract def &(x: Byte): Int
20.  abstract def *(x: Double): Double
21.  abstract def *(x: Float): Float
22.  abstract def *(x: Long): Long
23.  abstract def *(x: Int): Int
24.  abstract def *(x: Char): Int
25.  abstract def *(x: Short): Int
26.  abstract def *(x: Byte): Int
27.  abstract def +(x: Double): Double
28.  abstract def +(x: Float): Float
29.  abstract def +(x: Long): Long
30.  abstract def +(x: Int): Int
31.  abstract def +(x: Char): Int
32.  abstract def +(x: Short): Int
33.  abstract def +(x: Byte): Int
34.  abstract def -(x: Double): Double
35.  abstract def -(x: Float): Float
36.  abstract def -(x: Long): Long
37.  abstract def -(x: Int): Int
38.  abstract def -(x: Char): Int
39.  abstract def -(x: Short): Int
40.  abstract def -(x: Byte): Int
41.  abstract def /(x: Double): Double
42.  abstract def /(x: Float): Float
43.  abstract def /(x: Long): Long
44.  abstract def /(x: Int): Int
45.  abstract def /(x: Char): Int
46.  abstract def /(x: Short): Int
47.  abstract def /(x: Byte): Int
48.  abstract def <(x: Double): Boolean
49.  abstract def <(x: Float): Boolean
50.  abstract def <(x: Long): Boolean
51.  abstract def <(x: Int): Boolean
52.  abstract def <(x: Char): Boolean
53.  abstract def <(x: Short): Boolean
54.  abstract def <(x: Byte): Boolean
55.  abstract def <<(x: Int): Int
56.  abstract def <=(x: Double): Boolean
57.  abstract def <=(x: Float): Boolean
58.  abstract def <=(x: Long): Boolean
59.  abstract def <=(x: Int): Boolean
60.  abstract def <=(x: Char): Boolean
61.  abstract def <=(x: Short): Boolean
62.  abstract def <=(x: Byte): Boolean
63.  abstract def ==(x: Double): Boolean
64.  abstract def ==(x: Float): Boolean
65.  abstract def ==(x: Long): Boolean
66.  abstract def ==(x: Int): Boolean
67.  abstract def ==(x: Char): Boolean
68.  abstract def ==(x: Short): Boolean
69.  abstract def ==(x: Byte): Boolean
70.  abstract def >(x: Double): Boolean
71.  abstract def >(x: Float): Boolean
72.  abstract def >(x: Long): Boolean
73.  abstract def >(x: Int): Boolean
74.  abstract def >(x: Char): Boolean
75.  abstract def >(x: Short): Boolean
76.  abstract def >(x: Byte): Boolean
77.  abstract def >=(x: Double): Boolean
78.  abstract def >=(x: Float): Boolean
79.  abstract def >=(x: Long): Boolean
80.  abstract def >=(x: Int): Boolean
81.  abstract def >=(x: Char): Boolean
82.  abstract def >=(x: Short): Boolean
83.  abstract def >=(x: Byte): Boolean
84.  abstract def >>(x: Int): Int
85.  abstract def >>>(x: Int): Int
86.  abstract def ^(x: Long): Long
87.  abstract def ^(x: Int): Int
88.  abstract def ^(x: Char): Int
89.  abstract def ^(x: Short): Int
90.  abstract def ^(x: Byte): Int
91.  abstract def toByte: Byte
92.  abstract def toChar: Char
93.  abstract def toDouble: Double
94.  abstract def toFloat: Float
95.  abstract def toInt: Int
96.  abstract def toLong: Long
97.  abstract def toShort: Short
98.  abstract def unary_+: Int
99.  abstract def unary_-: Int
100.  abstract def unary_~: Int
101.  abstract def |(x: Long): Long
102.  abstract def |(x: Int): Int
103.  abstract def |(x: Char): Int
104.  abstract def |(x: Short): Int
105.  abstract def |(x: Byte): Int
106.  abstract def +(x: String): String
107.  abstract def <<(x: Long): Int
108.  abstract def >>(x: Long): Int
109.  abstract def >>>(x: Long): Int

Concrete Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def ->[B](y: B): (Char, B)
4.  final def ==(arg0: Any): Boolean
5.  def abs: Char
6.  def asDigit: Int
7.  final def asInstanceOf[T0]: T0
8.  def byteValue: Byte
9.  def charValue(): Char
10.  def compare(y: Char): Int
11.  def compareTo(arg0: Character): Int
12.  def compareTo(that: Char): Int
13.  def doubleValue: Double
14.  def ensuring(cond: (Char) => Boolean, msg: => Any): Char
15.  def ensuring(cond: (Char) => Boolean): Char
16.  def ensuring(cond: Boolean, msg: => Any): Char
17.  def ensuring(cond: Boolean): Char
18.  def equals(arg0: Any): Boolean
19.  def floatValue: Float
20.  def formatted(fmtstr: String): String
21.  def getClass(): Class[Char]
22.  def getDirectionality: Byte
23.  def getNumericValue: Int
24.  def getType: Int
25.  def hashCode(): Int
26.  def intValue: Int
27.  def isControl: Boolean
28.  def isDigit: Boolean
29.  def isHighSurrogate: Boolean
30.  def isIdentifierIgnorable: Boolean
31.  final def isInstanceOf[T0]: Boolean
32.  def isLetter: Boolean
33.  def isLetterOrDigit: Boolean
34.  def isLowSurrogate: Boolean
35.  def isLower: Boolean
36.  def isMirrored: Boolean
37.  def isSpaceChar: Boolean
38.  def isSurrogate: Boolean
39.  def isTitleCase: Boolean
40.  def isUnicodeIdentifierPart: Boolean
41.  def isUnicodeIdentifierStart: Boolean
42.  def isUpper: Boolean
43.  def isValidByte: Boolean
44.  def isValidChar: Boolean
45.  def isValidInt: Boolean
46.  def isValidShort: Boolean
47.  def isWhitespace: Boolean
48.  def isWhole: Boolean
49.  def longValue: Long
50.  def max(that: Char): Char
51.  def min(that: Char): Char
52.  def reverseBytes: Char
53.  val self: Char
54.  def shortValue: Short
55.  def sign: Char
56.  def to(end: Char, step: Char): Inclusive[Char]
57.  def to(end: Char): Inclusive[Char]
58.  def toLower: Char
59.  def toString(): String
60.  def toTitleCase: Char
61.  def toUpper: Char
62.  def until(end: Char, step: Char): Exclusive[Char]
63.  def until(end: Char): Exclusive[Char]

Shadowed Implicit Value Members

1.  def !=(x: Double): Boolean
2.  def !=(x: Float): Boolean
3.  def !=(x: Long): Boolean
4.  def !=(x: Int): Boolean
5.  def !=(x: Char): Boolean
6.  def !=(x: Short): Boolean
7.  def !=(x: Byte): Boolean
8.  def !=(x: Double): Boolean
9.  def !=(x: Float): Boolean
10.  def !=(x: Long): Boolean
11.  def !=(x: Int): Boolean
12.  def !=(x: Char): Boolean
13.  def !=(x: Short): Boolean
14.  def !=(x: Byte): Boolean
15.  def !=(x: Double): Boolean
16.  def !=(x: Float): Boolean
17.  def !=(x: Long): Boolean
18.  def !=(x: Int): Boolean
19.  def !=(x: Char): Boolean
20.  def !=(x: Short): Boolean
21.  def !=(x: Byte): Boolean
22.  def !=(x: Double): Boolean
23.  def !=(x: Float): Boolean
24.  def !=(x: Long): Boolean
25.  def !=(x: Int): Boolean
26.  def !=(x: Char): Boolean
27.  def !=(x: Short): Boolean
28.  def !=(x: Byte): Boolean
29.  def %(x: Double): Double
30.  def %(x: Float): Double
31.  def %(x: Long): Double
32.  def %(x: Int): Double
33.  def %(x: Char): Double
34.  def %(x: Short): Double
35.  def %(x: Byte): Double
36.  def %(x: Double): Double
37.  def %(x: Float): Float
38.  def %(x: Long): Float
39.  def %(x: Int): Float
40.  def %(x: Char): Float
41.  def %(x: Short): Float
42.  def %(x: Byte): Float
43.  def %(x: Double): Double
44.  def %(x: Float): Float
45.  def %(x: Long): Long
46.  def %(x: Int): Long
47.  def %(x: Char): Long
48.  def %(x: Short): Long
49.  def %(x: Byte): Long
50.  def %(x: Double): Double
51.  def %(x: Float): Float
52.  def %(x: Long): Long
53.  def %(x: Int): Int
54.  def %(x: Char): Int
55.  def %(x: Short): Int
56.  def %(x: Byte): Int
57.  def &(x: Long): Long
58.  def &(x: Int): Long
59.  def &(x: Char): Long
60.  def &(x: Short): Long
61.  def &(x: Byte): Long
62.  def &(x: Long): Long
63.  def &(x: Int): Int
64.  def &(x: Char): Int
65.  def &(x: Short): Int
66.  def &(x: Byte): Int
67.  def *(x: Double): Double
68.  def *(x: Float): Double
69.  def *(x: Long): Double
70.  def *(x: Int): Double
71.  def *(x: Char): Double
72.  def *(x: Short): Double
73.  def *(x: Byte): Double
74.  def *(x: Double): Double
75.  def *(x: Float): Float
76.  def *(x: Long): Float
77.  def *(x: Int): Float
78.  def *(x: Char): Float
79.  def *(x: Short): Float
80.  def *(x: Byte): Float
81.  def *(x: Double): Double
82.  def *(x: Float): Float
83.  def *(x: Long): Long
84.  def *(x: Int): Long
85.  def *(x: Char): Long
86.  def *(x: Short): Long
87.  def *(x: Byte): Long
88.  def *(x: Double): Double
89.  def *(x: Float): Float
90.  def *(x: Long): Long
91.  def *(x: Int): Int
92.  def *(x: Char): Int
93.  def *(x: Short): Int
94.  def *(x: Byte): Int
95.  def +(x: Double): Double
96.  def +(x: Float): Double
97.  def +(x: Long): Double
98.  def +(x: Int): Double
99.  def +(x: Char): Double
100.  def +(x: Short): Double
101.  def +(x: Byte): Double
102.  def +(x: Double): Double
103.  def +(x: Float): Float
104.  def +(x: Long): Float
105.  def +(x: Int): Float
106.  def +(x: Char): Float
107.  def +(x: Short): Float
108.  def +(x: Byte): Float
109.  def +(x: Double): Double
110.  def +(x: Float): Float
111.  def +(x: Long): Long
112.  def +(x: Int): Long
113.  def +(x: Char): Long
114.  def +(x: Short): Long
115.  def +(x: Byte): Long
116.  def +(x: Double): Double
117.  def +(x: Float): Float
118.  def +(x: Long): Long
119.  def +(x: Int): Int
120.  def +(x: Char): Int
121.  def +(x: Short): Int
122.  def +(x: Byte): Int
123.  def +(other: String): String
124.  def -(x: Double): Double
125.  def -(x: Float): Double
126.  def -(x: Long): Double
127.  def -(x: Int): Double
128.  def -(x: Char): Double
129.  def -(x: Short): Double
130.  def -(x: Byte): Double
131.  def -(x: Double): Double
132.  def -(x: Float): Float
133.  def -(x: Long): Float
134.  def -(x: Int): Float
135.  def -(x: Char): Float
136.  def -(x: Short): Float
137.  def -(x: Byte): Float
138.  def -(x: Double): Double
139.  def -(x: Float): Float
140.  def -(x: Long): Long
141.  def -(x: Int): Long
142.  def -(x: Char): Long
143.  def -(x: Short): Long
144.  def -(x: Byte): Long
145.  def -(x: Double): Double
146.  def -(x: Float): Float
147.  def -(x: Long): Long
148.  def -(x: Int): Int
149.  def -(x: Char): Int
150.  def -(x: Short): Int
151.  def -(x: Byte): Int
152.  def /(x: Double): Double
153.  def /(x: Float): Double
154.  def /(x: Long): Double
155.  def /(x: Int): Double
156.  def /(x: Char): Double
157.  def /(x: Short): Double
158.  def /(x: Byte): Double
159.  def /(x: Double): Double
160.  def /(x: Float): Float
161.  def /(x: Long): Float
162.  def /(x: Int): Float
163.  def /(x: Char): Float
164.  def /(x: Short): Float
165.  def /(x: Byte): Float
166.  def /(x: Double): Double
167.  def /(x: Float): Float
168.  def /(x: Long): Long
169.  def /(x: Int): Long
170.  def /(x: Char): Long
171.  def /(x: Short): Long
172.  def /(x: Byte): Long
173.  def /(x: Double): Double
174.  def /(x: Float): Float
175.  def /(x: Long): Long
176.  def /(x: Int): Int
177.  def /(x: Char): Int
178.  def /(x: Short): Int
179.  def /(x: Byte): Int
180.  def <(that: Char): Boolean
181.  def <(x: Double): Boolean
182.  def <(x: Float): Boolean
183.  def <(x: Long): Boolean
184.  def <(x: Int): Boolean
185.  def <(x: Char): Boolean
186.  def <(x: Short): Boolean
187.  def <(x: Byte): Boolean
188.  def <(x: Double): Boolean
189.  def <(x: Float): Boolean
190.  def <(x: Long): Boolean
191.  def <(x: Int): Boolean
192.  def <(x: Char): Boolean
193.  def <(x: Short): Boolean
194.  def <(x: Byte): Boolean
195.  def <(x: Double): Boolean
196.  def <(x: Float): Boolean
197.  def <(x: Long): Boolean
198.  def <(x: Int): Boolean
199.  def <(x: Char): Boolean
200.  def <(x: Short): Boolean
201.  def <(x: Byte): Boolean
202.  def <(x: Double): Boolean
203.  def <(x: Float): Boolean
204.  def <(x: Long): Boolean
205.  def <(x: Int): Boolean
206.  def <(x: Char): Boolean
207.  def <(x: Short): Boolean
208.  def <(x: Byte): Boolean
209.  def <<(x: Long): Long
210.  def <<(x: Int): Long
211.  def <<(x: Int): Int
212.  def <=(that: Char): Boolean
213.  def <=(x: Double): Boolean
214.  def <=(x: Float): Boolean
215.  def <=(x: Long): Boolean
216.  def <=(x: Int): Boolean
217.  def <=(x: Char): Boolean
218.  def <=(x: Short): Boolean
219.  def <=(x: Byte): Boolean
220.  def <=(x: Double): Boolean
221.  def <=(x: Float): Boolean
222.  def <=(x: Long): Boolean
223.  def <=(x: Int): Boolean
224.  def <=(x: Char): Boolean
225.  def <=(x: Short): Boolean
226.  def <=(x: Byte): Boolean
227.  def <=(x: Double): Boolean
228.  def <=(x: Float): Boolean
229.  def <=(x: Long): Boolean
230.  def <=(x: Int): Boolean
231.  def <=(x: Char): Boolean
232.  def <=(x: Short): Boolean
233.  def <=(x: Byte): Boolean
234.  def <=(x: Double): Boolean
235.  def <=(x: Float): Boolean
236.  def <=(x: Long): Boolean
237.  def <=(x: Int): Boolean
238.  def <=(x: Char): Boolean
239.  def <=(x: Short): Boolean
240.  def <=(x: Byte): Boolean
241.  def ==(x: Double): Boolean
242.  def ==(x: Float): Boolean
243.  def ==(x: Long): Boolean
244.  def ==(x: Int): Boolean
245.  def ==(x: Char): Boolean
246.  def ==(x: Short): Boolean
247.  def ==(x: Byte): Boolean
248.  def ==(x: Double): Boolean
249.  def ==(x: Float): Boolean
250.  def ==(x: Long): Boolean
251.  def ==(x: Int): Boolean
252.  def ==(x: Char): Boolean
253.  def ==(x: Short): Boolean
254.  def ==(x: Byte): Boolean
255.  def ==(x: Double): Boolean
256.  def ==(x: Float): Boolean
257.  def ==(x: Long): Boolean
258.  def ==(x: Int): Boolean
259.  def ==(x: Char): Boolean
260.  def ==(x: Short): Boolean
261.  def ==(x: Byte): Boolean
262.  def ==(x: Double): Boolean
263.  def ==(x: Float): Boolean
264.  def ==(x: Long): Boolean
265.  def ==(x: Int): Boolean
266.  def ==(x: Char): Boolean
267.  def ==(x: Short): Boolean
268.  def ==(x: Byte): Boolean
269.  def >(that: Char): Boolean
270.  def >(x: Double): Boolean
271.  def >(x: Float): Boolean
272.  def >(x: Long): Boolean
273.  def >(x: Int): Boolean
274.  def >(x: Char): Boolean
275.  def >(x: Short): Boolean
276.  def >(x: Byte): Boolean
277.  def >(x: Double): Boolean
278.  def >(x: Float): Boolean
279.  def >(x: Long): Boolean
280.  def >(x: Int): Boolean
281.  def >(x: Char): Boolean
282.  def >(x: Short): Boolean
283.  def >(x: Byte): Boolean
284.  def >(x: Double): Boolean
285.  def >(x: Float): Boolean
286.  def >(x: Long): Boolean
287.  def >(x: Int): Boolean
288.  def >(x: Char): Boolean
289.  def >(x: Short): Boolean
290.  def >(x: Byte): Boolean
291.  def >(x: Double): Boolean
292.  def >(x: Float): Boolean
293.  def >(x: Long): Boolean
294.  def >(x: Int): Boolean
295.  def >(x: Char): Boolean
296.  def >(x: Short): Boolean
297.  def >(x: Byte): Boolean
298.  def >=(that: Char): Boolean
299.  def >=(x: Double): Boolean
300.  def >=(x: Float): Boolean
301.  def >=(x: Long): Boolean
302.  def >=(x: Int): Boolean
303.  def >=(x: Char): Boolean
304.  def >=(x: Short): Boolean
305.  def >=(x: Byte): Boolean
306.  def >=(x: Double): Boolean
307.  def >=(x: Float): Boolean
308.  def >=(x: Long): Boolean
309.  def >=(x: Int): Boolean
310.  def >=(x: Char): Boolean
311.  def >=(x: Short): Boolean
312.  def >=(x: Byte): Boolean
313.  def >=(x: Double): Boolean
314.  def >=(x: Float): Boolean
315.  def >=(x: Long): Boolean
316.  def >=(x: Int): Boolean
317.  def >=(x: Char): Boolean
318.  def >=(x: Short): Boolean
319.  def >=(x: Byte): Boolean
320.  def >=(x: Double): Boolean
321.  def >=(x: Float): Boolean
322.  def >=(x: Long): Boolean
323.  def >=(x: Int): Boolean
324.  def >=(x: Char): Boolean
325.  def >=(x: Short): Boolean
326.  def >=(x: Byte): Boolean
327.  def >>(x: Long): Long
328.  def >>(x: Int): Long
329.  def >>(x: Int): Int
330.  def >>>(x: Long): Long
331.  def >>>(x: Int): Long
332.  def >>>(x: Int): Int
333.  def ^(x: Long): Long
334.  def ^(x: Int): Long
335.  def ^(x: Char): Long
336.  def ^(x: Short): Long
337.  def ^(x: Byte): Long
338.  def ^(x: Long): Long
339.  def ^(x: Int): Int
340.  def ^(x: Char): Int
341.  def ^(x: Short): Int
342.  def ^(x: Byte): Int
343.  def equals(arg0: AnyRef): Boolean
344.  def hashCode(): Int
345.  def toByte: Byte
346.  def toByte: Byte
347.  def toByte: Byte
348.  def toByte: Byte
349.  def toByte: Byte
350.  def toChar: Char
351.  def toChar: Char
352.  def toChar: Char
353.  def toChar: Char
354.  def toChar: Char
355.  def toDouble: Double
356.  def toDouble: Double
357.  def toDouble: Double
358.  def toDouble: Double
359.  def toDouble: Double
360.  def toFloat: Float
361.  def toFloat: Float
362.  def toFloat: Float
363.  def toFloat: Float
364.  def toFloat: Float
365.  def toInt: Int
366.  def toInt: Int
367.  def toInt: Int
368.  def toInt: Int
369.  def toInt: Int
370.  def toLong: Long
371.  def toLong: Long
372.  def toLong: Long
373.  def toLong: Long
374.  def toLong: Long
375.  def toShort: Short
376.  def toShort: Short
377.  def toShort: Short
378.  def toShort: Short
379.  def toShort: Short
380.  def toString(): String
381.  def toString(): String
382.  def unary_+: Double
383.  def unary_+: Float
384.  def unary_+: Long
385.  def unary_+: Int
386.  def unary_-: Double
387.  def unary_-: Float
388.  def unary_-: Long
389.  def unary_-: Int
390.  def unary_~: Long
391.  def unary_~: Int
392.  def |(x: Long): Long
393.  def |(x: Int): Long
394.  def |(x: Char): Long
395.  def |(x: Short): Long
396.  def |(x: Byte): Long
397.  def |(x: Long): Long
398.  def |(x: Int): Int
399.  def |(x: Char): Int
400.  def |(x: Short): Int
401.  def |(x: Byte): Int

Inherited from AnyVal

Inherited from Any

Inherited by implicit conversion char2Character fromChar to Character

Inherited by implicit conversion charWrapper fromChar to RichChar

Inherited by implicit conversion char2double fromChar to Double

Inherited by implicit conversion char2float fromChar to Float

Inherited by implicit conversion char2long fromChar to Long

Inherited by implicit conversion char2int fromChar to Int

Inherited by implicit conversion any2stringadd fromChar to any2stringadd[Char]

Inherited by implicit conversion StringFormat fromChar to StringFormat[Char]

Inherited by implicit conversion Ensuring fromChar to Ensuring[Char]

Inherited by implicit conversion ArrowAssoc fromChar to ArrowAssoc[Char]

Ungrouped