scala系列（一）基本类型及操作、程序控制结构 有更新！

  |   0 评论   |   1,505 浏览

37套精品Java架构师高并发高性能高可用分布式集群电商缓存性能调优设计项目实战视教程 置顶！ 有更新！

（一）Scala基本类型

Scala中的基本数据类型如下图： 

从上表中可以看出，Scala的基本数据类型与Java中的基本数据类型是一一对应的，不同的是Scala的基本数据类型头字母必须大写，本节以Int、Long、String、Char、Double及Float类型为例介绍Scala的基本类型定义

1. 整数类型变量

    val i16:Int = 0xF; // 16进制

    val i10:Int = 15;  // 10进制

print(i16 == i10);

 

    val i162 = 0x11; //不需要指定类型

    val i102 = 17;

    print(i162 == i102)

truetrue

 

2. 浮点类型变量

Double类型定义,直接输入浮点数，编译器会将其自动推断为Double类型，要定义Float类型浮点数，需要在浮点数后面加F或f。浮点类型的变量还可以采用指数表示法，e也可以是大写E,0.314529e1与0.314529*10等同。

    val doubleval = 3.143; // 默认是Double类型

    val floatval2 = 3.143F; // float类型 F,f

    println("doubleval==floatval2:"+(doubleval == floatval2));

 

    val fval3 = 3.14e5; // 指数表示法

    val fval4 = 314000F;

    println("fval3==fval4:"+(fval3 == fval4));

doubleval==floatval2:false

fval3==fval4:true

 

3. 字符变量

字符定义，用''将字符包裹

    val ct = 's';

常用特殊字符包括 
\n 换行符，其Unicode编码为 (\u000A) 
\b 回退符，其Unicode编码为 (\u0008) 
\t tab制表符 ，其Unicode编码(\u0009) 
\” 双引号，其Unicode编码为 (\u0022) 
\’ 单引号，其Unicode编码为 (\u0027) 
\ 反斜杆，其Unicode编码为(\u005C)

4. 字符串变量

字符串变量用""包裹，要定义"Hello World"，可以加入转义符\。如果希望能够原样输出字符串中的内容，则用三个引号"""将字符串包裹起来。

    val str = "Helloworld!";

    println(str);

    

    val str2 = "\"Helloworld!\""; // 转义字符

    println(str2);

    

    val str3 = """\\\"H\be\tlloworld!\"""; // 需要原样输出

    println(str3);

Helloworld!

"Helloworld!"

\\\"H\be\tlloworld!\

 

5. 布尔类型

    var bool = true;

 

（二）Scala基本类型操作

在Scala中一切操作皆方法，这意味着Scala中的一切皆为对象

1. 算术操作

整数求和，编译器会将其转换为(1).+(2)执行

scala> var sumVlaue=1+2

sumVlaue: Int = 3

//前一语句等同于下列语句

scala> var sumVlaue=(1).+(2)

sumVlaue: Int = 3

//操作符重载,编译器会将其转换为(1).+(2L)执行

scala> val longSum = 1 + 2L

longSum: Long = 3

//减法

scala> 1-3

res5: Int = -2

//除法

scala> 1/3

res6: Int = 0

//取模

scala> 1%3

res7: Int = 1

//乘法

scala> 1L*3L

res8: Long = 3

//scala中可以用+ -符号来表示正负数，例如-3 +3，并且可以加入到运算符当中

scala> var y=1+ -3

y: Int = -2

2. 关系运算

//>运算符

scala> 3 > -3

res12: Boolean = true//<运算符

scala> 3 < -3

res13: Boolean = false//<=运算符

scala> 3 <= -3

res14: Boolean = false//<=运算符

scala> 3 <=3

res15: Boolean = true//<=运算符

scala> !(3<= -3)

res16: Boolean = true

3. 逻辑运算

//逻辑与：&&

scala> val bool=truebool: Boolean = true

scala> bool && bool

res17: Boolean = true

//逻辑或：||

scala> bool || bool

res18: Boolean = true

scala> bool || !bool

res20: Boolean = true

4. 位运算

// 00000001// 00000010// 00000000

scala> 1 & 2

res24: Int = 0

// 00000001// 00000010// 00000011

scala> 1 | 2

res24: Int = 3

// 00000001// 00000011// 00000010

scala> 1 ^ 3

res24: Int =2

//00000001//11111110

scala> ~1

res24: Int =-2

//左移位（shift left）//00000110//00001100

scala> 6 << 1

res29: Int = 12

//右移位（shift left）//00000110//00000011

scala> 6 >> 1

res28: Int = 3

//无符号右移（shift left）

//11111111111111111111111111111111//00000000000000000000000000000001

scala> -1 >>> 31

res32: Int = 1

5. 对象比较

    var i1 = 1;

    var l1 = 1L;

    

    var s8 = (i1 == l1);

    println("i1.class"+i1.getClass()+",l2.class"+l1.getClass()+"i1 == l1:"+s8);

i1.class:int,l2.class:long,i1 == l1:true

 

Scala中的对象比较不同于Java中的对象比，Scala基于内容比较，而java中比较的是引用，进行内容比较时须定义比较方法。

6. 运算符的优先级

运算符优先级如下图所示，* / %优先级最高，依次类推 
 

（三）Scala程序控制结构

1. if

    // if 的表达式使用

    var x = if("hello" == "你好") 1 else 2;

    println(x);

2

 

2. while

  def gcdLoop(x: Long, y: Long): Long = {

        var a = x

        var b = y

        while (a != 0) {

            val temp = a

            a = b % a

            b = temp

        } 

        b

  }

3. do while的使用

    var line = ""

    do {

      line = readLine()

      println("Read: "+ line)

    } while (line != "")

adfd

Read: adfd

adfdfd

Read: adfdfd

注意：与if不同的是，while与do while不能用作表达式，也即其返回值为Unit，在某些函数式编程语言中，删除了while与do while程序控制结构，但scala仍然保留了while与do while，可见Scala并不是纯函数式编程语言（另外一个重要原因是，scala函数定义时仍然可以用var指定参数）。

利用if替代while控制结构，这样做可以减少var变量的使用，程序结构也更简单，表达能力更强。

  def gcd(x: Long, y: Long): Long = if (y == 0) x else gcd(y, x % y)

 

    var line = ""   

    while ((line = readLine()) != "")  // 在Scala中不能这么用，因为Scala中的赋值操作返回的值是Unit，而""是String类型，不能进行比较，这是函数式编程语言特有的特点

    println("Read: "+ line)

    //一直打印退出不了

4. for循环的使用

    //集合操作方式

    val filesHere = (new java.io.File(".")).listFiles;

    for (file <- filesHere) println(file)

.\.cache-main

.\.classpath

.\.project

.\.settings

.\bin

.\src

程序中的<-被称生成器（generator），在执行过程中，集合filesHere中（Array[File])的元素将依次赋给file，file类型为File，打印时调用其toString方法将文件名称打印出来。

<-生成器对其它类型的集合也适用

    for(ii <- 1 to 3)println(ii);

1

2

3

 

在for循环结构中还可以加入if进行过滤操作，可以加入多个过滤条件，用;隔开

    val filesHere = (new java.io.File(".")).listFiles;

    for (file <- filesHere if file.getName.endsWith(".project")) println(file)

.\.project

5. 多重循环的实现

    var line = ""

    val filesHere = (new java.io.File("E:\\eclipsepj\\003-tutorial\\src\\com\\boom\\scala\\s1")).listFiles

    def fileLines(file: java.io.File) = scala.io.Source.fromFile(file).getLines.toList

    def grep(pattern: String) = for (

        file <- filesHere if file.getName.endsWith(".scala");

        line <- fileLines(file) if line.trim.matches(pattern)

    ) println(file +": "+ line.trim )

    grep(".*gcd.*")

E:\eclipsepj\003-tutorial\src\com\boom\scala\s1\Hellow.scala: val doubleval = 3.143; // 默认是Double类型gcd

E:\eclipsepj\003-tutorial\src\com\boom\scala\s1\ProgramControl.scala: //    println(gcdLoop(10, 17))

E:\eclipsepj\003-tutorial\src\com\boom\scala\s1\ProgramControl.scala: grep(".*gcd.*")

E:\eclipsepj\003-tutorial\src\com\boom\scala\s1\ProgramControl.scala: def gcdLoop(x: Long, y: Long): Long = {

E:\eclipsepj\003-tutorial\src\com\boom\scala\s1\ProgramControl.scala: def gcd(x: Long, y: Long): Long = if (y == 0) x else gcd(y, x % y)

上面的for相当于下列语句

    def grep(pattern:String) = for(

      file <- filesHere if file.getName.endsWith(".scala")    

    ) for(

      line <- fileLines(file) if line.trim.matches(pattern)    

    ) println(file +":"+line.trim());

 

生成返回结果

每次循环将结果保留，当整个循环执行完毕，所有保留的值将会生成一个集合并返回

scala> def scalaFiles =

     | for {

     | file <- filesHere

     | if file.getName.endsWith(".scala")

     | } yield file

scalaFiles: Array[java.io.File]

 

Array[File]到Array[Int]的转换

scala> val forLineLengths =

     | for {

     | file <- filesHere

     | if file.getName.endsWith(".scala")

     | line <- fileLines(file)

     | trimmed = line.trim

     | if trimmed.matches(".*for.*")

     | } yield trimmed.length

forLineLengths: Array[Int] = Array()


评论

发表评论

validate