Scala - 03 - 基础语法

1- 变量

变量 mutable variable

  • 在程序运行过程中其值可能发生改变的量
  • 关键词var定义变量，定义时直接进行求值

常量 immutable variable

  • 在程序运行过程中其值不会发生变化的量
  • 在声明时就必须被初始化，而且一旦初始化后就不能再赋值；
  • 关键词val定义常量，定义时直接进行求值；
  • 关键词lazy val --- 惰性求值的常量，只有当该变量第一次被使用时才会被求值
  • 常量不能修改。如果程序尝试修改常量的值，将会在编译时报错

变量类型引用

  • 可以不显示指定变量的类型，Scala具有“类型推断”能力，会自动进行类型推导；
  • 如果在没有指明数据类型的情况下声明变量或常量，必须要给出其初始值，否则将会报错；
  • 一般情况下，如果定义的变量可能不会被用到，可以定义该变量为lazy val；
  val myStr = "Hello Scala!"                      //> myStr  : String = Hello Scala!
  val myStr2: String = "Hello Scala!"             //> myStr2  : String = Hello Scala!

示例-1：

scala> val x = 10  # 定义常量x
x: Int = 10  # Scala自动推导出x的类型是Int

scala> val y:Int =20  # 显示定义Int类型常量
y: Int = 20

scala> x + x  # 定义表达式
res0: Int = 20  # res0是Scala的REPL自动为没有变量名的表达式设置默认变量名，res是result的简写，0是默认变量的标号

scala> res0  # 直接引用表达式res0
res1: Int = 20  # 因为res0这个表达式没有变量名，所以REPL默认设置res1作为res0表达式结果的变量名

scala> res0*res1
res2: Int = 400

scala> val z=res0+res1+res2  # 为表达式指定变量名
z: Int = 440

scala> z = 100  # 为Z赋新值
<console>:12: error: reassignment to val  # 常量Z的值不可以被改变
       z = 100
         ^

scala> var a = 200  # 定义变量a
a: Int = 200

scala> a = 300  # 可以为变量a赋新值
a: Int = 300

scala> val d = 20
d: Int = 20

scala> val e = 30
e: Int = 30

scala> lazy val f = d * e  # 定义惰性常量f
f: Int = <lazy>  # f的值没有立即求解，<lazy>是惰性的标记

scala> f*10  # 当惰性常量第一次被使用时才会被求值
res3: Int = 6000

scala> f
res4: Int = 600

scala>

示例-2：

  • Scala 支持多个变量的声明
  • 如果方法返回值是元组，可以使用 val 来声明一个元组
  val x, y = 100                                  //> x  : Int = 100
                                                  //| y  : Int = 100

  val test = (50, "demo")                         //> test  : (Int, String) = (50,demo)

2- 数据类型

  • Byte         8位有符号补码整数。数值区间为 -128 到 127
  • Short       16位有符号补码整数。数值区间为 -32768 到 32767
  • Int            32位有符号补码整数。数值区间为 -2147483648 到 2147483647
  • Long        64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
  • Float        32位IEEE754单精度浮点数
  • Double     64位IEEE754单精度浮点数
  • Char        16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
  • String       字符序列
  • Boolean    true或false
  • Unit           表示无值，用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
  • Null            null 或空引用，是每个引用类（继承自AnyRef的类）的子类
  • Nothing      任何其他类型的子类型，不包括无值
  • Any            所有其他类的超类
  • AnyRef       Scala里所有引用类(reference class)的基类

2.1-字面量

字面量包括整数、浮点数、布尔型、字符、字符串、符号、函数和元组字面量。

Scala允许对“字面量”直接执行方法。

  val t = 123 //123就是整数字面量                        //> t  : Int = 123
  val t2 = 3.14 //3.14就是浮点数字面量                    //> t2  : Double = 3.14
  val t3 = true //true就是布尔型字面量                    //> t3  : Boolean = true
  val t4 = ‘A‘ //‘A‘就是字符字面量                       //> t4  : Char = A
  val t5 = "Hello" //"Hello"就是字符串字面量              //> t5  : String = Hello

  "abc".intersect("bcd")                          //> res0: String = bc

注意：intersect()方法用来输出两个字符串中都存在的字符

2.2-数字类型

包括Byte、Short、Int、Long、Folat、Double，其中Float、Double浮点数。

低精度数字类型向高精度赋值时，不需要类型转换；高精度数字类型向低精度赋值时，需要类型转换。

scala> val a:Byte = 10
a: Byte = 10

scala> val b:Short = 20
b: Short = 20

scala> val c:Int = 30
c: Int = 30

scala> val d:Long = 40
d: Long = 40

scala> val e:Float = 50
e: Float = 50.0

scala> val f:Double = 60.98765
f: Double = 60.98765

scala> val x:Long = b  # Short类型常量b赋值给Long类型常量x，低精度赋值给高精度
x: Long = 20

scala> val y:Byte = x  # Long类型常量x赋值给Byte类型常量y，高精度赋值给低精度
<console>:12: error: type mismatch;  # 提示类型不匹配
 found   : Long
 required: Byte
       val y:Byte = x
                    ^

scala>

2.3-布尔类型

scala> val m=true
m: Boolean = true

scala> val n=false
n: Boolean = false

scala>

2.3-Unit

unit多作为函数的返回值出现，在函数式编程中表示函数是有副作用的，函数不返回任何的值

scala> val u:Unit = ()  # 显式声明Unit类型常量，()是文字量
u: Unit = ()

scala> val p=()
p: Unit = ()

scala>

2.4-Null和Nothing

Scala.Null和Scala.Nothing是用统一的方式处理某些"边界情况"的特殊类型。

  • Null表示一个引用类型的值是空，在Scala中通常不使用Null，而是使用？？
  • Nothing表示程序异常终止，如果函数返回值是Nothing，表明函数发生了异常。
scala> def foo() = throw new Exception("error occurred")
foo: ()Nothing

scala>

2.5-字符

字符表示：在半角单引号(‘)中的单个字符

scala> ‘a‘
res0: Char = a

scala> ‘\n‘
res1: Char =

scala> ‘\t‘
res2: Char =

scala> ‘test‘
<console>:1: error: unclosed character literal (or use " for string literal "test")
       ‘test‘
            ^

scala>

2.6-字符串

String类型全称是java.lang.String，构建于Java的String之上，新增了字符串插值（interpolation）的特性。

也就是说，Scala的字符串是由Java的String类来实现的，也可以使用java.lang.String来声明。

默认情况下，Scala总会引入 java.lang._ 、 scala._ 和 Predef._，因此这里只需要使用String就可以声明变量。

  val myStr = "Hello Scala!"                      //> myStr  : String = Hello Scala!
  val myStr2: String = "Hello Scala!"             //> myStr2  : String = Hello Scala!
  val myStr3 : java.lang.String = "Hello Scala!"  //> myStr3  : String = Hello Scala!
  • 单行字符串表示：在双引号(") 中包含的单行字符
  • 多行字符串表示：在三个双引号(""")中包含的多行字符。
scala> val myname = "Anliven"
myname: String = Anliven

scala> s"My name is ${myname}"
res0: String = My name is Anliven

scala> """row 1
     | row 2
     | row 3"""
res1: String =
row 1
row 2
row 3

scala>

3- 打印语句

  • print语句：不换行打印
  • println语句：每次打印后追加一个换行符，实现换行的效果
  • printf函数：C语言风格格式化字符串
  print("This is a ")                             //> This is a
  print("test!")                                  //> test!
  println("This is a test!")                      //> This is a test!

  val test = 123456                               //> test  : Int = 123456
  println(test)                                   //> 123456
  printf("My name is %s, the ID is %d.\n", "Anliven", test)
                                                  //> My name is Anliven, the ID is 123456.

4- 操作符

在Scala中，可以使用加(+)、减(-) 、乘(*) 、除(/) 、余数（%）等操作符。

也可以使用大于(>)、小于(<)、大于等于(>=)和小于等于(<=)等关系和逻辑操作符，产生Boolean类型结果。

操作符本身就是方法，“a 方法 b”是“a.方法(b)”的简写形式，两者是等价的。

  val Sum1 = 6 + 2                                //> Sum1  : Int = 8
  val Sum2 = (6).+(2)                             //> Sum2  : Int = 8

在Scala中并没有提供“++”和“--”操作符，但可以“+=”方式来实现自增或自减

  var test = 1                                    //> test  : Int = 1
  test += 1
  println(test)                                   //> 2

注意：使用“+=”方式时，要使用var声明变量，否则执行时会报错。

5- 常见转义字符

0 到 255 间的 Unicode 字符可以用一个八进制转义序列来表示，即反斜线?\?后跟 最多三个八进制。

  println("Hello World\n\nHello Scala");          //> Hello World
                                                  //|
                                                  //| Hello Scala

6- Range

Range可以支持创建不同数据类型的数值序列，包括Int、Long、Float、Double、Char、BigInt和BigDecimal等。

在创建Range时，需要给出区间的起点和终点以及步长（默认步长为1）。

  1 to 3                                          //> res0: scala.collection.immutable.Range.Inclusive = Range 1 to 3
  1.to(3)                                         //> res1: scala.collection.immutable.Range.Inclusive = Range 1 to 3
  1 until 3                                       //> res2: scala.collection.immutable.Range = Range 1 until 3
  1 to 10 by 3                                    //> res3: scala.collection.immutable.Range = Range 1 to 10 by 3
  0.5f to 5.9f by 0.8f                            //> res4: scala.collection.immutable.NumericRange[Float] = NumericRange 0.5 to 5.
                                                  //| 9 by 0.8

7- 代码块（code block）

  • 在Scala中，代码块（code block）用于组织多个表达式。
  • 代码块也是一个表达式，其最终求得的值是最后一个表达式的值。
  • 只有一个表达式的代码块，花括号是可以省略的。
scala> var x = 10
x: Int = 10

scala> var y = 20
y: Int = 20

scala> x + y
res0: Int = 30

scala> {x*2;y*2;x*y}  # 代码块也是一个表达式，其最终求得的值是最后一个表达式的值。
res1: Int = 200

scala> {
     | x + y
     | x + x + y + y
     | }
res2: Int = 60

scala>

8- 函数

  • 函数是一组一起执行一个任务的语句。
  • 逻辑上，每个函数执行一个特定的任务。
  • 定义函数最常用的方法是作为某个对象的成员，这种函数被称为方法。
  • 方法是类的一部分，而函数是一个对象可以赋值给一个变量。

方法定义

Scala 函数定义格式如下：

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

解释说明：

  • def 关键字声明函数定义，函数名functionName遵守命名规范
  • 可选的[参数列表]，参数列表中的参数可以使用逗号分隔
  • 冒号"：" 后是方法的返回类型[return type]，可以是任意合法的 Scala 数据类型
  • 等于号"="后是方法的主体{}
  • function body：函数主体代码
  • return [expr]：返回值
  def hello(name: String): String = {
    s"hello, ${name}"
  }                                               //> hello: (name: String)String
  hello("Anliven")                                //> res0: String = hello, Anliven

  def hello2(name: String) = {
    s"hello, ${name}"
  }                                               //> hello2: (name: String)String
  hello2("Anliven")                               //> res1: String = hello, Anliven

  def add(x: Int, y: Int) = x + y                 //> add: (x: Int, y: Int)Int
  add (1,2)                                       //> res2: Int = 3

9- if表达式

if 语句

  • if是表达式而不是语句。
  • 如果布尔表达式为 true 则执行大括号内的语句块，否则跳过大括号内的语句块，执行大括号之后的语句块。
  • if语句可以采用各种嵌套的形式。
  • Scala中的if表达式的值可以赋值给变量
if(布尔表达式)
{
   // 如果布尔表达式为 true 则执行该语句块
}

if...else 语句

if 语句后可以紧跟 else 语句，else 内的语句块可以在布尔表达式为 false 的时候执行。

if(布尔表达式){
   // 如果布尔表达式为 true 则执行该语句块
}else{
   // 如果布尔表达式为 false 则执行该语句块
}

一些示例：

  if (true) 1 else 2                              //> res0: Int = 1
  if (true) 3 else 4                              //> res1: Int = 3

  val a = 1                                       //> a  : Int = 1
  if (a == 1) a                                   //> res2: AnyVal = 1
  if (a != 1) "not one"                           //> res3: Any = ()  # 表达式不返回值，结果就是Unit的文字量（），
  if (a != 1) "not one" else a                    //> res4: Any = 1

scala> val x = 6
x: Int = 6

scala> :paste
// Entering paste mode (ctrl-D to finish)

if (x>0) {println("This is a positive number")
} else {
    println("This is not a positive number")
}

// Exiting paste mode, now interpreting.

This is a positive number

scala>

scala> :paste
// Entering paste mode (ctrl-D to finish)

if (x>0) {
    println("This is a positive number")
} else if (x==0) {
    println("This is a zero")
} else {
    println("This is a negative number")
}

// Exiting paste mode, now interpreting.

This is a positive number

scala>

scala> val test = if (x>0) 1 else -1
test: Int = 1

scala>

10- 循环

10.1-while循环

Scala中也有while和do-while循环语句。

  var x = 3                                       //> x  : Int = 3
  while (x > 0) {
    x -= 1
    printf("i is %d\n", x)
  }                                               //> i is 2
                                                  //| i is 1
                                                  //| i is 0

  var y = 0                                       //> y  : Int = 0
  do {
    y += 1
    println(y)
  } while (y < 3)                                 //> 1
                                                  //| 2
                                                  //| 3

10.2-for循环

语句格式：

for (变量<-表达式) 语句块  // 其中，“变量<-表达式”被称为生成器（generator）

for推导式：

  • 带有yield关键字的for循环。
  • 通过for循环遍历一个或多个集合，对集合中的元素进行“推导”，从而计算得到新的集合，用于后续的其他处理。

示例-1：

  for (i <- 1 to 3) println(i)                    //> 1
                                                  //| 2
                                                  //| 3
  for (i <- 1 to 3 by 2) println(i)               //> 1
                                                  //| 3
  for (i <- 1 to 3 if i % 2 == 0) println(i)      //> 2
  for (i <- 1 to 3; j <- 1 to 3) println(i * j)   //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 2
                                                  //| 4
                                                  //| 6
                                                  //| 3
                                                  //| 6
                                                  //| 9
  for (i <- 1 to 3 if i % 2 == 0; j <- 1 to 3 if j != i) println(i * j)
                                                  //> 2
                                                  //| 6
  for (i <- 1 to 5 if i % 2 == 0) yield i         //> res0: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4)

注意：

  • 语句中“<-”表示，之前的i要遍历后面1到5的所有值。
  • 使用“守卫(guard)”的表达式可以满足特定条件的结果。
  • 支持“多个生成器”，可以用分号隔开。
  • 采用yield关键字，对过滤后的结果构建一个集合。

示例-2：

  val test = List("Aaaa", "Bbb", "Cccc")          //> test  : List[String] = List(Aaaa, Bbb, Cccc)

  for (
    demo <- test
  ) println(demo)                                 //> Aaaa
                                                  //| Bbb
                                                  //| Cccc

  for {
    demo <- test
    if (demo.length > 3)
  } println(demo)                                 //> Aaaa
                                                  //| Cccc

  val result_for = for {
    demo <- test
    demo1 = demo.toUpperCase()
    if (demo1 != "")
  } yield (demo1)                                 //> result_for  : List[String] = List(AAAA, BBB, CCCC)

11- try表达式

  • try在Scala里不是语句，而是一个表达式，会返回值。
  • 下划线“_”是通配符，可以统配所有的对象。
  • 无论是否发生异常，总会执行finally里的代码。
object first {
  val result_try = try {
    Integer.parseInt("dog")
  } catch {
    case _: Throwable => 0
  } finally {
    println("always be printed")
  }                                               //> always be printed
                                                  //| result_try  : Int = 0
}

12- match表达式

类似Java里的switch。

object first {
  val code = 3                                    //> code  : Int = 3
  val result_match = code match {
    case 1 => "one"
    case 2 => "two"
    case _ => "others"
  }                                               //> result_match  : String = others
}

13- 读写文件

写入文本文件

示例：在当前用户的工作目录新生成的output.txt文件，并逐行添加数字1到5

package helloscala
import java.io.PrintWriter

object helloscala {
  def main(args: Array[String]) {
    val out = new PrintWriter("output.txt")
    for (i <- 1 to 5) out.println(i)
    out.close()
  }
}

读取文本文件中的行
使用Scala.io.Source的getLines方法实现对文件中所有行的读取。

package helloscala
import scala.io.Source

object helloscala {
  def main(args: Array[String]) {
    val inputFile = Source.fromFile("output.txt")
    val lines = inputFile.getLines
    for (line <- lines) println(line)
    inputFile.close()
  }
}

　　

原文地址：https://www.cnblogs.com/anliven/p/10041570.html

时间： 2024-08-01 17:55:17

Scala - 03 - 基础语法的相关文章

Java入门 - 语言基础 - 03.基础语法

原文地址:http://www.work100.net/training/java-basic-syntax.html更多教程:光束云 - 免费课程 基础语法 序号 文内章节 视频 1 第一个Java程序 - 2 基本语法 - 3 Java标识符 - 4 Java修饰符 - 5 Java变量 - 6 Java数组 - 7 Java枚举 - 8 Java关键字 - 9 Java注释 - 10 Java空行 - 11 继承 - 12 接口 - 13 Java源程序与编译型运行区别 - 请参照如上章节

scala系列--基础语法

Scala 与 Java 的最大区别是:Scala 语句末尾的分号 ; 是可选的. 区分大小写 -  Scala是大小写敏感的,这意味着标识Hello 和 hello在Scala中会有不同的含义. 类名 - 对于所有的类名的第一个字母要大写. 方法名称 - 所有的方法名称的第一个字母用小写. 程序文件名 - 程序文件的名称应该与对象名称完全匹配. import语句可以出现在任何地方,而不是只能在文件顶部.import的效果从开始延伸到语句块的结束. 如果想要引入包中的几个成员,可以使用selec

Scala学习 -- 基础语法

一.变量 1.三种变量修饰符 val 定义 immutable variable(不修改 常量) var 定义 immutable variable(可修改 变量)   lazy val (惰性赋值的常量):不直接算出结果,在系统第一次调用 lazy val 的时候计算结果 scala> val d = 12 d: Int = 12 scala> val e = 20 e: Int = 20 scala> lazy val f = d * e f: Int = <lazy>

Scala基础语法 （一）

如果你之前是一名 Java 程序员,并了解 Java 语言的基础知识,那么你能很快学会 Scala 的基础语法. Scala 与 Java 的最大区别是:Scala 语句末尾的分号 ; 是可选的. 我们可以认为 Scala 程序是对象的集合,通过调用彼此的方法来实现消息传递.接下来我们来理解下,类,对象,方法,实例变量的概念: 对象 - 对象有属性和行为.例如:一只狗的状属性有:颜色,名字,行为有:叫.跑.吃等.对象是一个类的实例. 类 - 类是对象的抽象,而对象是类的具体实例. 方法 - 方法

Scala学习笔记一之基础语法，条件控制，循环控制，函数，数组，集合

前言:Scala的安装教程:http://www.cnblogs.com/biehongli/p/8065679.html 1:Scala之基础语法学习笔记: 1:声明val变量:可以使用val来声明变量,用来存放表达式的计算结果,但是常量声明后是无法改变它的值的,建议使用val来声明常量: 声明var变量:如果要声明可以改变的引用,可以使用var变量,声明的常量的值可以改变. 3:指定类型:无论声明val变量还是声明var变量.都可以手动指定其类型,如果不指定,scala会自动根据值,进行类型

Spark入门到精通--（第二节）Scala编程详解基础语法

Scala是什么? Scala是以实现scaleable language为初衷设计出来的一门语言.官方中,称它是object-oriented language和functional language的混合式语言. Scala可以和java程序无缝拼接,因为scala文件编译后也是成为.class文件,并且在JVM上运行. Spark是由Scala进行开发的. Scala安装? 这里就讲一下Scala在Centos上进行安装的过程,和安装JDK差不多. 官网下载Scala:http://www

Scala系统学习(三)：Scala基础语法

如果您熟悉Java语言语法和编程,那么学习Scala将会很容易.Scala和Java之间最大的句法差异在于行结束字符的分号(;) 是可选的. 当编写Scala程序时,它可以被定义为通过调用彼此的方法进行通信的对象的集合.现在我们简单地看一下类,对象,方法和实例变量的含义. 对象 - 对象有状态和行为.一个对象是类的一个实例.例如 - 狗有状态:颜色,名称,品种,它行为有:摇摆,吠叫和吃东西. 类 - 可以将类定义为描述与该类相关的行为/状态的模板/蓝图. 方法 - 一个方法基本上是一种行为.一个

Scala学习（一）——基础语法

Scala语言是一种面向对象语言,结合了命令式(imperative)和函数式(functional)编程风格,其设计理念是创造一种更好地支持组件的语言. 特性 多范式(Multi-Paradigm)编程语言,类似Java.C#: 继承面向对象编程和函数式编程的特性: 面向对象:[1]. 子类继承,[2]. 混入(Mixin)机制: 函数式:支持高阶函数.嵌套函数,模式匹配,支持柯里化(Currying): 类型推断(Type Inference):根据函数体中的具体内容推断方法的返回值类型 更

Scala简介及基础语法

一.scala简介 官网:https://www.scala-lang.org/ Scala语言很强大,集成了面向对象和函数式编程的特点. 运行在JVM(jdk). 大数据中为什么学习scala? spark是scala语言编写. python写spark 挺好的 java写spark 很糟糕(代码实在是太多了) scala写spark 很完美 二.scala特点 1)优雅 框架设计中第一个要考虑的问题就是API是否优雅. 精简的封装. 代码精简(少). 2)速度快 scala语言表达能力强.