Scala语言基础（一）

---

简介

Scala语言是一门类Java的多范式语言，整合了面向对象编程和函数式编程的最佳特性。

• Scala运行于Java虚拟机（JVM）之上，并且兼容现有的Java程序
• Scala是一门纯粹的面向对象的语言
• Scala是一门函数式语言

---

一、基本数据类型和变量

1.基本数据类型

Scala的数据类型包括：Byte、Char、Short、Int、Long、Float、Double和Boolean。在 Scala 中，所有数据类型都是对象，比如，Int的全名是scala.Int。

数据类型	描述
Byte	8位有符号整数，数值范围为 -128 到 127
Char	16位无符号Unicode字符，数值范围为 U+0000 到 U+FFFF
Short	16位有符号整数，数值范围为 -32768 到 32767
Int	32位有符号整数，数值范围为 -2147483648 到 2147483647
Long	64位有符号整数，数值范围为 -263 到 263-1
Float	32位IEEE 754单精度浮点数
Double	64位IEEE 754双精度浮点数
Boolean	布尔类型，值为 true 或 false

2.字面量

在 Scala 中，字面量（Literals）是直接表示固定值的表达式。Scala支持各种类型的字面量，涵盖了数值、字符、字符串、布尔值等。

val i=123   //整数字面量
val i=1.23  //浮点数字面量
val i=true  //布尔型字面量

3.变量

Scala有两种类型的变量：

• val：是不可变的，在声明时就必须被初始化，而且初始化以后就不能再赋值
• var：是可变的，声明的时候需要进行初始化，初始化以后还可以再次对其赋值

var i:Int = 10   //var 变量名 [: 变量类型] = 初始值		
val j:Int = 20   //val 常量名 [: 常量类型] = 初始值

Scala的类型推断机制可根据初始值自动推断变量的类型，使得定义变量时可以省略具体的数据类型及其前面的冒号

4.运算符

Scala 含有丰富的内置运算符，包括以下几种类型：

1. 算术运算符：加(+)、减(-) 、乘(*) 、除(/) 、余数(%)；
2. 关系运算符：大于(>)、小于(<)、等于(==)、不等于(!=)、大于等
   于(>=)、小于等于(<=) ；
3. 逻辑运算符：逻辑与(&&)、逻辑或(||)、逻辑非(!)；
4. 位运算符：按位与(&)、按位或(|)、按位异或(^)、按位取反(~)、左移动运算符(<<)、右移动运算符(>>)、无符号运算符(>>>)；
5. 赋值运算符：=及其与其它运算符结合的扩展赋值运算符，例如+=、%= ；

操作符优先级：算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符

5.注释

// 单行注释
/* 多行注释 */
/**
* 文档注释
*/

6.输入输出

• 输入：readInt、readDouble、readByte、readShort、readFloat、readLong、readChar、readBoolean及readLine，分别对应9种基本数据类型
• 输出：print()、println()、printf()

 print("i="); print("hello");
 // 两条语句位于同一行 i=hello
 println("hello"); println("world");
 // println 自动换行
 // hello
 // world
 printf("I am %d years old and weight %.1f Kg.",34,56.5) 

二、流程控制

1.if…else

// 1.if...else if...else
 if( x == 10 ){
 	println("X 的值为 10");
 }else if( x == 20 ){
    println("X 的值为 20");
 }else if( x == 30 ){
    println("X 的值为 30");
 }else{
    println("无法判断 X 的值");
 }
// 2.三元运算
val a = if(x > 0) 1 else -1

2.while循环

var i=0
// 1.while
while (i < 5) {
  println(i)
  i += i
}

//2.do...while
do {
  println(i)
  i += i
} while (i < 5)

3.for循环

// to 包含 5 输出结果：1 2 3 4 5 
for (i <- 0 to 5) {
  println(i)
}
// until 不包含 5 输出结果：1 2 3 4 
for (i <- 0 until 5) {
  println(i)
}
// by:步长 输出结果：1 3 5 
for (i <- 1 until 5 by 2) {
  println(i)
}
// 多个生成器:i循环嵌套j循环 
// 输出结果: 1 2 2 4 3 6
for (i <- 1 to 3;j <- 1 to 2 ) {
  println(i)
}
// if 过滤，可通过 ; 添加多个过滤条件
for (i <- 0 to 5 if i > 2) {
  print(i)
}//输出：3 4 5
for (i <- 0 to 5 if i > 2; if i != 4) {
  print(i)
}//输出：3 5

for 结构可以在每次执行的时候创造一个值，然后将包含了所有产生值的集合作为for循环表达式的结果返回，集合的类型由生成器中的集合类型确定。

val r=for (i <- Array(1,2,3,4,5) if i%2==0) yield { println(i); i} 
// 2 
// 4 
// r: Array[Int] = Array(2,4) 

4.循环控制

为了提前终止整个循环或者跳到下一个循环，Scala没有break和continue关键字。Scala提供了一个Breaks类，Breaks类有两个方法用于对循环结构进行控制，即breakable和break。

Breaks.breakable(
  for (e <- 1 to 5) {
    println(e)
    if (e > 4) {
      Breaks.break() //跳出breakable，终止for循环，相当于break
    }
  }
)

for (e <- 1 to 5) {
  Breaks.breakable(
    if (e > 4) {
      Breaks.break() //跳出breakable，终止当次循环，相当于continue
    }
    println(e)
  }
)

三、集合

1.简介

Scala提供了一套丰富的集合（collection）实现，包括序列（Sequence）、集合（Set）、映射（Map）等 。

• Scala 集合分为可变的和不可变的集合。
• 可变集合：可以对原对象进行修改。
• 不可变集合：每次修改就会返回一个新对象，而不会对原对象进行修改。

2.数组

• 数组：一种可变的、可索引的、元素具有相同类型的数据集合 。
• Scala提供了参数化类型的通用数组类Array[T]，其中T可以是任意的Scala类型，可以通过显式指定类型来实例化一个数组。

// 声明一个长度为3的整型数组，每个数组元素初始化为0; 数组索引从0开始
val arr1 = new Array[Int](3)
arr1(0) = 12 //给第一个元素赋值

也可以不给出数组类型，Scala会自动根据提供的初始化数据来推断出数组的类型

val arr = Array(12,45,33)

多维数组的创建通过Array.ofDim实现，通过多级圆括号访问

val  matrix = Array.ofDim[Int](3,4)  
//类型: Array[Array[Int]] 
matrix(0)(2) // 返回第一行第三列的元素

3.元组

• 元组是对多个不同类型对象的一种简单封装，最大长度为22。

// 声明
val tuple = (40, "bobo", true)
// 访问
println(tuple._1)

4.列表

• 列表: 一种共享相同类型的不可变的对象序列
• 不同于Java的java.util.List，scala的List是不可变的

var strList=List("BigData","Hadoop","Spark")
strList.head // 返回列表第一个元素的值: BigData
strList.tail // 返回除第一个元素外的其它值构成的新列表: ("Hadoop","Spark") 

// 开头插入数据
val otherList="Apache"::strList // List("Apache","BigData","Hadoop","Spark")

// 空列表对象Nil: 可以将多个元素用操作符::串起来初始化一个列表
val intList = 1::2::3::Nil // 与val intList = List(1,2,3)等效

5.集合

• 集合(set)：不重复元素的集合
• 数据无序、不可重复
• 默认情况下，Scala 使用的是不可变集合

var mySet = Set("Hadoop","Spark") 
mySet += "Scala"

如果要声明一个可变集，则需要提前引入scala.collection.mutable.Set

import scala.collection.mutable.Set 
val myMutableSet = Set("Database","BigData") 

6.映射

• 映射(Map)：一系列键值对。键是唯一的，但值不一定是唯一的。
• 有可变与不可变两种类型，默认情况下为不可变。

val university = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University")
// 通过 键 取值
println(university("XMU"))

要使用可变映射，需引入scala.collection.mutable.Map

import scala.collection.mutable.Map 
val university2 = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University") 
university2("XMU") = "Ximan University" //更新已有元素的值 
university2("FZU") = "Fuzhou University" //添加新元素 
university2 + = ("SDU"->"Shandong University","WHU"->"Wuhan University") //同时添加两个新元素

7.迭代器

迭代器不是一个集合，而是提供了按顺序访问集合元素的数据结构，包含两个基本操作：next和hasNext

• next：返回迭代器的下一个元素
• hasNext：检测是否还有下一个元素

val iter = Iterator("Hadoop","Spark","Scala") 
while (iter.hasNext) { 
    println(iter.next()) 
}