a. package com.runoob
class HelloWorld
b. package com.runoob {
class HelloWorld
}
import java.awt.{Color, Font}
// 重命名成员
import java.util.{HashMap => JavaHashMap}
// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员,但是HashMap被隐藏了
val foo = """菜鸟教程
www.runoob.com
www.w3cschool.cc
www.runnoob.com
以上三个地址都能访问"""
使用关键词 "var" 声明变量,使用关键词 "val" 声明常量。
var myVar : String = "Foo"
val myVal : String = "Too"
如果程序尝试修改常量 myVal 的值,程序将会在编译时报错。
var myVar = 10;
val myVal = "Hello, Scala!";
val xmax, ymax = 100 // xmax, ymax都声明为100
这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外,对其它所有类都是private。
a. def functionName ([参数列表]) : [return type] = {
function body
return [expr]
}
b. 如果你不写等于号和方法主体,那么方法会被隐式声明为抽象(abstract),包含它的类型于是也是一个抽象类型。
如果方法没有返回值,可以返回为 Unit,这个类似于 Java 的 void
c. String方法
下表列出了 java.lang.String 中常用的方法,你可以在 Scala 中使用:
序号 |
方法及描述 |
1 |
char charAt(int index) 返回指定位置的字符 |
2 |
int compareTo(Object o) 比较字符串与对象 |
3 |
int compareTo(String anotherString) 按字典顺序比较两个字符串 |
4 |
int compareToIgnoreCase(String str) 按字典顺序比较两个字符串,不考虑大小写 |
5 |
String concat(String str) 将指定字符串连接到此字符串的结尾 |
6 |
boolean contentEquals(StringBuffer sb) 将此字符串与指定的 StringBuffer 比较。 |
7 |
static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String |
8 |
static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String |
9 |
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束 |
10 |
boolean equals(Object anObject) 将此字符串与指定的对象比较 |
11 |
boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较,不考虑大小写 |
12 |
byte getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中 |
13 |
byte[] getBytes(String charsetName 使用指定的字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中 |
14 |
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组 |
15 |
int hashCode() 返回此字符串的哈希码 |
16 |
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引 |
17 |
int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索 |
18 |
int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引 |
19 |
int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始 |
20 |
String intern() 返回字符串对象的规范化表示形式 |
21 |
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引 |
22 |
int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索 |
23 |
int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引 |
24 |
int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索 |
25 |
int length() 返回此字符串的长度 |
26 |
boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式 |
27 |
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等 |
28 |
boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等 |
29 |
String replace(char oldChar, char newChar) 返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的 |
30 |
String replaceAll(String regex, String replacement 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串 |
31 |
String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串 |
32 |
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串 |
33 |
String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串 |
34 |
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始 |
35 |
boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 |
36 |
CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列,它是此序列的一个子序列 |
37 |
String substring(int beginIndex) 返回一个新的字符串,它是此字符串的一个子字符串 |
38 |
String substring(int beginIndex, int endIndex) 返回一个新字符串,它是此字符串的一个子字符串 |
39 |
char[] toCharArray() 将此字符串转换为一个新的字符数组 |
40 |
String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写 |
41 |
String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写 |
42 |
String toString() 返回此对象本身(它已经是一个字符串!) |
43 |
String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写 |
44 |
String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写 |
45 |
String trim() 删除指定字符串的首尾空白符 |
46 |
static String valueOf(primitive data type x) 返回指定类型参数的字符串表示形式 |
数组
var z:Array[String] = new Array[String](3)
或
var z = new Array[String](3)
z(0) = "Runoob"; z(1) = "Baidu"; z(4/2) = "Google"
var z = Array("Runoob", "Baidu", "Google")
多维数组
var myMatrix = ofDim[Int](3,3)
数组方法
下表中为 Scala 语言中处理数组的重要方法,使用它前我们需要使用 import Array._ 引入包。
序号 |
方法和描述 |
1 |
def apply( x: T, xs: T* ): Array[T] 创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。 |
2 |
def concat[T]( xss: Array[T]* ): Array[T] 合并数组 |
3 |
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit 复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。 |
4 |
def empty[T]: Array[T] 返回长度为 0 的数组 |
5 |
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] 返回指定长度数组,每个数组元素为指定函数的返回值。 以上实例数组初始值为 0,长度为 3,计算函数为a=>a+1: scala> Array.iterate(0,3)(a=>a+1) |
6 |
def fill[T]( n: Int )(elem: => T): Array[T] 返回数组,长度为第一个参数指定,同时每个元素使用第二个参数进行填充。 |
7 |
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] 返回二数组,长度为第一个参数指定,同时每个元素使用第二个参数进行填充。 |
8 |
def ofDim[T]( n1: Int ): Array[T] 创建指定长度的数组 |
9 |
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 创建二维数组 |
10 |
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 创建三维数组 |
11 |
def range( start: Int, end: Int, step: Int ): Array[Int] 创建指定区间内的数组,step 为每个元素间的步长 |
12 |
def range( start: Int, end: Int ): Array[Int] 创建指定区间内的数组 |
13 |
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回指定长度数组,每个数组元素为指定函数的返回值,默认从 0 开始。 以上实例返回 3 个元素: scala> Array.tabulate(3)(a => a + 5) |
14 |
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回指定长度的二维数组,每个数组元素为指定函数的返回值,默认从 0 开始。 |
List
1. 定义
// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")
// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)
// 空列表
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
// 字符串列表
val site = "Runoob" :: ("Google" :: ("Baidu" :: Nil))
2. 连接列表
使用 ::: 运算符或 List.:::() 方法或 List.concat() 方法来连接两个或多个列表。
3. List.fill()
val site = List.fill(3)("Runoob") // 重复 Runoob 3次
4. List.tabulate()
// 通过给定的函数创建 6 个元素
val squares = List.tabulate(6)(n => n * n)
5. Scala List 常用方法
下表列出了 Scala List 常用的方法:
序号 |
方法及描述 |
1 |
def +:(elem: A): List[A] 为列表预添加元素 scala> val x = List(1) scala> val y = 2 +: x scala> println(x) |
2 |
def ::(x: A): List[A] 在列表开头添加元素 |
3 |
def :::(prefix: List[A]): List[A] 在列表开头添加指定列表的元素 |
4 |
def :+(elem: A): List[A] 复制添加元素后列表。 scala> val a = List(1) scala> val b = a :+ 2 scala> println(a) |
5 |
def addString(b: StringBuilder): StringBuilder 将列表的所有元素添加到 StringBuilder |
6 |
def addString(b: StringBuilder, sep: String): StringBuilder 将列表的所有元素添加到 StringBuilder,并指定分隔符 |
7 |
def apply(n: Int): A 通过列表索引获取元素 |
8 |
def contains(elem: Any): Boolean 检测列表中是否包含指定的元素 |
9 |
def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将列表的元素复制到数组中。 |
10 |
def distinct: List[A] 去除列表的重复元素,并返回新列表 |
11 |
def drop(n: Int): List[A] 丢弃前n个元素,并返回新列表 |
12 |
def dropRight(n: Int): List[A] 丢弃最后n个元素,并返回新列表 |
13 |
def dropWhile(p: (A) => Boolean): List[A] 从左向右丢弃元素,直到条件p不成立 |
14 |
def endsWith[B](that: Seq[B]): Boolean 检测列表是否以指定序列结尾 |
15 |
def equals(that: Any): Boolean 判断是否相等 |
16 |
def exists(p: (A) => Boolean): Boolean 判断列表中指定条件的元素是否存在。 判断l是否存在某个元素: scala> l.exists(s => s == "Hah") |
17 |
def filter(p: (A) => Boolean): List[A] 输出符号指定条件的所有元素。 过滤出长度为3的元素: scala> l.filter(s => s.length == 3) |
18 |
def forall(p: (A) => Boolean): Boolean 检测所有元素。 例如:判断所有元素是否以"H"开头: scala> l.forall(s => s.startsWith("H")) res10: Boolean = false |
19 |
def foreach(f: (A) => Unit): Unit 将函数应用到列表的所有元素 |
20 |
def head: A 获取列表的第一个元素 |
21 |
def indexOf(elem: A, from: Int): Int 从指定位置 from 开始查找元素第一次出现的位置 |
22 |
def init: List[A] 返回所有元素,除了最后一个 |
23 |
def intersect(that: Seq[A]): List[A] 计算多个集合的交集 |
24 |
def isEmpty: Boolean 检测列表是否为空 |
25 |
def iterator: Iterator[A] 创建一个新的迭代器来迭代元素 |
26 |
def last: A 返回最后一个元素 |
27 |
def lastIndexOf(elem: A, end: Int): Int 在指定的位置 end 开始查找元素最后出现的位置 |
28 |
def length: Int 返回列表长度 |
29 |
def map[B](f: (A) => B): List[B] 通过给定的方法将所有元素重新计算 |
30 |
def max: A 查找最大元素 |
31 |
def min: A 查找最小元素 |
32 |
def mkString: String 列表所有元素作为字符串显示 |
33 |
def mkString(sep: String): String 使用分隔符将列表所有元素作为字符串显示 |
34 |
def reverse: List[A] 列表反转 |
35 |
def sorted[B >: A]: List[A] 列表排序 |
36 |
def startsWith[B](that: Seq[B], offset: Int): Boolean 检测列表在指定位置是否包含指定序列 |
37 |
def sum: A 计算集合元素之和 |
38 |
def tail: List[A] 返回所有元素,除了第一个 |
39 |
def take(n: Int): List[A] 提取列表的前n个元素 |
40 |
def takeRight(n: Int): List[A] 提取列表的后n个元素 |
41 |
def toArray: Array[A] 列表转换为数组 |
42 |
def toBuffer[B >: A]: Buffer[B] 返回缓冲区,包含了列表的所有元素 |
43 |
def toMap[T, U]: Map[T, U] List 转换为 Map |
44 |
def toSeq: Seq[A] List 转换为 Seq |
45 |
def toSet[B >: A]: Set[B] List 转换为 Set |
46 |
def toString(): String 列表转换为字符串 |
Set
Scala Set(集合)是没有重复的对象集合,所有的元素都是唯一的。
下表列出了 Scala Set 常用的方法:
序号 |
方法及描述 |
1 |
def +(elem: A): Set[A] 为集合添加新元素,x并创建一个新的集合,除非元素已存在 |
2 |
def -(elem: A): Set[A] 移除集合中的元素,并创建一个新的集合 |
3 |
def contains(elem: A): Boolean 如果元素在集合中存在,返回 true,否则返回 false。 |
4 |
def &(that: Set[A]): Set[A] 返回两个集合的交集 |
5 |
def &~(that: Set[A]): Set[A] 返回两个集合的差集 |
6 |
def +(elem1: A, elem2: A, elems: A*): Set[A] 通过添加传入指定集合的元素创建一个新的不可变集合 |
7 |
def ++(elems: A): Set[A] 合并两个集合 |
8 |
def -(elem1: A, elem2: A, elems: A*): Set[A] 通过移除传入指定集合的元素创建一个新的不可变集合 |
9 |
def addString(b: StringBuilder): StringBuilder 将不可变集合的所有元素添加到字符串缓冲区 |
10 |
def addString(b: StringBuilder, sep: String): StringBuilder 将不可变集合的所有元素添加到字符串缓冲区,并使用指定的分隔符 |
11 |
def apply(elem: A) 检测集合中是否包含指定元素 |
12 |
def count(p: (A) => Boolean): Int 计算满足指定条件的集合元素个数 |
13 |
def copyToArray(xs: Array[A], start: Int, len: Int): Unit 复制不可变集合元素到数组 |
14 |
def diff(that: Set[A]): Set[A] 比较两个集合的差集 |
15 |
def drop(n: Int): Set[A]] 返回丢弃前n个元素新集合 |
16 |
def dropRight(n: Int): Set[A] 返回丢弃最后n个元素新集合 |
17 |
def dropWhile(p: (A) => Boolean): Set[A] 从左向右丢弃元素,直到条件p不成立 |
18 |
def equals(that: Any): Boolean equals 方法可用于任意序列。用于比较系列是否相等。 |
19 |
def exists(p: (A) => Boolean): Boolean 判断不可变集合中指定条件的元素是否存在。 |
20 |
def filter(p: (A) => Boolean): Set[A] 输出符合指定条件的所有不可变集合元素。 |
21 |
def find(p: (A) => Boolean): Option[A] 查找不可变集合中满足指定条件的第一个元素 |
22 |
def forall(p: (A) => Boolean): Boolean 查找不可变集合中满足指定条件的所有元素 |
23 |
def foreach(f: (A) => Unit): Unit 将函数应用到不可变集合的所有元素 |
24 |
def head: A 获取不可变集合的第一个元素 |
25 |
def init: Set[A] 返回所有元素,除了最后一个 |
26 |
def intersect(that: Set[A]): Set[A] 计算两个集合的交集 |
27 |
def isEmpty: Boolean 判断集合是否为空 |
28 |
def iterator: Iterator[A] 创建一个新的迭代器来迭代元素 |
29 |
def last: A 返回最后一个元素 |
30 |
def map[B](f: (A) => B): immutable.Set[B] 通过给定的方法将所有元素重新计算 |
31 |
def max: A 查找最大元素 |
32 |
def min: A 查找最小元素 |
33 |
def mkString: String 集合所有元素作为字符串显示 |
34 |
def mkString(sep: String): String 使用分隔符将集合所有元素作为字符串显示 |
35 |
def product: A 返回不可变集合中数字元素的积。 |
36 |
def size: Int 返回不可变集合元素的数量 |
37 |
def splitAt(n: Int): (Set[A], Set[A]) 把不可变集合拆分为两个容器,第一个由前 n 个元素组成,第二个由剩下的元素组成 |
38 |
def subsetOf(that: Set[A]): Boolean 如果集合中含有子集返回 true,否则返回false |
39 |
def sum: A 返回不可变集合中所有数字元素之和 |
40 |
def tail: Set[A] 返回一个不可变集合中除了第一元素之外的其他元素 |
41 |
def take(n: Int): Set[A] 返回前 n 个元素 |
42 |
def takeRight(n: Int):Set[A] 返回后 n 个元素 |
43 |
def toArray: Array[A] 将集合转换为数组 |
44 |
def toBuffer[B >: A]: Buffer[B] 返回缓冲区,包含了不可变集合的所有元素 |
45 |
def toList: List[A] 返回 List,包含了不可变集合的所有元素 |
46 |
def toMap[T, U]: Map[T, U] 返回 Map,包含了不可变集合的所有元素 |
47 |
def toSeq: Seq[A] 返回 Seq,包含了不可变集合的所有元素 |
48 |
def toString(): String 返回一个字符串,以对象来表示 |
Map
序号 |
方法及描述 |
1 |
def ++(xs: Map[(A, B)]): Map[A, B] 返回一个新的 Map,新的 Map xs 组成 |
2 |
def -(elem1: A, elem2: A, elems: A*): Map[A, B] 返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。 |
3 |
def --(xs: GTO[A]): Map[A, B] 返回一个新的 Map, 移除 xs 对象中对应的 key |
4 |
def get(key: A): Option[B] 返回指定 key 的值 |
5 |
def iterator: Iterator[(A, B)] 创建新的迭代器,并输出 key/value 对 |
6 |
def addString(b: StringBuilder): StringBuilder 将 Map 中的所有元素附加到StringBuilder,可加入分隔符 |
7 |
def addString(b: StringBuilder, sep: String): StringBuilder 将 Map 中的所有元素附加到StringBuilder,可加入分隔符 |
8 |
def apply(key: A): B 返回指定键的值,如果不存在返回 Map 的默认方法 |
9 |
def clear(): Unit 清空 Map |
10 |
def clone(): Map[A, B] 从一个 Map 复制到另一个 Map |
11 |
def contains(key: A): Boolean 如果 Map 中存在指定 key,返回 true,否则返回 false。 |
12 |
def copyToArray(xs: Array[(A, B)]): Unit 复制集合到数组 |
13 |
def count(p: ((A, B)) => Boolean): Int 计算满足指定条件的集合元素数量 |
14 |
def default(key: A): B 定义 Map 的默认值,在 key 不存在时返回。 |
15 |
def drop(n: Int): Map[A, B] 返回丢弃前n个元素新集合 |
16 |
def dropRight(n: Int): Map[A, B] 返回丢弃最后n个元素新集合 |
17 |
def dropWhile(p: ((A, B)) => Boolean): Map[A, B] 从左向右丢弃元素,直到条件p不成立 |
18 |
def empty: Map[A, B] 返回相同类型的空 Map |
19 |
def equals(that: Any): Boolean 如果两个 Map 相等(key/value 均相等),返回true,否则返回false |
20 |
def exists(p: ((A, B)) => Boolean): Boolean 判断集合中指定条件的元素是否存在 |
21 |
def filter(p: ((A, B))=> Boolean): Map[A, B] 返回满足指定条件的所有集合 |
22 |
def filterKeys(p: (A) => Boolean): Map[A, B] 返回符合指定条件的不可变 Map |
23 |
def find(p: ((A, B)) => Boolean): Option[(A, B)] 查找集合中满足指定条件的第一个元素 |
24 |
def foreach(f: ((A, B)) => Unit): Unit 将函数应用到集合的所有元素 |
25 |
def init: Map[A, B] 返回所有元素,除了最后一个 |
26 |
def isEmpty: Boolean 检测 Map 是否为空 |
27 |
def keys: Iterable[A] 返回所有的key/p> |
28 |
def last: (A, B) 返回最后一个元素 |
29 |
def max: (A, B) 查找最大元素 |
30 |
def min: (A, B) 查找最小元素 |
31 |
def mkString: String 集合所有元素作为字符串显示 |
32 |
def product: (A, B) 返回集合中数字元素的积。 |
33 |
def remove(key: A): Option[B] 移除指定 key |
34 |
def retain(p: (A, B) => Boolean): Map.this.type 如果符合满足条件的返回 true |
35 |
def size: Int 返回 Map 元素的个数 |
36 |
def sum: (A, B) 返回集合中所有数字元素之和 |
37 |
def tail: Map[A, B] 返回一个集合中除了第一元素之外的其他元素 |
38 |
def take(n: Int): Map[A, B] 返回前 n 个元素 |
39 |
def takeRight(n: Int): Map[A, B] 返回后 n 个元素 |
40 |
def takeWhile(p: ((A, B)) => Boolean): Map[A, B] 返回满足指定条件的元素 |
41 |
def toArray: Array[(A, B)] 集合转数组 |
42 |
def toBuffer[B >: A]: Buffer[B] 返回缓冲区,包含了 Map 的所有元素 |
43 |
def toList: List[A] 返回 List,包含了 Map 的所有元素 |
44 |
def toSeq: Seq[A] 返回 Seq,包含了 Map 的所有元素 |
45 |
def toSet: Set[A] 返回 Set,包含了 Map 的所有元素 |
46 |
def toString(): String 返回字符串对象 |
tuple元组
与列表一样,元组也是不可变的,但与列表不同的是元组可以包含不同类型的元素。
元组的值是通过将单个的值包含在圆括号中构成的。例如:
val t = (1, 3.14, "Fred")
以上实例在元组中定义了三个元素,对应的类型分别为[Int, Double, java.lang.String]。
此外我们也可以使用以上方式来定义:
val t = new Tuple3(1, 3.14, "Fred")
元组的实际类型取决于它的元素的类型,比如 (99, "runoob") 是 Tuple2[Int, String]。 ('u', 'r', "the", 1, 4, "me") 为 Tuple6[Char, Char, String, Int, Int, String]。
目前 Scala 支持的元组最大长度为 22。对于更大长度你可以使用集合,或者扩展元组。
访问元组的元素可以通过数字索引,如下一个元组:
val t = (4,3,2,1)
我们可以使用 t._1 访问第一个元素, t._2 访问第二个元素,如下所示:
object Test {
def main(args: Array[String]) {
val t = (4,3,2,1)
val sum = t._1 + t._2 + t._3 + t._4
println( "元素之和为: " + sum )
}
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
元素之和为: 10
迭代元组
你可以使用 Tuple.productIterator() 方法来迭代输出元组的所有元素:
object Test {
def main(args: Array[String]) {
val t = (4,3,2,1)
t.productIterator.foreach{ i =>println("Value = " + i )}
}
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
Value = 4
Value = 3
Value = 2
Value = 1
元组转为字符串
你可以使用 Tuple.toString() 方法将元组的所有元素组合成一个字符串,实例如下:
object Test {
def main(args: Array[String]) {
val t = new Tuple3(1, "hello", Console)
println("连接后的字符串为: " + t.toString() )
}
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
连接后的字符串为: (1,hello,scala.Console$@4dd8dc3)
元素交换
你可以使用 Tuple.swap 方法来交换元组的元素。如下实例:
object Test {
def main(args: Array[String]) {
val t = new Tuple2("www.google.com", "www.runoob.com")
println("交换后的元组: " + t.swap )
}
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
交换后的元组: (www.runoob.com,www.google.com)
Option(选项)
序号 |
方法及描述 |
1 |
def get: A 获取可选值 |
2 |
def isEmpty: Boolean 检测可选类型值是否为 None,是的话返回 true,否则返回 false |
3 |
def productArity: Int 返回元素个数, A(x_1, ..., x_k), 返回 k |
4 |
def productElement(n: Int): Any 获取指定的可选项,以 0 为起始。即 A(x_1, ..., x_k), 返回 x_(n+1) , 0 < n < k. |
5 |
def exists(p: (A) => Boolean): Boolean 如果可选项中指定条件的元素存在且不为 None 返回 true,否则返回 false。 |
6 |
def filter(p: (A) => Boolean): Option[A] 如果选项包含有值,而且传递给 filter 的条件函数返回 true, filter 会返回 Some 实例。 否则,返回值为 None 。 |
7 |
def filterNot(p: (A) => Boolean): Option[A] 如果选项包含有值,而且传递给 filter 的条件函数返回 false, filter 会返回 Some 实例。 否则,返回值为 None 。 |
8 |
def flatMap[B](f: (A) => Option[B]): Option[B] 如果选项包含有值,则传递给函数 f 处理后返回,否则返回 None |
9 |
def foreach[U](f: (A) => U): Unit 如果选项包含有值,则将每个值传递给函数 f, 否则不处理。 |
10 |
def getOrElse[B >: A](default: => B): B 如果选项包含有值,返回选项值,否则返回设定的默认值。 |
11 |
def isDefined: Boolean 如果可选值是 Some 的实例返回 true,否则返回 false。 |
12 |
def iterator: Iterator[A] 如果选项包含有值,迭代出可选值。如果可选值为空则返回空迭代器。 |
13 |
def map[B](f: (A) => B): Option[B] 如果选项包含有值, 返回由函数 f 处理后的 Some,否则返回 None |
14 |
def orElse[B >: A](alternative: => Option[B]): Option[B] 如果一个 Option 是 None , orElse 方法会返回传名参数的值,否则,就直接返回这个 Option。 |
15 |
def orNull 如果选项包含有值返回选项值,否则返回 null。 |
Iterator(迭代器)
序号 |
方法及描述 |
1 |
def hasNext: Boolean 如果还有可返回的元素,返回true。 |
2 |
def next(): A 返回迭代器的下一个元素,并且更新迭代器的状态 |
3 |
def ++(that: => Iterator[A]): Iterator[A] 合并两个迭代器 |
4 |
def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B] 合并两个迭代器 |
5 |
def addString(b: StringBuilder): StringBuilder 添加一个字符串到 StringBuilder b |
6 |
def addString(b: StringBuilder, sep: String): StringBuilder 添加一个字符串到 StringBuilder b,并指定分隔符 |
7 |
def buffered: BufferedIterator[A] 迭代器都转换成 BufferedIterator |
8 |
def contains(elem: Any): Boolean 检测迭代器中是否包含指定元素 |
9 |
def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将迭代器中选定的值传给数组 |
10 |
def count(p: (A) => Boolean): Int 返回迭代器元素中满足条件p的元素总数。 |
11 |
def drop(n: Int): Iterator[A] 返回丢弃前n个元素新集合 |
12 |
def dropWhile(p: (A) => Boolean): Iterator[A] 从左向右丢弃元素,直到条件p不成立 |
13 |
def duplicate: (Iterator[A], Iterator[A]) 生成两个能分别返回迭代器所有元素的迭代器。 |
14 |
def exists(p: (A) => Boolean): Boolean 返回一个布尔值,指明迭代器元素中是否存在满足p的元素。 |
15 |
def filter(p: (A) => Boolean): Iterator[A] 返回一个新迭代器 ,指向迭代器元素中所有满足条件p的元素。 |
16 |
def filterNot(p: (A) => Boolean): Iterator[A] 返回一个迭代器,指向迭代器元素中不满足条件p的元素。 |
17 |
def find(p: (A) => Boolean): Option[A] 返回第一个满足p的元素或None。注意:如果找到满足条件的元素,迭代器会被置于该元素之后;如果没有找到,会被置于终点。 |
18 |
def flatMap[B](f: (A) => GenTraversableOnce[B]): Iterator[B] 针对迭代器的序列中的每个元素应用函数f,并返回指向结果序列的迭代器。 |
19 |
def forall(p: (A) => Boolean): Boolean 返回一个布尔值,指明 it 所指元素是否都满足p。 |
20 |
def foreach(f: (A) => Unit): Unit 在迭代器返回的每个元素上执行指定的程序 f |
21 |
def hasDefiniteSize: Boolean 如果迭代器的元素个数有限则返回true(缺省等同于isEmpty) |
22 |
def indexOf(elem: B): Int 返回迭代器的元素中index等于x的第一个元素。注意:迭代器会越过这个元素。 |
23 |
def indexWhere(p: (A) => Boolean): Int 返回迭代器的元素中下标满足条件p的元素。注意:迭代器会越过这个元素。 |
24 |
def isEmpty: Boolean 检查it是否为空, 为空返回 true,否则返回false(与hasNext相反)。 |
25 |
def isTraversableAgain: Boolean Tests whether this Iterator can be repeatedly traversed. |
26 |
def length: Int 返回迭代器元素的数量。 |
27 |
def map[B](f: (A) => B): Iterator[B] 将 it 中的每个元素传入函数 f 后的结果生成新的迭代器。 |
28 |
def max: A 返回迭代器迭代器元素中最大的元素。 |
29 |
def min: A 返回迭代器迭代器元素中最小的元素。 |
30 |
def mkString: String 将迭代器所有元素转换成字符串。 |
31 |
def mkString(sep: String): String 将迭代器所有元素转换成字符串,并指定分隔符。 |
32 |
def nonEmpty: Boolean 检查容器中是否包含元素(相当于 hasNext)。 |
33 |
def padTo(len: Int, elem: A): Iterator[A] 首先返回迭代器所有元素,追加拷贝 elem 直到长度达到 len。 |
34 |
def patch(from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B] 返回一个新迭代器,其中自第 from 个元素开始的 replaced 个元素被迭代器所指元素替换。 |
35 |
def product: A 返回迭代器所指数值型元素的积。 |
36 |
def sameElements(that: Iterator[_]): Boolean 判断迭代器和指定的迭代器参数是否依次返回相同元素 |
37 |
def seq: Iterator[A] 返回集合的系列视图 |
38 |
def size: Int 返回迭代器的元素数量 |
39 |
def slice(from: Int, until: Int): Iterator[A] 返回一个新的迭代器,指向迭代器所指向的序列中从开始于第 from 个元素、结束于第 until 个元素的片段。 |
40 |
def sum: A 返回迭代器所指数值型元素的和 |
41 |
def take(n: Int): Iterator[A] 返回前 n 个元素的新迭代器。 |
42 |
def toArray: Array[A] 将迭代器指向的所有元素归入数组并返回。 |
43 |
def toBuffer: Buffer[B] 将迭代器指向的所有元素拷贝至缓冲区 Buffer。 |
44 |
def toIterable: Iterable[A] Returns an Iterable containing all elements of this traversable or iterator. This will not terminate for infinite iterators. |
45 |
def toIterator: Iterator[A] 把迭代器的所有元素归入一个Iterator容器并返回。 |
46 |
def toList: List[A] 把迭代器的所有元素归入列表并返回 |
47 |
def toMap[T, U]: Map[T, U] 将迭代器的所有键值对归入一个Map并返回。 |
48 |
def toSeq: Seq[A] 将代器的所有元素归入一个Seq容器并返回。 |
49 |
def toString(): String 将迭代器转换为字符串 |
50 |
def zip[B](that: Iterator[B]): Iterator[(A, B) 返回一个新迭代器,指向分别由迭代器和指定的迭代器 that 元素一一对应而成的二元组序列 |
Scala Trait(特征) 相当于 Java 的接口,实际上它比接口还功能强大。
与接口不同的是,它还可以定义属性和方法的实现。
一般情况下Scala的类只能够继承单一父类,但是如果是 Trait(特征) 的话就可以继承多个,从结果来看就是实现了多重继承。
Trait(特征) 定义的方式与类类似,但它使用的关键字是 trait,如下所示:
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
以上Trait(特征)由两个方法组成:isEqual 和 isNotEqual。isEqual 方法没有定义方法的实现,isNotEqual定义了方法的实现。子类继承特征可以实现未被实现的方法。所以其实 Scala Trait(特征)更像 Java 的抽象类。
以下演示了特征的完整实例:
/* 文件名:Test.scala
* author:菜鸟教程
* url:www.runoob.com
*/
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
class Point(xc: Int, yc: Int) extends Equal {
var x: Int = xc
var y: Int = yc
def isEqual(obj: Any) =
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}
object Test {
def main(args: Array[String]) {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
}
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
false
true
true
特征构造顺序
特征也可以有构造器,由字段的初始化和其他特征体中的语句构成。这些语句在任何混入该特征的对象在构造时都会被执行。
构造器的执行顺序:
构造器的顺序是类的线性化的反向。线性化是描述某个类型的所有超类型的一种技术规格。
object Test {
def main(args: Array[String]) {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
println(matchTest(6))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int"
case _ => "many"
}
}
import scala.util.matching.Regex
object Test {
def main(args: Array[String]) {
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
}
}
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Test {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>{
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}
}
}
提取器是从传递给它的对象中提取出构造该对象的参数。
Scala 标准库包含了一些预定义的提取器,我们会大致的了解一下它们。
Scala 提取器是一个带有unapply方法的对象。unapply方法算是apply方法的反向操作:unapply接受一个对象,然后从对象中提取值,提取的值通常是用来构造该对象的值。
以下实例演示了邮件地址的提取器对象:
object Test {
def main(args: Array[String]) {
println ("Apply 方法 : " + apply("Zara", "gmail.com"));
println ("Unapply 方法 : " + unapply("[email protected]"));
println ("Unapply 方法 : " + unapply("Zara Ali"));
}
// 注入方法 (可选)
def apply(user: String, domain: String) = {
user +"@"+ domain
}
// 提取方法(必选)
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2){
Some(parts(0), parts(1))
}else{
None
}
}
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
Apply 方法 : Zara@gmail.com
Unapply 方法 : Some((Zara,gmail.com))
Unapply 方法 : None
以上对象定义了两个方法: apply 和 unapply 方法。通过 apply 方法我们无需使用 new 操作就可以创建对象。所以你可以通过语句 Test("Zara", "gmail.com") 来构造一个字符串 "[email protected]"。
unapply方法算是apply方法的反向操作:unapply接受一个对象,然后从对象中提取值,提取的值通常是用来构造该对象的值。实例中我们使用 Unapply 方法从对象中提取用户名和邮件地址的后缀。
实例中 unapply 方法在传入的字符串不是邮箱地址时返回 None。代码演示如下:
unapply("[email protected]") 相等于 Some("Zara", "gmail.com")
unapply("Zara Ali") 相等于 None
提取器使用模式匹配
在我们实例化一个类的时,可以带上0个或者多个的参数,编译器在实例化的时会调用 apply 方法。我们可以在类和对象中都定义 apply 方法。
就像我们之前提到过的,unapply 用于提取我们指定查找的值,它与 apply 的操作相反。 当我们在提取器对象中使用 match 语句是,unapply 将自动执行,如下所示:
object Test {
def main(args: Array[String]) {
val x = Test(5)
println(x)
x match
{
case Test(num) => println(x + " 是 " + num + " 的两倍!")
//unapply 被调用
case _ => println("无法计算")
}
}
def apply(x: Int) = x*2
def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
10
10 是 5 的两倍!
Scala 进行文件写操作,直接用的都是 java中 的 I/O 类 (java.io.File):
import java.io._
object Test {
def main(args: Array[String]) {
val writer = new PrintWriter(new File("test.txt" ))
writer.write("菜鸟教程")
writer.close()
}
}
执行以上代码,会在你的当前目录下生产一个 test.txt 文件,文件内容为"菜鸟教程":
$ scalac Test.scala
$ scala Test
$ cat test.txt
菜鸟教程
从屏幕上读取用户输入
有时候我们需要接收用户在屏幕输入的指令来处理程序。实例如下:
import scala.io._
object Test {
def main(args: Array[String]) {
print("请输入菜鸟教程官网 : " )
val line = StdIn.readLine()
println("谢谢,你输入的是: " + line)
}
}
Scala2.11 后的版本 Console.readLine 已废弃,使用 scala.io.StdIn.readLine() 方法代替。
执行以上代码,屏幕上会显示如下信息:
$ scalac Test.scala
$ scala Test
请输入菜鸟教程官网 : www.runoob.com
谢谢,你输入的是: www.runoob.com
从文件上读取内容
从文件读取内容非常简单。我们可以使用 Scala 的 Source 类及伴生对象来读取文件。以下实例演示了从 "test.txt"(之前已创建过) 文件中读取内容:
import scala.io.Source
object Test {
def main(args: Array[String]) {
println("文件内容为:" )
Source.fromFile("test.txt" ).foreach{
print
}
}
}
执行以上代码,输出结果为:
$ scalac Test.scala
$ scala Test
文件内容为:
菜鸟教程