Shulou(Shulou.com)06/03 Report--

This article mainly explains the "basic types and textual introduction of Scala". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "the basic types and textual introduction of Scala".

Basic types of Scala

Table 5. 1 shows many basic types of Scala and its instance range. In general, types Byte,Short,Int,Long and Char are called integer types: integral type. Integer types plus Float and Double are called number types: numeric type.

Table 5.1 some basic types

With the exception of String, which belongs to the java.lang package, all other base types are members of the package scala. For example, the full name of Int is scala.Int. However, since all members of the package scala and java.lang are automatically referenced by each Scala source file, you can just use a simplified name anywhere (that is, names like Boolean, or Char, or String).

Be careful

Currently, you can actually use lowercase aliases for Scala value types that are consistent with the original type of Java. For example, you can use int instead of Int in Scala programs. But remember that they are all the same thing: scala.Int. The recommended style proposed by the Scala community practice is always in uppercase, which is what we do in this book. To commemorate this community-driven choice, future versions of Scala may no longer support or even remove lowercase variants, so it would be wise to follow the flow of the community and use Int instead of int in your Scala code.

A keen Java developer will notice that the basic type of Scala is exactly the same as the corresponding type range of Java. This allows the Scala compiler to directly translate the value type of Scala: the value type instance, such as Int or Double, into the Java primitive type in the bytecode it generates.

Text

All the basic types listed in Table 5. 1 can be written as text: literal. Text is a way to write constant values directly in code.

Integer text

Integer text of types Int,Long,Short and Byte can be in three formats: decimal, hexadecimal, and octal. The beginning of the integer text describes the base of the number. If the number starts at 0x or 0X, it is hexadecimal (based on 16) and may contain numbers from 0 to 9, and uppercase or lowercase numbers from A to F. Examples are as follows:

Scala > val hex = 0x5 hex: Int = 5 scala > val hex2 = 0x00FF hex2: Int = 255scala > val magic = 0xcafebabe magic: Int =-889275714

Note that no matter what form of integer text you initialize, Scala's shell always prints an integer value based on 10. So the interpreter will display the value of the hex2 variable you initialized with the text 0x00FF as decimal 255. Of course, you can disbelieve what we say. A good way to start feeling the language is to try these sentences in the interpreter as you read this chapter. If the number starts at zero, it is octal (based on 8) and can only contain the numbers 0 to 7 Here are some examples:

Scala > val oct = 035 / / (octal 35 is decimal 29) oct: Int = 29 scala > val nov = 0777 nov: Int = 511 scala > val dec = 0321 dec: Int = 209

If the number starts with a non-zero number and has not been decorated, it is decimal (based on 10). For example:

Scala > val dec1 = 31 dec1: Int = 31 scala > val dec2 = 255 dec2: Int = 255 scala > val dec3 = 20 dec3: Int = 20

If the integer text ends in L or l, it is of type Long, otherwise it is of type Int. Some integer text of type Long are:

Scala > val prog = 0XCAFEBABEL prog: Long = 3405691582 scala > val tower = 35L tower: Long = 35 scala > val of = 31l of: Long = 31

If the text of type Int is assigned to a variable of type Short or Byte, the text is regarded as a Short or Byte type that makes the text value within the valid range of that type. Such as:

Scala > val little: Short = 367little: Short = 367scala > val littler: Byte = 38 littler: Byte = 38

Floating point text

Floating point text consists of decimal numbers, optional decimal points, and optional E or e and exponential parts. Here are some examples of floating-point text:

Scala > val big = 1.2345 big: Double = 1.2345 scala > val bigger = 12.345 bigger: Double = 12.345 scala > val biggerStill = 123E45 biggerStill: Double = 1.23e+35 trillion

Note that the exponent part represents multiplying by the power of 10. So, 12.345 is 1.2345 times 101, which is equal to 12.345. If the floating point text ends with F or f, it is of type Float, otherwise it is of type Double. Optionally, Double floating point text can also end with D or d. Examples of Float text are as follows:

Scala > val little = 1.2345F little: Float = 1.2345 scala > val littleBigger = 3e5f littleBigger: Float = 300000.0

* A value can be expressed as a Double type in the following (or other) formats:

Scala > val anotherDouble = 3e5 anotherDouble: Double = 300000.0 scala > val yetAnother = 3e5D yetAnother: Double = 300000.0

Character text

Character text can be any Unicode character between single quotation marks, such as:

Scala > val a = 'A'a: Char = A

In addition to explicitly providing characters between single quotes, you can also provide an octal or hexadecimal number with a prefix backslash that represents a character code point. The octal number must be between'0' and '377'. For example, the Unicode character code point for the letter An is octal 101. Therefore:

Scala > val c ='\ 101c: Char = A

Character text can also be given as a universal Unicode character with a four-digit hexadecimal number prefixed with\ u, such as:

Scala > val d ='\ u0041d: Char = A scala > val f ='\ u0044' f: Char = D

In fact, this unicode character can appear anywhere in a Scala program. For example, you can write an identifier like this:

Scala > val B\ u0041\ u0044 = 1 BAD: Int = 1

This identifier is treated as BAD, the result of the extension of the two unicode characters in the above code. In general, naming an identifier in this way is a bad idea because it is too difficult to read. However, this syntax allows Scala source files that contain non-ASCII Unicode characters to be represented by ASCII.

Table 5.2 Special character text escape sequence

Finally, there are some character texts that are represented as special escape sequences, as shown in Table 5.2. For example:

Scala > val backslash ='\\ 'backslash: Char =\

String text

Undefined

Scala > val hello = "hello" hello: java.lang.String = hello

The syntax of the characters in quotation marks is the same as the character text, such as:

Scala > val escapes = "\\"\'"escapes: java.lang.String =\"'

Because this syntax is clumsy for strings that contain a large number of escape sequences or span several lines. So Scala introduces a special syntax for the original string: raw String. Start and end an original string with three quotation marks ("") on the same line. The internal original string can contain any kind of character, including new lines, quotation marks, and special characters, except for three quotation marks on the same line. For example, the following program prints a message using the original string:

Println ("" Welcome to Ultamix 3000. Type "HELP" for help. "")

Running this code does not produce exactly what you need, but rather:

Welcome to Ultamix 3000. Type "HELP" for help.

The reason is that the leading space in the second line is included in the string. To address this common situation, the string class introduces the stripMargin method. The way to use this is to put the pipe symbol (|) in front of each line and then call stripMargin on the entire string:

Println ("" | Welcome to Ultamix 3000. | Type "HELP" for help. "" .stripMargin)

In this way, the output is satisfactory:

Welcome to Ultamix 3000. Type "HELP" for help.

Symbolic text

The symbolic text is written as'

Oh, here.

Can be an identifier of any letter or number. This text is mapped to an instance of the predefined class scala.Symbol. In particular, the text 'cymbal will be extended by the compiler to factory method calls: Symbol ("cymbal"). A typical application scenario for symbolic text is that you use an identifier in a dynamically typed language. For example, you might want to define a method to update database records:

Scala > def updateRecordByName (r: Symbol, value: Any) {/ / code goes here} updateRecordByName: (Symbol,Any) Unit

The method takes a symbolic parameter indicating the field name of the record and a field that should be updated into the value of the record. In dynamically typed languages, you can call this operation by passing an undeclared field identifier to the method, but this will compile in Scala:

Scala > updateRecordByName (favoriteAlbum, "OK Computer")

6: error: not found: value favoriteAlbum updateRecordByName (favoriteAlbum, "OK Computer")

An equally concise alternative is that you can pass a symbolic text:

Scala > updateRecordByName ('favoriteAlbum, "OK Computer")

There is not much that can be done with symbols other than discovering its name:

Scala > val s = 'aSymbol s: Symbol =' aSymbol scala > s.name res20: String = aSymbol

Another thing worth noting is that the symbol is detained: interned. If you write the same symbolic text twice, the two expressions will point to the same Symbol object.

Boolean text

Boolean types have two text, true and false:

Scala > val bool = true bool: Boolean = true scala > val fool = false fool: Boolean = false Thank you for your reading. The above is the content of "basic types and textual introduction of Scala". After the study of this article, I believe you have a deeper understanding of the basic types and textual introduction of Scala, and the specific use needs to be verified by practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.