IO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* IO
* Scala进行文件写操作,直接用的都是java中的I/O类(java.io.File)
*/
object TestIO {
def main(args: Array[String]): Unit = {
// 写操作
// val writer = new PrintWriter(new File("test.txt" ))
// writer.write(" 测试成功")
// writer.close()
// 从屏幕上读取用户输入
// print("请输入您的姓名:")
// val line = StdIn.readLine()
// println(line+"先生,欢迎您~")
// 从文件上读取内容
Source.fromFile("test.txt").foreach{
print
}
}
}

迭代器(Iterator)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
* Iterator(迭代器)
* Scala Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法。
* 迭代器it的两个基本操作是 next和hasNext。
* 调用it.next()会返回迭代器的下一个元素,并且更新迭代器的状态。
* 调用it.hasNext()用于检测集合中是否还有元素。
* 让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环
*/
object TestIterator {
def main(args: Array[String]): Unit = {
val it = Iterator("a","b","c")
// 迭代输出
while(it.hasNext)
println(it.next())
// 最大值,最小值,只能同时获得其中一个,最大值或最小值
val num = Iterator(3,7,4,2,9)
println(num.min)
// println(num.max)
// 迭代器的长度,两种方式
val it2 = Iterator(1,1,2)
println(it2.size)
// println(it2.length)
}
}

模式匹配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/**
* 模式匹配
* match对应Java里的switch,但是写在选择器表达式之后。即: 选择器 match {备选项}。
* match 表达式通过以代码编写的先后次序尝试每个模式来完成计算,
* 只要发现有一个匹配的case,剩下的case不会继续匹配
*/
object TestMatch {
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int"
// 表示默认的全匹配备选项,类似switch中的default
case _ => "many"
}
def main(args: Array[String]): Unit = {
println(matchTest(1))
// 样例类
// 一个类被声明为样例类,主构造器的所有参数会被编译成类的属性
// Scala 会自动给样例类生成伴生对象,以及实现apply和unapply方法等以及其他方法
case class Person(name: String, age: Int)
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)
for (person <- List(alice, bob, charlie)) {
person match {
case Person("Alice", 25) => println("Hi Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) =>
println("Age: " + age + " year, name: " + name + "?")
}
}
}
}

闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 闭包
*/
object TestMultiplier {
def main(args: Array[String]): Unit = {
// 闭包是一个函数,返回值依赖于声明在函数外部的一个或多个变量
var a = 3
val multiplier = (i:Int) => i*a
println(multiplier(1))
println(multiplier(2))
println(multiplier(3))
}
}

选项(Option)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
* Option
* Scala Option(选项)类型用来表示一个值是可选的(有值或无值)。
* Option[T] 是一个类型为 T 的可选值的容器:如果值存在,Option[T] 就是一个Some[T] ,
* 如果不存在,Option[T] 就是对象None
*/
object TestOption {
def main(args: Array[String]): Unit = {
// 声明
val a:Option[Int] = Some(1)
val b:Option[Int] = None
// 如果有值的话,可以通过get方法获取值
println(a.get)
// getOrElse()方法
// 有值就直接获取值,没有值就使用默认值
println(a.getOrElse(10))
println(b.getOrElse(10))
// isEmpty()方法
// 检测元组中的元素是否为none
println(a.isEmpty)
println(b.isEmpty)
}
}

正则表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* 正则表达式
*/
object TestRegex {
def main(args: Array[String]): Unit = {
// 使用String类的r()方法构造了一个Regex对象
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
// 使用 findFirstIn 方法找到首个匹配项
println(pattern.findFirstIn(str).get)
// 使用 findAllIn 方法查找所有匹配项,使用逗号连接返回结果
println(pattern.findAllIn(str).mkString("|"))
// 使用 replaceFirstIn( ) 方法来替换第一个匹配项
val pattern2 = "(S|s)cala".r
println(pattern2.replaceFirstIn(str,"Java"))
// 使用 replaceAllIn( ) 方法替换所有匹配项
println(pattern2.replaceAllIn(str,"Java"))
// 正则表达式
val pattern3 = new Regex("[a-zA-Z][s]")
println(pattern3.findFirstIn(str).get)
}
}

最后更新: 2018年10月08日 18:35

原始链接: https://www.lousenjay.top/2018/10/08/Scala入门详解(四)/