Scala学习笔记（2）—— Scala 基础（1）
1 Scala 基础
1.1 声明变量
object HelloScala {
def main(args: Array[String]) {
//使用 val 定义的变量值是不可以改变的，相当于 java 里的final
val a=1
//使用 var 定义的变量是可变项，在Scala中鼓励使用
var s="mike"
// scala 编译器会自动推断变量的类型，必要的时候可以指定类型
val str:String = "Helllo"
}
}
1.2 常用类型
Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型
1.3 条件表达式
object HelloScala {
def main(args: Array[String]) {
val x = 1
val y = if (x > 0) 1 else -1
println(y)
//支持混合类型的表达式
val z = if (x > 1) 1 else "error"
println(z)
//如果缺失else ,相当于 else()
val m = if (x > 2) 1
println(m)
//在Scala中每个表达式都有值，scala中有个Unit类，写做(),相当于java中的void
val n = if (x > 2) 1 else ()
println(n)
val k = if (x < 0) 0
else if (x >= 1) 1 else -1
println(k)
}
}
1.4 块表达式
package helloscala
object HelloScala {
def main(args: Array[String]) {
val x=0
// {} 可以包含一系列的表达式，块中最后一个表达式的值就是快的值
val result ={
if(x<0){
-1
}else if(x >= -1){
1
}else{
"error"
}
}
//result 的值就是块表达式的结果
println(result)
}
}
1.5 循环
在scala中有for循环和while循环，用for循环比较多
for循环语法结构：for (i <- 表达式/数组/集合)
object HelloScala {
def main(args: Array[String]) {
//for(i <- 表达式)，1 to 10 返回 一个区间
for (i <- 1 to 10)
println(i)
val arr = Array("a", "b", "c")
for (i <- arr)
println(i)
//高级 for 循环
//每个迭代生成器都可以带一个条件，注意：if 前面没有分号
for (i <- 1 to 3; j <- 1 to 3 if i != j)
print((10 * i + j) + " ")
println()
// for 推导式，如果 for 循环以 yield开始，则该循环会构建一个集合
//每次迭代生成集合中的一个值
val v = for (i <- 1 to 10) yield i * 10
println(v)
}
}
1
2
3
4
5
6
7
8
9
10
a
b
c
12 13 21 23 31 32
Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
Process finished with exit code 0
1.6 调用方法和函数
Scala中的+ - * / %等操作符的作用与Java一样，位操作符 & | ^ >> <<也一样。只是有
一点特别的：这些操作符实际上是方法。例如：
a + b
是如下方法调用的简写：
a.+(b)
a 方法 b可以写成 a.方法(b)
1.7 定义方法和函数
1.7.1 定义方法
方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型
1.7.2 定义函数
1.7.3 方法和函数的区别
在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作
object HelloScala {
//定义一个方法，参数是一个函数
def m1(f: (Int, Int) => Int): Int = {
f(2, 6)
}
//定义一个函数
val f1 = (x: Int, y: Int) => x + y
val f2 = (m: Int, n: Int) => m * n
def main(args: Array[String]) {
val r1 = m1(f1)
println(r1)
val r2 = m1(f2)
println(r2)
}
}
8
12
Process finished with exit code 0
1.7.4 将方法转换为函数（神奇的下划线）
2 数组
2.1 定长数组和变长数组
package helloscala
import scala.collection.mutable.ArrayBuffer
object ArrayDemo {
def main(args: Array[String]): Unit = {
//初始化一个长度为 8 的定长数组，其元素均为0
val arr1 = new Array[Int](8)
//直接打印，内容为数组的 hashcode
println(arr1)
//将数组转换为数组缓冲，就可以看到内容
println(arr1.toBuffer)
//如果没有new,相当于调用了数组的 apply 方法，直接为数组赋值
val arr2= Array[Int](10)
println(arr2.toBuffer)
val arr3= Array("hello","world")
println(arr3(1))
/*
* 变长数组
*
* */
val ab = ArrayBuffer[Int]()
//向数组尾部添加一个元素
ab += 1
//追加多个元素
ab += (2,3,4,5)
//追加一个数组
ab ++= Array(6,7)
//追加一个数组缓冲
ab ++= ArrayBuffer(8,9)
println(ab)
//在数组某个位置插入元素
ab.insert(0,-100,-200)
println(ab)
//在数组某个位置删除元素
ab.remove(8,2)
println(ab)
}
}
[[email protected]
ArrayBuffer(0, 0, 0, 0, 0, 0, 0, 0)
ArrayBuffer(10)
world
ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
ArrayBuffer(-100, -200, 1, 2, 3, 4, 5, 6, 7, 8, 9)
ArrayBuffer(-100, -200, 1, 2, 3, 4, 5, 6, 9)
Process finished with exit code 0
2.2 遍历数组
- 增强 for 循环
- until会生成脚标，0 until 10 包含0不包含10
package helloscala
object ForArrayDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1,2,3,4,5)
for( i <- arr)
print(i+" ")
println()
for( i <- (0 until arr.length).reverse)
print(arr(i)+" ")
}
}
1 2 3 4 5
5 4 3 2 1
Process finished with exit code 0
2.3 数组转换
yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变
package helloscala
object ArrayYieldDemo {
def main(args: Array[String]): Unit = {
val arr = Array(1, 2, 3, 4, 5, 6)
//将偶数取出乘以10，再生成一个新的数组
val res = for (e <- arr if e % 2 == 0) yield e * 10
println(res.toBuffer)
/*
* 更高级的写法
* filter 是过滤，接收一个返回值为 boolean 的函数
* map 相当于将数组中的每一个元素取出来
* */
val r = arr.filter(_ % 2 == 0).map(_ * 10)
println(r.toBuffer)
}
}
ArrayBuffer(20, 40, 60)
ArrayBuffer(20, 40, 60)
2.4 数组的常用算法
3 映射
在Scala中，把哈希表这种数据结构叫做映射
3.1 构建映射
3.2 获取和修改映射中的值
如果映射中有值，返回映射中的值，没有返回默认值
注意：在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变
注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型
4 元组
映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。
4.1 创建元组
4.2 获取元组中的值
获取元组中的元素可以使用下划线加角标，注意：元组中的角标从 1 开始
4.3 将对偶的集合转换成映射
4.4 拉链操作
zip 命令可以将多个值绑定在一起
5 集合
- Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质
- 在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）
5.1 序列
5.1.1 不可变的序列 import scala.collection.immutable._
在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
package helloscala
object ImmutListDemo {
def main(args: Array[String]): Unit = {
//创建一个不可变的集合
val lst1 = List(1,2,3)
println("lst1: "+ lst1)
//将0 插入到 lst1 的前面生成一个新的 List
val lst2 = 0::lst1
println("lst2: "+ lst2)
val lst3 = lst1.::(0)
println("lst3: "+ lst3)
val lst4 = 0 +:lst1
println("lst4: "+ lst4)
val lst5 = lst1.+:(0)
println("lst5: "+ lst5)
//将一个元素添加到lst1的后面产生一个新的集合
val lst6 = lst1 :+ 3
println("lst6: "+ lst6)
val lst0 = List(4,5,6)
println("lst0: "+ lst0)
//将2个list合并成一个新的List
val lst7 = lst1 ++ lst0
println("lst7: "+ lst7)
//将lst1 插入到 lst0 前面生成一个新的集合
val lst8 = lst1 ++: lst0;
println("lst8: "+ lst8)
//将 lst0 插入到 lst1 前生成一个新的集合
val lst9 = lst1.:::(lst0)
println("lst9: "+ lst9)
}
}
lst1: List(1, 2, 3)
lst2: List(0, 1, 2, 3)
lst3: List(0, 1, 2, 3)
lst4: List(0, 1, 2, 3)
lst5: List(0, 1, 2, 3)
lst6: List(1, 2, 3, 3)
lst0: List(4, 5, 6)
lst7: List(1, 2, 3, 4, 5, 6)
lst8: List(1, 2, 3, 4, 5, 6)
lst9: List(4, 5, 6, 1, 2, 3)
Process finished with exit code 0
5.1.2 可变的序列import scala.collection.mutable._
package helloscala
import scala.collection.mutable.ListBuffer
object MutListDemo {
def main(args: Array[String]): Unit = {
//可变列表
val lst0 = ListBuffer[Int](1, 2, 3)
//空的可变列表
val lst1 = new ListBuffer[Int]
lst1 += 4
lst1.append(5)
println("lst1: " + lst1)
//将lst1中的元素加到 lst0 中，注意：没有生成新的集合
lst0 ++= lst1
println("lst0 "+ lst0)
val lst2 = lst0 ++ lst1
println("lst2: "+ lst2)
//将元素追加到lst0 的后面生成一个新的集合
val lst3 = lst0 :+ 5
println("lst3: "+ lst3)
}
}
lst1: ListBuffer(4, 5)
lst0 ListBuffer(1, 2, 3, 4, 5)
lst2: ListBuffer(1, 2, 3, 4, 5, 4, 5)
lst3: ListBuffer(1, 2, 3, 4, 5, 5)
5.2 Set
5.2.1 不可变 Set
package helloscala
import scala.collection.immutable.HashSet
object ImmutSetDemo {
def main(args: Array[String]): Unit = {
val set1 = new HashSet[Int]()
//将元素和set1 合并生成一个新的 set,原有 set 不变
val set2 = set1 + 4
println("set2: "+ set2)
//set中的元素不能重复
val set3 = set1 ++ Set(5, 6, 7)
println("set3: "+set3)
val set0 = Set(1, 3, 4) ++ set2
println("set0: "+ set0)
println(set0.getClass)
}
}
set2: Set(4)
set3: Set(5, 6, 7)
set0: Set(1, 3, 4)
class scala.collection.immutable.Set$Set3
5.2.2 可变 Set
package helloscala
import scala.collection.mutable
object MutSetDemo{
def main(args: Array[String]): Unit = {
val set1 = new mutable.HashSet[Int]()
set1+=2
set1.add(4)
set1 ++= Set(1,3,5)
println("set1:" + set1)
//删除一个元素
set1 -= 5
set1.remove(2)
println(set1)
}
}
set1:Set(1, 5, 2, 3, 4)
Set(1, 3, 4)
5.3 Map
package helloscala
import scala.collection.mutable
object MutMapDemo {
def main(args: Array[String]): Unit = {
val map1 = new mutable.HashMap[String,Int]()
map1("hadoop")=1
println(map1)
map1 += (("hadoop",2))
println(map1)
map1.put("storm",3)
println(map1)
//map中移除元素
map1 -= "spark"
map1.remove("hadoop")
println(map1)
}
}
Map(hadoop -> 1)
Map(hadoop -> 2)
Map(hadoop -> 2, storm -> 3)
Map(storm -> 3)