Scala的基本使用

@
目录

• Scala的基本使用
  
  
  
  • 一、基础语法
    
    
    
    • 1.1 变量
      
      
      
      • 1.1.1 var和val
        
      • 1.1.2 自动类型推断
        
      
      
    • 1.2 数据类型
      
      
      
      • 1.2.1 基础数据类型
        
      • 1.2.2 增强数据类型
        
      
      
    • 1.3 操作符
      
    
    
  • 二、流程控制
    
    
    
    • 2.1 if表达式
      
    • 2.2 语句终结符
      
    • 2.3 循环
      
      
      
      • 2.3.1 for循环
        
      • 2.3.2 这里面的to可以换成until
        
      • 2.3.3 for循环针对字符串还可以用
        
        
        
        • 2.3.4 注意花括号
          
        
        
      • 2.3.5 while循环
        
      
      
    • 2.4 高级for循环
      
      
      
      • 2.4.1 if守卫模式
        
      • 2.4.2 for推导式
        
      
      
    
    
  • 三、Scala的集合体系
    
    
    
    • 3.1 集合体系
      
    • 3.2 集合分类
      
    • 3.3Set集合
      
      
      
      • 3.3.1创建集合
        
        
        
        • 不可变集合
          
        • 可变集合
          
        
        
      • 3.3.2 HashSet
        
      • 3.3.3LinkedHashSet
        
      • 3.3.4 SortedSet
        
      
      
    • 3.4 List集合
      
      
      
      • 3.4.1 创建
        
      • 3.4.2 获取数组元素
        
      
      
    • 3.5 ListBuffer
      
      
      
      • 3.5.1 动态增加或者移除元素
        
      • 3.5.2 遍历ListBuffer
        
      
      
    • 3.6 Map集合
      
      
      
      • 3.6.1创建Map
        
        
        
        • 创建一个不可变的Map
          
        • 创建一个可变的Map
          
        • 还有一种创建Map的简易方式，这种方式创建的是不可变Map
          
        
        
      • 3.6.2 查询
        
        
        
        • 一般查询
          
        • key不存在处理
          
        • getOrElse函数
          
        
        
      • 3.6.3 修改
        
        
        
        • 更新map中的元素
          
        • 增加多个元素
          
        • 移除元素
          
        
        
      • 3.6.4 遍历
        
        
        
        • 遍历map的entrySet
          
        • 遍历map的key
          
        • 遍历map的value
          
        
        
      • 3.6.5 最后看一下Map的几个子类
        
      
      
    • 3.7 Array
      
    • 3.8 ArrayBuffer
      
      
      
      • 3.8.1 初始化
        
      • 3.8.2 添加元素
        
      • 3.8.3 指定位置插入元素
        
      • 3.8.4 移除元素
        
      • 3.8.5 Array与ArrayBuffer的转换
        
      
      
    • 3.9 数组常见操作
      
      
      
      • 3.9.1 遍历
        
      • 3.9.2 求和、求最大值
        
      • 3.9.3 数组排序
        
      
      
    • 3.10 Tuple
      
    • 3.11 总结
      
      
      
      • 3.11.1 可变集合
        
      • 3.11.2 不可变集合
        
      • 3.11.3 可变+不可变集合
        
      • 3.11.4 还有两个编外人员：
        
      
      
    
    
  • 四、Scala中函数的使用
    
    
    
    • 4.1 函数的定义
      
      
      
      • 4.1.1 定义函数
        
      • 4.1.2 函数的返回值
        
      • 4.1.3 区别
        
      • 4.1.4 单行函数
        
      • 4.1.5 多行函数
        
      
      
    • 4.2 函数的参数
      
      
      
      • 4.2.1 默认参数
        
        
        
        • scala实现
          
        • java实现
          
        
        
      • 4.2.2 带名参数
        
      • 4.2.3 可变参数
        
      
      
    • 4.3 过程-特殊的函数
      
      
      
      • 4.3.1 定义
        
      • 4.3.2 写法
        
      
      
    • 4.4 lazy
      
      
      
      • 4.4.1 使用场景
        
      
      
    
    
  
  

Scala的基本使用

一、基础语法

1.1 变量

1.1.1 var和val

Scala中的变量分为两种：
可变var：可以随时修改var声明的变量的值
不可变val：val声明的变量，值不能被修改，否则会报错：error: reassignment to val

1. scala> var a = 1
2. a: Int = 1
3. scala> a = 2
4. a: Int = 2
5. scala> val b = 1
6. b: Int = 1
7. scala> b = 2
8. <console>:8: error: reassignment to val
9.        b = 2
10.        ^

复制代码

1.1.2 自动类型推断

无论声明val变量，还是声明var变量，都可以手动指定变量的类型；如果不指定，Scala会自动根据值，进行类型推断

1. scala> val c = 1
2. c: Int = 1
4. scala> val c: Int = 1
5. c: Int = 1

复制代码

1.2 数据类型

1.2.1 基础数据类型

Byte、Char、Short、Int、Long、Float、Double、Boolean
1.2.2 增强数据类型

StringOps、RichInt、RichDouble、RichChar
增强版数据类给基本数据类型增加了上百种增强的功能
1.3 操作符

Scala的算术操作符与Java的算术操作符没有什么区别

比如+、-、*、/、%等，以及&、|、^、>>、 18) 1 else 0age: Int = 20res0: Int = 1[/code]2.3 循环

2.3.1 for循环

for循环本身的特性就没什么好说的了，直接上案例

1. scala> val age = 20; if(age > 18) 1 else 0
2. age: Int = 20
3. res0: Int = 1

复制代码

2.4 高级for循环

2.4.1 if守卫模式

if守卫模式，假设我们想要获取1~10之间的所有偶数，使用普通的for循环，需要把每一个数字都循环出来，然后判断是否是偶数
如果在for循环里面使用if守卫，可以在循环的时候就执行一定的逻辑，判断数值是否是偶数

1. scala> :paste
2. // Entering paste mode (ctrl-D to finish)
4. val n = 10
5. for(i <- 1 to n)
6. println(i)
8. // Exiting paste mode, now interpreting.
10. 1
11. 2
12. 3
13. 4
14. 5
15. 6
16. 7
17. 8
18. 9
19. 10
20. n: Int = 10

复制代码

可变集合

1. scala> :paste
2. // Entering paste mode (ctrl-D to finish)
4. val n = 10
5. for(i <- 1 until 10)
6. println(i)
8. // Exiting paste mode, now interpreting.
10. 1
11. 2
12. 3
13. 4
14. 5
15. 6
16. 7
17. 8
18. 9
19. n: Int = 10

复制代码

3.3.2 HashSet

HashSet集合分为 可变和不可变集合

1. scala> for(c <- "hello scala") println(c)
2. h
3. e
4. l
5. l
6. o
8. s
9. c
10. a
11. l
12. a

复制代码

3.3.3LinkedHashSet

LinkedHashSet 只有可变的，没有不可变的

1. scala> :paste
2. // Entering paste mode (ctrl-D to finish)
4. for(i <- 1 to 5)
5. println(i)
6. println("hehe")
8. // Exiting paste mode, now interpreting.
10. 1
11. 2
12. 3
13. 4
14. 5
15. hehe

复制代码

3.3.4 SortedSet

SortedSet分为 可变和不可变集合
SortedSet集合中的元素是按照元素的字典顺序排序的

1. scala> :paste
2. // Entering paste mode (ctrl-D to finish)
4. for(i <- 1 to 5)
5. {
6. println(i)
7. println("hehe")
8. }
10. // Exiting paste mode, now interpreting.
12. 1
13. hehe
14. 2
15. hehe
16. 3
17. hehe
18. 4
19. hehe
20. 5
21. hehe

复制代码

3.4 List集合

List代表一个不可变的列表
3.4.1 创建

1. scala> :paste
2. // Entering paste mode (ctrl-D to finish)
4. var n = 10
5. while(n>0){
6. println(n)
7. n -= 1
8. }
10. // Exiting paste mode, now interpreting.
12. 10
13. 9
14. 8
15. 7
16. 6
17. 5
18. 4
19. 3
20. 2
21. 1
22. n: Int = 0

复制代码

3.4.2 获取数组元素

head：表示获取List中的第一个元素
tail：表示获取List中第一个元素之后的所有元素
那其实head和tail就可以获取list中的所有元素了

1. scala> for(i <- 1 to 10 if i % 2 == 0) println(i)
2. 2
3. 4
4. 6
5. 8
6. 10

复制代码

通过::操作符，可以将head和tail的结果合并成一个List

1. scala> for(i <- 1 to 10) yield i *2
2. res16: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

复制代码

3.5 ListBuffer

3.5.1 动态增加或者移除元素

1. scala> val s = Set(1,2,3)
2. s: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

复制代码

3.5.2 遍历ListBuffer

1. scala> val s = scala.collection.mutable.Set(1,2,3)
2. s: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
4. scala> s += 4
5. res34: s.type = Set(1, 2, 3, 4)

复制代码

创建一个可变的Map

1. scala> val s = new scala.collection.mutable.HashSet[Int]()
2. s: scala.collection.mutable.HashSet[Int] = Set()
4. scala> s +=1
5. res35: s.type = Set(1)
7. scala> s +=2
8. res36: s.type = Set(1, 2)
10. scala> s +=5
11. res38: s.type = Set(1, 5, 2)

复制代码

还有一种创建Map的简易方式，这种方式创建的是不可变Map

1. scala> val s = new scala.collection.mutable.LinkedHashSet[Int]()
2. s: scala.collection.mutable.LinkedHashSet[Int] = Set()
4. scala> s +=1
5. res42: s.type = Set(1)
7. scala> s +=2
8. res43: s.type = Set(1, 2)
10. scala> s +=5
11. res44: s.type = Set(1, 2, 5)

复制代码

3.6.2 查询

一般查询

1. scala> val s = scala.collection.mutable.SortedSet[String]()
2. s: scala.collection.mutable.SortedSet[String] = TreeSet()
4. scala> s +=("c")
5. res45: s.type = TreeSet(c)
7. scala> s +=("a")
8. res46: s.type = TreeSet(a, c)
10. scala> s +=("b")
11. res47: s.type = TreeSet(a, b, c)

复制代码

key不存在处理

获取指定key对应的value，如果key不存在，会报错
使用if-else语句，如果指定的key不存在，则返回一个默认值

1. scala>  val l = List(1, 2, 3, 4)
2. l: List[Int] = List(1, 2, 3, 4)

复制代码

getOrElse函数

map中还有一个getOrElse函数
建议后期从map中获取数据都使用这个getOrElse函数

1. scala> l.head
2. res49: Int = 1
4. scala> l.tail
5. res51: List[Int] = List(2, 3, 4)

复制代码

3.6.3 修改

更新map中的元素

1. scala> l.head :: l.tail
2. res52: List[Int] = List(1, 2, 3, 4)

复制代码

增加多个元素

1. scala> val lb = scala.collection.mutable.ListBuffer[Int]()
2. lb: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
4. scala> lb +=1
5. res56: lb.type = ListBuffer(1)
7. scala> lb +=2
8. res57: lb.type = ListBuffer(1, 2)
10. scala> lb +=5
11. res58: lb.type = ListBuffer(1, 2, 5)
13. scala> lb -=5
14. res59: lb.type = ListBuffer(1, 2)

复制代码

移除元素

1. scala> for(i <- lb) println(i)
2. 1
3. 2

复制代码

3.6.4 遍历

遍历map的entrySet

1. scala> val ages = Map("jack"->30,"tom"->25,"jessic"->23)
2. ages: scala.collection.immutable.Map[String,Int] = Map(jack -> 30, tom -> 25, jessic -> 23)
4. scala> ages("jack")
5. res100: Int = 30

复制代码

LinkedHashMap是可变的

1. scala> val ages = scala.collection.mutable.Map("jack"->30,"tom"->25,"jessic"->23)
2. ages: scala.collection.mutable.Map[String,Int] = Map(jessic -> 23, jack -> 30, tom -> 25)
4. scala> ages("jack")
5. res101: Int = 30

复制代码

3.7 Array

Scala中Array的含义与Java中的数组类似，长度不可变,数组初始化后，长度就固定下来了，而且元素全部根据其类型进行初始化,可以直接使用Array()创建数组，元素类型自动推断
3.8 ArrayBuffer

Scala中ArrayBuffer与Java中的ArrayList类似，长度可变
ArrayBuffer：支持添加元素、移除元素
如果不想每次都使用全限定名，则可以预先导入ArrayBuffer类

1. scala> val ages = Map(("jack",30),("tom",25),("jessic"->23))
2. ages: scala.collection.immutable.Map[String,Int] = Map(jack -> 30, tom -> 25, jessic -> 23)

复制代码

3.8.1 初始化

使用ArrayBuffer()的方式可以创建一个空的ArrayBuffer

1. scala> val ages = scala.collection.mutable.Map(("jack",30),("tom",25),("jessic"->23))
2. ages: scala.collection.mutable.Map[String,Int] = Map(jessic -> 23, jack -> 30, tom -> 25)
4. scala> val age = ages("jack")
5. age: Int = 30
7. scala> val age = ages("jack1")
8. java.util.NoSuchElementException: key not found: jack1

复制代码

3.8.2 添加元素

使用+=操作符，可以添加一个元素，或者多个元素
b += 1 或者 b += (2, 3, 4, 5)

1. scala> val age = if (ages.contains("jack1")) ages("jack1") else 0
2. age: Int = 0

复制代码

3.8.3 指定位置插入元素

使用insert()函数可以在指定位置插入元素，但是这种操作效率很低，因为需要移动指定位置后的所有元素
向3号角标的位置添加一个元素 30

1. scala> val age = ages.getOrElse("jack1", 0)
2. age: Int = 0
4. scala> val age = ages.getOrElse("jack", 0)
5. age: Int = 30

复制代码

3.8.4 移除元素

使用remove()函数可以移除指定位置的元素
移除1号角标的元素

1. scala> ages("jack") = 31
3. scala> ages
4. res104: scala.collection.mutable.Map[String,Int] = Map(jessic -> 23, jack -> 31, tom -> 25)

复制代码

3.8.5 Array与ArrayBuffer的转换

Array与ArrayBuffer可以互相进行转换
b.toArray：ArrayBuffer转Array
a.toBuffer：Array转ArrayBuffer
3.9 数组常见操作

3.9.1 遍历

1. scala> ages += ("hehe" -> 35, "haha" -> 40)
2. res105: ages.type = Map(hehe -> 35, jessic -> 23, jack -> 31, tom -> 25, haha -> 40)

复制代码

3.9.3 数组排序

1. scala> ages -= "hehe"
2. res106: ages.type = Map(jessic -> 23, jack -> 31, tom -> 25, haha -> 40)

复制代码

3.10 Tuple

Tuple：称之为元组，它与Array类似，都是不可变的，但与数组不同的是元组可以包含不同类型的元素
Tuple中的元素角标从 1  开始
目前 Scala 支持的元组最大长度为 22 ，对于更大长度可以使用集合或数组

1. scala> for ((key, value) <- ages) println(key + " " + value)
2. jessic 23
3. jack 31
4. tom 25
5. haha 40

复制代码

3.11 总结

3.11.1 可变集合

LinkedHashSet、ListBuffer、ArrayBuffer、LinkedHashMap
3.11.2 不可变集合

List、SortedMap
3.11.3 可变+不可变集合

Set、HashSet、SortedSet、Map、HashMap
3.11.4 还有两个编外人员：

Array、Tuple
Array：长度不可变，里面的元素可变
Tuple：长度不可变，里面的元素也不可变
四、Scala中函数的使用

4.1 函数的定义

4.1.1 定义函数

在Scala中定义函数需要使用 def 关键字，函数包括函数名、参数、函数体
4.1.2 函数的返回值

Scala要求必须给出函数所有参数的类型，但是函数返回值的类型不是必须的，因为Scala可以自己根据函数体中的表达式推断出返回值类型。
4.1.3 区别

函数中最后一行代码的返回值就是整个函数的返回值，不需要使用return，这一点与Java不同，java中函数的返回值是必须要使用return的
4.1.4 单行函数

scala> def sayHello(name: String) = print("Hello, " + name)
sayHello: (name: String)Unit
scala> sayHello("Scala")
Hello, Scala
4.1.5 多行函数

scala> :paste
// Entering paste mode (ctrl-D to finish)
def sayHello(name: String, age: Int) = {
  println("My name is "+name+",age is "+age)
age
}
// Exiting paste mode, now interpreting
sayHello: (name: String, age: Int)Int
scala> sayHello("Scala",18)
My name is Scala,age is 18
res120: Int = 18
4.2 函数的参数

4.2.1 默认参数

在Scala中，有时候我们调用某些函数时，不希望给出参数的具体值，而是希望使用参数自身默认的值，此时就需要在定义函数时使用默认参数。
如果给出的参数不够，则会从左往右依次应用参数。

1. scala> for (key <- ages.keySet) println(key)
2. jessic
3. jack
4. tom
5. haha

复制代码

scala实现

1. scala> for (value <- ages.values) println(value)
2. 23
3. 31
4. 25
5. 40

复制代码

java实现

1. scala> val ages = scala.collection.immutable.SortedMap("b" -> 30, "a" -> 15, "c" -> 25)
2. ages: scala.collection.immutable.SortedMap[String,Int] = Map(a -> 15, b -> 30, c -> 25)
4. scala> ages
5. res112: scala.collection.immutable.SortedMap[String,Int] = Map(a -> 15, b -> 30, c -> 25)

复制代码

4.2.2 带名参数

在调用函数时，也可以不按照函数定义的参数顺序来传递参数，而是使用带名参数的方式来传递。

1. scala> val ages = new scala.collection.mutable.LinkedHashMap[String, Int]()
2. ages: scala.collection.mutable.LinkedHashMap[String,Int] = Map()
4. scala> ages("b")=30
6. scala> ages("a")=15
8. scala> ages("c")=25
10. scala> ages
11. res116: scala.collection.mutable.LinkedHashMap[String,Int] = Map(b -> 30, a -> 15, c -> 25)

复制代码

4.2.3 可变参数

在Scala中，有时我们需要将函数定义为参数个数可变的形式，则此时可以使用变长参数来定义函数。

1. scala> import scala.collection.mutable.ArrayBuffer
2. import scala.collection.mutable.ArrayBuffer

复制代码

4.3 过程-特殊的函数

4.3.1 定义

定义函数时，如果函数体直接在花括号里面而没有使用=连接，则函数的返回值类型就是Unit，这样的函数称之为过程
过程通常用于不需要返回值的函数
4.3.2 写法

过程还有一种写法，就是将函数的返回值类型显式定义为Unit
比较一下这四种写法的区别
函数：

1. scala> val b = new ArrayBuffer[Int]()
2. b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

复制代码

过程：

1. scala> b += 1
2. res69: b.type = ArrayBuffer(1)
4. scala> b += (2, 3, 4, 5)
5. res70: b.type = ArrayBuffer(1, 2, 3, 4, 5)

复制代码

4.4 lazy

将一个变量声明为lazy，则只有在第一次使用该变量时，变量对应的表达式才会发生计算
4.4.1 使用场景

什么场景下需要使用lazy特性呢？
这种特性对于特别耗时的操作特别有用，比如打开文件这个操作。

1. scala> b.insert(3,30)
3. scala> b
4. res72: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 30, 4, 5)

复制代码

即使D://test.txt文件不存在，代码也不会报错，只有变量使用时才会报错，这就是lazy这个特性。

1. scala> b.remove(1)
2. res73: Int = 2
4. scala> b
5. res74: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 30, 4, 5)

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！