Scala学习笔记-基本数据类型

Scala-基本数据类型

scala支持八种基本数据类型，同时利用隐式转换，对基本数据类型进行了增强，下面就来介绍一下scala中的基本数据类型。

---

scala基本数据类型说明

scala中的基本数据类型同java的基本数据类型有所不同，scala没有区分基本类型和包装类型，而是统一定义为class类，注意这里的类不同于java中的包装类型，这仅仅是scala的一个普通类而已，scala编译器在翻译的过程中，会将其转换成java中的基本数据类型，就像下面这样：

class Test {
val a: Byte = 0
}

被翻译成如下java代码：

public class Test
{
private final byte a = 0;
public byte a() { 
return this.a;
  }
}

scala中包含的基本数据类型详情如下表所示：

序号	基本类型	增强类型	大小	取值范围
1	Byte	RichByte	8-bit	-128 ~ 127
2	Char	RichChar	16-bit	0 ~ 65535
3	Short	RichShort	16-bit	-32768 ~ 32767
4	Int	RichInt	32-bit	-2^31 ~ 2^31 -1
5	Long	RichLong	64-bit	-2^63 ~ 2^63 -1
6	Float	RichFloat	32-bit
7	Double	RichDoube	64-bit

其中RichXX是对于基本数据类型的扩展，提供了常用的操作基本数据类型的方法，当在基本数据类型上使用那些没有提供的方法时，scala就会自动应用 隐式转换 将其转换成对用的增强类型，并从中寻找被应用的方法，以Int为例，看一下源码中的注释：

/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2002-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */

// DO NOT EDIT, CHANGES WILL BE LOST
// This auto-generated code can be modified in scala.tools.cmd.gen.
// Afterwards, running tools/codegen-anyvals regenerates this source file.

package scala

/** `Int`, a 32-bit signed integer (equivalent to Java's `int` primitive type) is a
 * subtype of [[scala.AnyVal]]. Instances of `Int` are not
 * represented by an object in the underlying runtime system.
 *
 * There is an implicit conversion from [[scala.Int]] => [[scala.runtime.RichInt]]
 * which provides useful non-primitive operations.
 */
final abstract class Int private extends AnyVal {
def toByte: Byte
def toShort: Short
def toChar: Char
  ...

可以从类的说明中看到，scala为Int添加了从Int到Rich的隐式转换。

代码示例

下面来看一些简单的例子

package my.scala.basictype

/**
 * Created by zhangdong on 2016/4/30.
 */
object Test1 extends App{

/** 
 * Byte, Char, Short, Int, ,Long, Float, Double, Boolean
 * */

//Byte -128 - 127
val byte_1: Byte = 65
    println(byte_1.toChar)  // A
//toInt 为RichByte提供的方法
    println(byte_1.toInt.getClass.getSimpleName) // int



//Short -32768 - 32767 2^15
   println("------------short------------")
val short_1: Short = 10000
   println(short_1)    //10000
   println(short_1.getClass.getSimpleName) //short
//RichShort
   println(short_1.toByte)  //16



//Char 0 - 65535 2^16 - 1
   println("-----------char-------------")
val char_1: Char = 10009
//println((Character.MIN_VALUE + 0) + "-" + Character.MAX_VALUE)
   println(char_1)   // ✙
//RichDouble
   println(char_1.toByte) // 25
   println(char_1.toDouble) //10009.0


//Int -2^31 - (2^31 - 1)
   println("-----------Int---------------")
val int_1: Int = 2000
   println(int_1)
//RichInt
   println(int_1.toShort) //2000
   println(int_1.toDouble) //2000.0

val int_2 = - 190
   println(int_2.abs)  //求绝对值
   println(int_2.byteValue) //66 ， -190超出byte范围
   println(int_1.compare(11145))   //-1
   println(int_2.compareTo(-823))  // 1
   println((int_1.compare(2000)))  //0

   println(int_2.isValidShort) //true
   println(int_1.isValidByte)  //false 不在byte范围内

   println(int_1.max(20001))  //20001 返回较大的
   println(int_1.min(19000))  //2000 返回自己


val to_1 = 10 to (100, 4)
  println(to_1)  //包括100

val until_1 = 10 until(100, 3)  //不包括100
  println(until_1)

//Long -2^63 - (2^63 - 1)
//Float -2^63 - (2^63 - 1)
//Double 

}

没有列举的可查看官方文档。