目录
Scala Iterator(迭代器)
迭代器 it 的两个基本操作是 next 和 hasNext。
调用 it.next() 会返回迭代器的下一个元素,并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环:
object Test {
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}
查找最大与最小元素
it.min 和 it.max 方法
object Test {
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("最大元素是:" + ita.max )
println("最小元素是:" + itb.min )
}
}
获取迭代器的长度
使用 it.size 或 it.length 方法
object Test {
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("ita.size 的值: " + ita.size )
println("itb.length 的值: " + itb.length )
}
}
Scala 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 类和对象
类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
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);
}
}
Scala中的类不声明为public,一个Scala源文件中可以有多个类。
Scala 继承
Scala继承一个基类跟Java很相似:
- 1、重写一个非抽象方法必须使用override修饰符。
class Person {
var name = ""
override def toString = getClass.getName + "[name=" + name + "]"
}
class Employee extends Person {
var salary = 0.0
override def toString = super.toString + "[salary=" + salary + "]"
}
object Test extends App {
val fred = new Employee
fred.name = "Fred"
fred.salary = 50000
println(fred)
}
- 2、只有主构造函数才可以往基类的构造函数里写参数。
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);
}
}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("x 的坐标点 : " + x);
println ("y 的坐标点 : " + y);
println ("z 的坐标点 : " + z);
}
}
object Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// 移到一个新的位置
loc.move(10, 10, 5);
}
}
Scala 使用 extends 关键字来继承一个类。实例中 Location 类继承了 Point 类。Point 称为父类(基类),Location 称为子类。
override val xc 为重写了父类的字段。
继承会继承父类的所有属性和方法,Scala 只允许继承一个父类。
- 3、在子类中重写超类的抽象方法时,你不需要使用override关键字。
Scala 单例对象
在 Scala 中,是没有 static 这个东西的,但是它也为我们提供了单例模式的实现方法,那就是使用关键字 object。
Scala 中使用单例模式时,除了定义的类之外,还要定义一个同名的 object 对象,它和类的区别是,object对象不能带参数。
当单例对象与某个类共享同一个名称时,他被称作是这个类的伴生对象:companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类:companion class。类和它的伴生对象可以互相访问其私有成员。
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
}
}
object Test {
def main(args: Array[String]) {
val point = new Point(10, 20)
printPoint
def printPoint{
println ("x 的坐标点 : " + point.x);
println ("y 的坐标点 : " + point.y);
}
}
}
/* 文件名:Marker.scala
* author:菜鸟教程
* url:www.runoob.com
*/
// 私有构造方法
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 Trait(特征)
Scala Trait(特征) 相当于 Java 的接口,实际上它比接口还功能强大。
与接口不同的是,它还可以定义属性和方法的实现。
一般情况下Scala的类只能够继承单一父类,但是如果是 Trait(特征) 的话就可以继承多个,从结果来看就是实现了多重继承。
Trait(特征) 定义的方式与类类似,但它使用的关键字是 trait
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
/*
isEqual 方法没有定义方法的实现,isNotEqual定义了方法的实现。子类继承特征可以实现未被实现的方法。所以其实 Scala Trait(特征)更像 Java 的抽象类。
*/
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))
}
}
特征构造顺序
特征也可以有构造器,由字段的初始化和其他特征体中的语句构成。这些语句在任何混入该特征的对象在构造时都会被执行。
构造器的执行顺序:
- 调用超类的构造器;
- 特征构造器在超类构造器之后、类构造器之前执行;
- 特征由左到右被构造;
- 每个特征当中,父特征先被构造;
- 如果多个特征共有一个父特征,父特征不会被重复构造
- 所有特征被构造完毕,子类被构造。
构造器的顺序是类的线性化的反向。线性化是描述某个类型的所有超类型的一种技术规格。