![\"Scala](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Scala-Data-Types-01.jpg\")
<\/a>Scala Data Types with Examples | Escape Value & Typecasting<\/p><\/div>\n
Introduction to Data Types in Scala<\/h3>\n
Like every other language, Scala has a type for every value. We saw this when we discussed variables and values. Even functions have a value. So, let\u2019s understand the Scala data types hierarchy for unified types.<\/p>\n
<\/a>Introduction to Scala Data Types<\/p><\/div>\n
Here, the supertype for all types is Any. It has universal methods like equals, hashCode, and toString.<\/p>\n
Any parents two subclasses: AnyVal and AnyRef.<\/p>\n
AnyVal represents value types. The nine predefined and non-nullable value types are: Double, Float, Long, Int, Short, Byte, Char, Unit, and Boolean. We\u2019ll discuss these values in a short while. AnyRef represents reference types. A user-defined type is a subtype of this. And in the context of a JRE, AnyRef corresponds to java.lang.Object.<\/p>\n
Lets now directly jump to the Scala Data Types.<\/p>\n
Scala Data Types<\/h3>\n
Let\u2019s discuss the basic in-built Scala data types in detail.<\/p>\n
a. Scala Byte<\/h4>\n
Size: 8-bit
\nSigned value
\nRange: -128 to 127<\/p>\n
b. Scala Short<\/h4>\n
Size: 16-bit
\nSigned value
\nRange: -32768 to 32767<\/p>\n
c. Scala Int<\/h4>\n
Size: 32-bit
\nSigned value
\nRange: – 2147483648 to 2147483647<\/p>\n
d. Scala Long<\/h4>\n
Size: 64-bit
\nSigned value
\nRange: -9223372036854775808 to 9223372036854775807<\/p>\n
e. Scala Float<\/h4>\n
Size: 32-bit
\nIt follows the IEEE 754 standard, and is a single-precision float.<\/p>\n
f. Scala Double<\/h4>\n
Size: 32-bit
\nIt follows the IEEE 754 standard, and is a double-precision float.<\/p>\n
g. Scala Char<\/h4>\n
Size: 16-bit
\nIt is an unsigned Unicode character
\nRange: U+0000 to U+FFFF<\/p>\n
h. Scala String<\/h4>\n
A string is a sequence of Chars.<\/p>\n
i. Scala Boolean<\/h4>\n
A Boolean value is either true or false.<\/p>\n
j. Scala Unit<\/h4>\n
There is only one instance of unit, and that is (). It carries no meaningful information. And since all functions must return something, sometimes, we have them return Unit.<\/p>\n
k. Scala Null<\/h4>\n
This refers to an empty or null reference. It is a subtype of all reference types. This makes it a subtype of any subtype of AnyRef. Null helps with interoperability with other JVM languages, and we almost never use it.<\/p>\n
l. Scala Nothing<\/h4>\n
Nothing is a subtype to every other type. And trust us, it holds no value at all.
\nSince it is a subtype of all types, we also call it the bottom type. Actually, no value is of type Nothing. So where would we use it? We can use it to signal non-termination like a thrown exception, program exit, or an infinite loop.<\/p>\n
m. Scala Any<\/h4>\n
This is the supertype for all other types. This means that any object is of the type Any.<\/p>\n
n. Scala AnyVal<\/h4>\n
This represents value types.<\/p>\n
o. Scala AnyRef<\/h4>\n
AnyRef represents reference types.<\/p>\n
Since all these Scala Data types are objects and not primitives, it is possible to call methods on these objects.<\/p>\n
Basic Literals<\/h3>\n
In this section, we will see integral, floating point, Boolean, symbol, character, and string literals in Scala. We will also see multi-line strings and null values.<\/p>\n
a. Integral Literals<\/h4>\n
These are usually Ints. When we use an \u2018l\u2019 or \u2018L\u2019 suffix, these are Longs.
\nSome valid integral literals:
\n07
\n7
\n111
\n0xFFFFFFFF
\n0798L<\/p>\n
b. Floating-Point Literals<\/h4>\n
We\u2019ve seen floating-point numbers like 7.0 and 7.7 rather than 7. When there\u2019s a suffix of \u2018f\u2019 or \u2018F\u2019, these are of type Float. Otherwise, they\u2019re of type Double.
\nSome valid floating-point literals:
\n0.0
\n1e70f
\n3.24179f
\n1.0e100
\n.1<\/p>\n
c. Boolean Literals<\/h4>\n
We have two Boolean literals- true and false.<\/p>\n
d. Symbol Literals<\/h4>\n
Scala has a Symbol case class:<\/p>\n
package scala\r\nfinal case class Symbol private (name: String) {\r\noverride def toString: String = \"'\" + name\r\n}<\/pre>\nSo, a symbol \u2018x\u2019 is equivalent to scala.Symbol(\u201cx\u201d).<\/p>\n
e. Character Literals<\/h4>\n
This is a single character delimited by quotes. A character is a printable Unicode character, and can be described by an escape sequence. We\u2019ll discuss escape sequences next.
\nSome valid character literals:
\n‘a’
\n‘\\n’
\n‘\\u0042’
\n‘\\t’<\/p>\n
f. String Literals<\/h4>\n
Such a literal is a sequence of characters delimited by double quotes.
\nSome valid string literals:
\n\u201cHannah\\nMontana\u201d
\n\u201cAnd then she said, \\\u201dBe here now is a dog\u2019s purpose\\\u201d\u201d<\/p>\n
g. Multi-line Strings<\/h4>\n
Like in Python, we can use three sets of double quotes to delimit a string to span it across multiple lines.
\nA valid multi-line string:
\n\u201c\u201d\u201dThe first line
\nThe second line\\n
\nThe fourth line\u201d\u201d\u201d<\/p>\n
h. Null Values<\/h4>\n
A null value has the type scala.Null. This makes it compatible with each reference type. But what is really denotes is a reference value referring to a special \u2018null\u2019 object.<\/p>\n
Any doubt yet in Scala Data Types.<\/p>\n
Escape Values<\/h3>\n
An escape value is a backslash with a character that will escape that character to execute a certain functionality. We can use these in character and string literals. We have the following escape values in Scala:<\/p>\n
| Escape Sequences<\/b><\/td>\n | Unicode<\/b><\/td>\n | Description<\/b><\/td>\n<\/tr>\n| \\b<\/td>\n | \\u0008<\/td>\n | Backspace BS<\/td>\n<\/tr>\n | \\t<\/td>\n | \\u0009<\/td>\n | Horizontal Tab HT<\/td>\n<\/tr>\n | \\n<\/td>\n | \\u000a<\/td>\n | Newline<\/td>\n<\/tr>\n | \\f<\/td>\n | \\u000c<\/td>\n | Formfeed FF<\/td>\n<\/tr>\n | \\r<\/td>\n | \\u000d<\/td>\n | Carriage Return CR<\/td>\n<\/tr>\n | \\\u201d<\/td>\n | \\u0022<\/td>\n | Double quote \u201c<\/td>\n<\/tr>\n | \\\u201d<\/td>\n | \\u0027<\/td>\n | Single quote \u2018<\/td>\n<\/tr>\n | \\\\<\/td>\n | \\u005c<\/td>\n | Backslash \\<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n | We can also represent characters with Unicodes between 0 and 255 with octal escapes (using backslashes). Upto three octal characters may follow. Take an example:<\/p>\n scala> println(\"Hey, how \\b are you?\\n\\tI've been\\r...\\\"waiting\\\"\")<\/pre>\n |