Scala入门笔记二

时间  2019-12-09
标签 scala 入门 笔记 栏目 Scala 繁體版
原文   原文链接

目录java

标识符

可用的字符

  • 处理括号类字符,分隔符以外,其余全部的可打印的ASCII字符,如字母,数字,下划线和美圆符号($)都可出如今Scala标识符中
  • 插入符包括了(,) [,] {,and}
  • 分隔符包括 ` ' " . ; ,等
  • Scala还容许在标识符中使用编码在 \u0020到\u007F之间的字符,如数学符号,想 / 和 < 这样的操做符字符以及其余的一些符号

不能使用保留字.数据库

普通标识符

  • 常见的标识符每每由字母或下划线开头,后面跟着一些字母,数字,下划线和$符
  • Scala容许使用Unicode格式的字符
  • $符在Scala内部会做为特定做用,尽可能不要使用
  • Scala编译器会将下划线以后,空格以前的全部字符视为标识符的一部分
  • 假如在下划线后输入了操做符,那么不容许在操做符后输入字母或数字
  • 假如某一标识符以操做符开头,那么后面的字符也必须是操做符字符

示例

val xyz_++= = 1

使用反引号定义标识符

能够经过反引号定义标识符,两个反引号内的任意长度的字符串即是定义的标识符.ide

def `test that addition work`= assert(1 + 1 = 2)

无参数方法

  • 对于不包含参数的方法,除了能够选择使用中缀调用或后缀调用方式以外,Scala还容许用户灵活决定是否使用括号
  • 定义无参方法时省略了括号,那么在调用这些方法时必须省略括号
  • 定义无参方法时添加了空括号,那么调用该方法时能够选择省略或保留括号

几个等价表达式

List(1, 2, 3, 4).filter((i: Int) => isEven(i)).foreach((i: Int) => println(i))
List(1, 2, 3, 4).filter(i => isEven(i)).foreach(i => println(i))
List(1, 2, 3, 4).filter(isEven).foreach(println)
List(1, 2, 3, 4) filter isEven foreach println

优先级规则

1. 全部字母
2. |
3. ^
4. &
5. < >
6. = !
7. :
8. + -
9. * / %
10. 其余特殊字符
  • 全部操做符都是方法
  • 并非全部方法都是左结合
  • 任何名字以冒号(:)结尾的方法均与其右边的对象绑定

cons操做

  • cons是constructor的缩写
  • cons操做指经过::方法将某一元素放置到列表前面

示例

scala> val list = List('c', 'd')
list: List[Char] = List(c, d)

scala> 'a' :: list
res1: List[Char] = List(a, c, d)

scala> val list = List('c', 'd')
list: List[Char] = List(c, d)

scala> 'b' :: list
res2: List[Char] = List(b, c, d)

scala> list.::('a')
res3: List[Char] = List(a, c, d)

scala> 'a' :: list
res4: List[Char] = List(a, c, d)

scala> 'b' :: list
res5: List[Char] = List(b, c, d)

注意:this

  • 'a' :: list 等价于 list.::('a')编码

  • 不能使用该方法重复插入多个字符es5

if语句

  • Scala的if语句能够向Java中同样使用scala

    if (2 + 2 = 5) {
    println("if")
} else if (2 + 2 = 3) {
    println("else if")
} else {
    println("else")
}

  • Scala中的if语句是有返回值的. 能够将if表达式的结果值赋值给其余变量. 如下面代码为例.code

    val configFile = new java.io.File("someFile.txt")

val configFilePath = if (configFile.exists()) {
    configFile.getAbsolutePath()
} else {
    configFile.createNewFile()
    configFile.getAbsolutePath()
}

    if语句返回值的类型也被称为全部条件分支的最小上界类型,也就是与每条each子句可能返回值类型最接近的父类型.在上面例子中,configFilePath 是if表达式的结果值,该if表达式将执行文件不存在的条件分支(假定),并返回新建立文件的绝对路径.将if语句的返回值赋予变量configFilePath .orm

Scala不支持三元表达式对象

循环

for推导式

for循环

示例

代码
val list = List("A", "B", "C")
  
for (item <- list)
    println(item)
输出
A
B
C

生成器表达式

  • 像item <- list这样的表达式被称为生成器表达式
  • 该表达式会基于集合生成单独的数值
  • 左箭头操做符(<-)用于对象列表这样的集合进行遍历

保护式: 筛选元素

  • for语句中能够加入if表达式来筛选元素,这些表达式被称为保护式(guard)

示例

代码
val list = List("ABC", "CDE", "EFG")

for (item <- list
    if item.contains("C")
    )
  println(item)
输出
ABC
CDE

添加多个保护式

示例
val list = List("ABC", "BCD", "CDE")
  
for (item <- list
   if item.contains("B")
   if !item.startsWith("A")
    )
  println(item)
 
for (item <- list
   if item.contains("B") && !item.startsWith("A")
    )
  println(item)
输出
BCD
BCD
  • 分别为两个for循环的输出

Yielding

  • 使用yielding关键字能在for表达式中生成新的集合

示例

代码
val list = List("ABC", "BCD", "CDE")
val filterItems =  for {item <- list
    if item.contains("B")
    if !item.startsWith("A")
    } yield item
filterItems
运行
scala> val list = List("ABC", "BCD", "CDE")
list: List[String] = List(ABC, BCD, CDE)

scala> val filterItems =  for {item <- list
     | if item.contains("B")
     |  if !item.startsWith("A")
     | } yield item
filterItems: List[String] = List(BCD)

扩展做用域与值定义

  • 可以在for表达式中的最初部分定义值,并可在之后的表达式中使用该值

示例

代码
val list = List("abc", "bcd", "cde")
  
val upcaseItems = for {
    item <- list
    upcaseItem = item.toUpperCase()
} yield upcaseItem
运行
scala> val list = List("abc", "bcd", "cde")
list: List[String] = List(abc, bcd, cde)

scala>
     | val upcaseItems = for {
     | item <- list
     |     upcaseItem = item.toUpperCase()
     | } yield upcaseItem
upcaseItems: List[String] = List(ABC, BCD, CDE)

while循环

示例

while (表达式) {
    do something
}

do...while循环

示例

var count = 0
do {
    count += 1
} while(count < 10)

条件操做符

操做符 操做
&& 和操做
|| 或操做
> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 等于
!= 不等于

  • && 和 || 是短路操做符

  • 在Java中== 只会对对象引用进行比较, 调用equals来比较字段值; Scala使用== 符执行逻辑上的相等检查. 即调用equals方法进行判断.

    public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public boolean equals(Object obj) {
        return true;
    }

    public static void main(String args[]) {
        Person p1 = new Person("sun", 20);
        Person p2 = new Person("li", 20);
        System.out.println(p1 == p2);
    }
}
// 输出:
false
    class Person(var name: String, var age: Int) {
    override def equals(obj: scala.Any): Boolean = true
}

val p1 = new Person("sun", 20)
val p2 = new Person("sun", 20)

println(p1 == p2)

// 输出:
true

    ​

使用try...catch...final子句

  • Scala使用模式匹配来捕获异常, 而Java使用单独的catch子句来捕获各个异常
  • 使用case NonFatal(ex) => ... 子句使用scala.util.control.NonFatal 匹配了全部的非致命性异常
  • 经过编写throw new MyBadException(...) 抛出异常
  • 若是自定义异常是一个case类,那么抛出异常时能够省略new关键字

实例

try {
    ...
} catch {
    case NonFatal(ex) => println(s"Non fatal exception! $ex")
    case ...
} finally {
    ...
}

惰性赋值

  • 惰性赋值是与传名参数相关的技术
  • 若是但愿以延迟的方式初始化某值, 而且表达式不会被重复计算, 则须要使用惰性赋值
  • 常见应用场景
    • 因为表达式执行代价昂贵(好比打开一个数据库链接), 但愿能推迟该操做, 直到确实须要表达式结果时才执行它
    • 为了缩短模块启动时间, 能够将当前不须要的某些工做推迟执行
    • 为了确保对象中其余字段的初始化过程能优先执行, 须要将某些字段惰性化

示例

object ExpensiveResource {
    lazy val resource: Int = init()
    def init(): Int = {
        // 某些代价昂贵的操做
        0
    }
}
  • lazy关键字意味着求值过程会被推迟,只有须要时才会执行计算
  • 首次使用惰性值时, 初始化代码才会被执行一次, 这种只能执行一次的计算对于可变字段而言没有任何意义.所以lazy关键字不能修饰var变量
  • 经过**保护式来实现惰性值

枚举

  • Scala经过在标准库中专门定义Enumeration类实现枚举

示例一

代码

// file: enum.scala
object Breed extends Enumeration {
    type Breed  = Value
    val doberman    = Value("Doberman Pinscher")
    val yorkie      = Value("Yorkshire Terrier")
    val scottie     = Value("Scottish Terrier")
    val dane        = Value("Great Dane")
    val portie      = Value("Portuguese Water Dog")
}

import Breed._

println("ID\tBreed")
for (breed <- Breed.values) println(s"${breed.id}\t$breed")

println("\nJust Terriers:")
Breed.values filter (_.toString.endsWith("Terrier")) foreach println

def isTerrier(b: Breed) = b.toString.endsWith("Terrier")

println("\nJust Terriers:")
Breed.values filter isTerrier foreach println

运行

scala enum.scala

输出

ID      Breed
0       Doberman Pinscher
1       Yorkshire Terrier
2       Scottish Terrier
3       Great Dane
4       Portuguese Water Dog

Just Terriers:
Yorkshire Terrier
Scottish Terrier

Just Terriers:
Yorkshire Terrier
Scottish Terrier

可插入字符串

下面是一个简单示例:

val name = "Buck Trends"
println(s"Hello, $name")

格式化

下面是几个对可插入字符串进行格式化的示例.

scala> val gross = 100000F
gross: Float = 100000.0

scala> val net = 64000F
net: Float = 64000.0

scala> val percent = (net / gross) * 100
percent: Float = 64.0

scala> println(f"$$${gross}%.2f vs. $$${net}%.2f or ${percent}%.1f%%")
$100000.00 vs. $64000.00 or 64.0%

scala> val s = "%02d: name = %s".format(5, "Dean Wampler")
s: String = 05: name = Dean Wampler

// 原生插入器
scala> val name = "Dean Wampler"
name: String = Dean Wampler

scala> s"123\n$name\n456"
res1: String =
123
Dean Wampler
456

scala> raw"123\n$name\n456"
res2: String = 123\nDean Wampler\n456
  • 使用$$ 打印一个$
  • 使用%% 打印一个%
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程