目录
Scala-变量、常量
1.变量
在程序运行过程中其值可能发生改变的量叫做变量（关键词 "var" 声明变量，可修改）。
2.常量
在程序运行过程中其值不会发生变化的量叫做常量（关键词 "val" 声明常量，不可修改）。
示例：
var myVar1 : String = "Jim"
var myVar1 : String = "Jason"
var myVal1 : String = "Jim"注：变量的类型在变量名之后等号之前声明。
Scala-内置运算符
1.算术运算符
假定变量 A 为 10，B 为 20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加号 | A + B 运算结果为 30 |
| - | 减号 | A - B 运算结果为 -10 |
| * | 乘号 | A * B 运算结果为 200 |
| / | 除号 | B / A 运算结果为 2 |
| % | 取余 | B % A 运算结果为 0 |
2.关系运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 | (A == B) 运算结果为 false |
| != | 不等于 | (A != B) 运算结果为 true |
| > | 大于 | (A > B) 运算结果为 false |
| < | 小于 | (A < B) 运算结果为 true |
| >= | 大于等于 | (A >= B) 运算结果为 false |
| <= | 小于等于 | (A <= B) 运算结果为 true |
3.逻辑运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑与 | (A && B) 运算结果为 false |
| || | 逻辑或 | (A || B) 运算结果为 true |
| ! | 逻辑非 | !(A && B) 运算结果为 true |
4.位运算符
位运算符用来对二进制位进行操作，~,&,|,^ 分别为取反，按位与与，按位与或，按位与异或运算。
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
| >>> | 无符号右移 | A >>>2 输出结果 15, 二进制解释: 0000 1111 |
5.赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算，指定右边操作数赋值给左边的操作数。 | C = A + B 将 A + B 的运算结果赋值给 C |
| += | 相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。 | C += A 相当于 C = C + A |
| -= | 相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。 | C -= A 相当于 C = C - A |
| *= | 相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。 | C *= A 相当于 C = C * A |
| /= | 相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。 | C /= A 相当于 C = C / A |
| %= | 求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。 | C %= A is equivalent to C = C % A |
| <<= | 按位左移后再赋值 | C <<= 2 相当于 C = C << 2 |
| >>= | 按位右移后再赋值 | C >>= 2 相当于 C = C >> 2 |
| &= | 按位与运算后赋值 | C &= 2 相当于 C = C & 2 |
| ^= | 按位异或运算符后再赋值 | C ^= 2 相当于 C = C ^ 2 |
| |= | 按位或运算后再赋值 | C |= 2 相当于 C = C | 2 |
6.运算符优先级
| 类别 | 运算符 | 关联性 |
|---|---|---|
| 1 | () [] | 左到右 |
| 2 | ! ~ | 右到左 |
| 3 | * / % | 左到右 |
| 4 | + - | 左到右 |
| 5 | >> >>> << | 左到右 |
| 6 | > >= < <= | 左到右 |
| 7 | == != | 左到右 |
| 8 | & | 左到右 |
| 9 | ^ | 左到右 |
| 10 | | | 左到右 |
| 11 | && | 左到右 |
| 12 | || | 左到右 |
| 13 | = += -= *= /= %= >>= <<= &= ^= |= | 右到左 |
| 14 | , | 左到 |
Scala-if...else
1. if语句
if (布尔表达式) {
// 如果布尔表达式为 true 则执行该语句块
}2.if...else 语句
if 语句后可以紧跟 else 语句，else 内的语句块可以在布尔表达式为 false 的时候执行。
if (布尔表达式) {
// 如果布尔表达式为 true 则执行该语句块
}else{
// 如果布尔表达式为 false 则执行该语句块
}3.if...elif..else 语句
if (布尔表达式 1) {
// 如果布尔表达式 1 为 true 则执行该语句块
} else if (布尔表达式 2) {
// 如果布尔表达式 2 为 true 则执行该语句块
} else if (布尔表达式 3) {
// 如果布尔表达式 3 为 true 则执行该语句块
} else {
// 如果以上条件都为 false 执行该语句块
}4.if...else 嵌套语句
if (布尔表达式 1) {
// 如果布尔表达式 1 为 true 则执行该语句块
if (布尔表达式 2) {
// 如果布尔表达式 2 为 true 则执行该语句块
}
}Scala -循环
| 循环类型 | 描述 |
|---|---|
| while 循环 | 运行一系列语句，如果条件为true，会重复运行，直到条件变为false。 |
| do...while 循环 | 类似 while 语句区别在于判断循环条件之前，先执行一次循环的代码块。 |
| for 循环 | 用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。 |
Scala 不支持 break 或 continue 语句，但从 2.8 版本后提供了一种中断循环的方式。
break语法
当在循环中使用 break 语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。
// 导入以下包
import scala.util.control._
// 创建 Breaks 对象
val loop = new Breaks;
// 在 breakable 中循环
loop.breakable{
// 循环
for(...){
....
// 循环中断
loop.break;
}
}实例：
import scala.util.control._
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
val loop = new Breaks;
loop.breakable {
for( a <- numList){
println( "Value of a: " + a );
if( a == 4 ){
loop.break;
}
}
}
println( "After the loop" );
}
}Scala -方法与函数
Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
方法是组成类的一部分；
函数则是一个完整的对象，继承了 Trait 的类的对象。
val | def 语句定义函数，def 语句定义方法。
1.方法定义
方法定义由一个 def 关键字开始，紧接着是可选的参数列表（多个参数用逗号分隔），一个冒号 : 和方法的返回类型，一个等于号 = ，最后是方法的主体。
Scala 方法定义格式：
def functionName ([参数列表]) : [return type] = {
function body
return [expr]
}如果方法没有返回值，可以返回为 Unit，类似于 Java 的 void。
实例：
object Hi{
def printMe( ) : Unit = {
println("Hi!")
}
}
如果不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型也成为一个抽象类型。
def functionName ([参数列表]) : [return type]
Scala-集合
可变集合：可以在适当的地方被更新或扩展（修改，添加，移除集合元素）。
不可变集合：永远不会改变（可模拟添加，移除或更新操作；但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变）。
常用集合类型的应用：
| 序号 | 集合及描述 |
|---|---|
| 1 | Scala List(列表) List的特征是其元素以线性方式存储，集合中可以存放重复对象。 参考 API文档 |
| 2 | Scala Set(集合) Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。 参考 API文档 |
| 3 | Scala Map(映射) Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。 参考 API文档 |
| 4 | Scala 元组 元组是不同类型的值的集合 |
| 5 | Scala Option Option[T] 表示有可能包含值的容器，也可能不包含值。 |
| 6 | Scala Iterator（迭代器） 迭代器不是一个容器，更确切的说是逐一访问容器内元素的方法。 |
Scala-类和对象
类是对象的抽象，而对象是类的具体实例。
类是抽象的，不占用内存；
对象是具体的，占用存储空间。
类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
Scala 继承
Scala继承一个基类跟Java很相似, 但我们需要注意以下几点：
import java.io._
class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移到一个新的位置
pt.move(10, 10);
}
}类：Point；对象：pt。
Scala-继承
1、重写一个非抽象方法必须使用override修饰符。
2、只有主构造函数才可以往基类的构造函数里写参数。
3、在子类中重写超类的抽象方法时，你不需要使用override关键字
Scala-单例对象
在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。
Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数。
当单例对象与某个类共享同一个名称时，被称作是这个类的伴生对象：companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问其私有成员。
// 私有构造方法
class Marker private(val color:String) {
println("创建" + this)
override def toString(): String = "颜色标记："+ color
}
// 伴生对象，与类名字相同，可以访问类的私有属性和方法
object Marker{
private val markers: Map[String, Marker] = Map(
"red" -> new Marker("red"),
"blue" -> new Marker("blue"),
"green" -> new Marker("green")
)
def apply(color:String) = {
if(markers.contains(color)) markers(color) else null
}
def getMarker(color:String) = {
if(markers.contains(color)) markers(color) else null
}
def main(args: Array[String]) {
println(Marker("red"))
// 单例函数调用，省略了.(点)符号
println(Marker getMarker "blue")
}
}Scala-模式匹配
选择器 match {备选项}
一个模式匹配包含了一系列备选项，每个都开始于关键字 case。
每个备选项都包含了一个模式及一到多个表达式。
箭头符号 => 隔开了模式和表达式。
match 表达式通过以代码编写的先后次序尝试每个模式来完成计算，只要发现有一个匹配的case，剩下的case不会继续匹配。
object Test {
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}Scala-正则表达式
Scala 通过 scala.util.matching 包中的 Regex 类来支持正则表达式。
import scala.util.matching.Regex
object Test {
def main(args: Array[String]) {
val pattern = new Regex("(S|s)cala") // 首字母可以是大写 S 或小写 s
val str = "Scala is scalable and cool"
println((pattern findAllIn str).mkString(",")) // 使用逗号 , 连接返回结果
}
}使用 mkString( ) 方法来连接正则表达式匹配结果的字符串，并可以使用管道(|)来设置不同的模式。
findFirstIn( ) ：找到首个匹配项；
findAllIn( ) ： 查看所有的匹配项；
replaceFirstIn( ) ：替换第一个匹配项；
replaceAllIn( ) ：替换所有匹配项。
正则表达式规则：
Scala 的正则表达式继承了 Java 的语法规则，Java 则大部分使用了 Perl 语言的规则。
| 表达式 | 匹配规则 |
|---|---|
| ^ | 匹配输入字符串开始的位置。 |
| $ | 匹配输入字符串结尾的位置。 |
| . | 匹配除"\r\n"之外的任何单个字符。 |
| [...] | 字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。 |
| [^...] | 反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。 |
| \\A | 匹配输入字符串开始的位置（无多行支持） |
| \\z | 字符串结尾(类似$，但不受处理多行选项的影响) |
| \\Z | 字符串结尾或行尾(不受处理多行选项的影响) |
| re* | 重复零次或更多次 |
| re+ | 重复一次或更多次 |
| re? | 重复零次或一次 |
| re{ n} | 重复n次 |
| re{ n,} | |
| re{ n, m} | 重复n到m次 |
| a|b | 匹配 a 或者 b |
| (re) | 匹配 re,并捕获文本到自动命名的组里 |
| (?: re) | 匹配 re,不捕获匹配的文本，也不给此分组分配组号 |
| (?> re) | 贪婪子表达式 |
| \\w | 匹配字母或数字或下划线或汉字 |
| \\W | 匹配任意不是字母，数字，下划线，汉字的字符 |
| \\s | 匹配任意的空白符,相等于 [\t\n\r\f] |
| \\S | 匹配任意不是空白符的字符 |
| \\d | 匹配数字，类似 [0-9] |
| \\D | 匹配任意非数字的字符 |
| \\G | 当前搜索的开头 |
| \\n | 换行符 |
| \\b | 通常是单词分界位置，但如果在字符类里使用代表退格 |
| \\B | 匹配不是单词开头或结束的位置 |
| \\t | 制表符 |
| \\Q | 开始引号：\Q(a+b)*3\E 可匹配文本 "(a+b)*3"。 |
| \\E | 结束引号：\Q(a+b)*3\E 可匹配文本 "(a+b)*3"。 |
正则表达式实例
| 实例 | 描述 |
|---|---|
| . | 匹配除"\r\n"之外的任何单个字符。 |
| [Rr]uby | 匹配 "Ruby" 或 "ruby" |
| rub[ye] | 匹配 "ruby" 或 "rube" |
| [aeiou] | 匹配小写字母 ：aeiou |
| [0-9] | 匹配任何数字，类似 [0123456789] |
| [a-z] | 匹配任何 ASCII 小写字母 |
| [A-Z] | 匹配任何 ASCII 大写字母 |
| [a-zA-Z0-9] | 匹配数字，大小写字母 |
| [^aeiou] | 匹配除了 aeiou 其他字符 |
| [^0-9] | 匹配除了数字的其他字符 |
| \\d | 匹配数字，类似: [0-9] |
| \\D | 匹配非数字，类似: [^0-9] |
| \\s | 匹配空格，类似: [ \t\r\n\f] |
| \\S | 匹配非空格，类似: [^ \t\r\n\f] |
| \\w | 匹配字母，数字，下划线，类似: [A-Za-z0-9_] |
| \\W | 匹配非字母，数字，下划线，类似: [^A-Za-z0-9_] |
| ruby? | 匹配 "rub" 或 "ruby": y 是可选的 |
| ruby* | 匹配 "rub" 加上 0 个或多个的 y。 |
| ruby+ | 匹配 "rub" 加上 1 个或多个的 y。 |
| \\d{3} | 刚好匹配 3 个数字。 |
| \\d{3,} | 匹配 3 个或多个数字。 |
| \\d{3,5} | 匹配 3 个、4 个或 5 个数字。 |
| \\D\\d+ | 无分组： + 重复 \d |
| (\\D\\d)+/ | 分组： + 重复 \D\d 对 |
| ([Rr]uby(, )?)+ | 匹配 "Ruby"、"Ruby, ruby, ruby"，等等 |
注：反斜线是转义字符，如要输出 \，需要在字符串中写成 \\ 来获取一个反斜线。
476
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
