Scala从入门到了解第二课：scala迭代器模式

1、第一个scala程序

vi HelloWorld.scala

object HelloWorld{
        def main (args:Array[String]){
                println("HelloWorld,scala!")
        }

}

scalac HelloWorld.scala

#编译完成后当前目录会生成两个文件HelloWorld.class和HelloWorld$.class

scala HelloWorld

2、isDistanceOf[]和asDistanceOf[]

scala> val a=10
a: Int = 10

scala> a.asInstanceOf[Double]
res0: Double = 10.0

scala> a.isInstanceOf[Double]

res1: Boolean = false

3、导入文件

scala> import scala.io.Source._
import scala.io.Source._

scala> fromFile("/home/hadoop/HelloWorld.scala")

res2: scala.io.BufferedSource = non-empty iterator

4、默认参数、命名参数、可变参数

1）默认参数

scala> def sayName(name:String="Lucy")=println(name)
sayName: (name: String)Unit

scala> sayName("Bob")
Bob

scala> sayName()

Lucy

#一般情况函数名后的括号内为“形参名:形参类型”，而此处为形参名:形参类型=默认值”，这叫做默认参数

2）命名参数

scala> def speed(distance:Float,time:Float)=distance/time
speed: (distance: Float, time: Float)Float

scala> speed(distance=100,time=3)
res6: Float = 33.333332

scala> speed(time=3,distance=100)
res7: Float = 33.333332

scala> speed(100,3)

res8: Float = 33.333332

#命名参数指的是调用函数时传参格式为“函数名(参数名=参数值,参数名=参数值,.......)”，正常调用为“函数名(第一参数，第二参数)”

3）可变参数

scala> def sum(nums:Int*)={
     | var result:Int=0
     | for(num <- nums)
     | result+=num

     | result}

scala>sum(1,2,3,4)

res0: Int=10

scala>sum(1 to 4 :_*)

res1: Int=10

#可变参数：函数参数类型格式为（变量:类型*），此时该函数可以接受多个该类型的参数

5、属性私有

class Person(val name:String,id:Int){

        .....................

}

#参数id前方未加变量定义修饰符，故id这个字段只能在Person类中访问，其他类要访问必须new一个Person的对象，通过对象访问

private[this] val name="Lucy"

#private[this]限定了name这个字段只能在this类中访问

6、默认值

scala> var a:Int=_
a: Int = 0


scala> var a:Double=_
a: Double = 0.0


scala> var a:String=_
a: String = null


scala> var a:Boolean=_
a: Boolean = false

7、测试类

object test{

    def main(args:Array:[String]){

       //main函数代码

    }

}

以上等价于

 

object test extends App{

.................................

}

8、构造器

class Person(参数:参数类型，...................){.....................}

#以上格式称之为主构造器

class Person(var name:String,val id:Int){

    var gender:gender=_

    def this(name:String,id:Int,gender:String){

        this(name,id)

        this.gender=gender

    }

}

#红色部分为附属构造器，附属构造器的函数体第一行必须调用主构造器或其他附属构造器

 

9、继承

class Person(var name:String,val id:Int){...........}

class Student(name:String,id:Int) extends Person(name,id){............}

#父类中已经有了name,id两个字段，故子类中这两个字段可以不写定义修饰符

#调用子类时会先触发父类构造，再触发子类构造

#子类要重写父类的方法，def前要加上overwrite关键字

10、抽象类

abstract calss Person{

    def sum()

    val name:String

    .................

}

#抽象类定义时加abstract关键字，抽象类中的抽象方法和抽象属性不用加abstract关键字

#子类继承抽象类，要么子类定义成抽象类，要么去实现父类抽象类中的抽象方法和抽象属性

#抽象类不允许被new（实例化），可以通过抽象类的子类进行实例化

11、伴生类与伴生对象

class Person{....................}

object Person{...............}

#object与class名字相同，class叫做object的伴生类，object叫做class的伴生对象

#object中的方法和属性可以直接在测试类中通过"对象.方法"调用而不用实例化对象，具体可参考java中的静态类

伴生类伴生对象很重要的

12、Array

scala> val a=new Array[String](5)
a: Array[String] = Array(null, null, null, null, null)

scala> a.length
res0: Int = 5

scala> a(0)="hadoop"

scala> a(1)="hive"

scala> a(2)="scala"
 

scala> a(3)="spark"

scala> a(4)="flume"

scala> a
res7: Array[String] = Array(hadoop, hive, scala, spark, flume)

scala> a(4)="kfaka"

scala> a

res9: Array[String] = Array(hadoop, hive, scala, spark, kfaka)

scala> val c=Array(1,2,3,4,5)
c: Array[Int] = Array(1, 2, 3, 4, 5)

scala> c

res10: Array[Int] = Array(1, 2, 3, 4, 5)

scala> c.min
res11: Int = 1

scala> c.max

res12: Int = 5

scala> c.sum

res14: Int = 15

scala> c.mkString
res17: String = 12345

 

scala> c.mkString(",")
res15: String = 1,2,3,4,5

scala> c.mkString("<",",",">")

 

res16: String = <1,2,3,4,5>

 

13、ArrayBuffer（可变长度的数组）

scala>  val a=scala.collection.mutable.ArrayBuffer[Int]()
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> a+=1
res0: a.type = ArrayBuffer(1)

scala> a+=2
res1: a.type = ArrayBuffer(1, 2)

scala> a+=(3,4)
res2: a.type = ArrayBuffer(1, 2, 3, 4)

scala> a++=Array(3,4)
res3: a.type = ArrayBuffer(1, 2, 3, 4, 3, 4)

scala> a.insert(0,100)

scala> a
res6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(100, 1, 2, 3, 4, 3, 4)

scala> a.remove(0)
res7: Int = 100

scala> a
res8: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 3, 4)

scala> a.remove(3,3)

scala> a
res10: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

scala> a.trimEnd(1)

scala> a
res12: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2)

scala> a.trimStart(1)

scala> a
res14: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2)

scala> a.toArray
res15: Array[Int] = Array(2)

scala> a.toList

res16: List[Int] = List(2)

14、集合

scala> Nil
res0: scala.collection.immutable.Nil.type = List()


scala> val a=List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)


scala> a.head
res1: Int = 1


scala> a.tail
res2: List[Int] = List(2, 3, 4, 5)


scala> 12::a
res3: List[Int] = List(12, 1, 2, 3, 4, 5)


scala> val b=List(0,0,0,0)
b: List[Int] = List(0, 0, 0, 0)


scala> a:::b

res4: List[Int] = List(1, 2, 3, 4, 5, 0, 0, 0, 0)

 

15、ListBuffer

scala> val a=scala.collection.mutable.ListBuffer[Int]()
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

scala> a+=1
res5: a.type = ListBuffer(1)

scala> a+=2
res6: a.type = ListBuffer(1, 2)

scala> a+=(3,4)
res7: a.type = ListBuffer(1, 2, 3, 4)


scala> a++=List(3,4)
res8: a.type = ListBuffer(1, 2, 3, 4, 3, 4)

scala> a.insert(0,100)

scala> a
res10: scala.collection.mutable.ListBuffer[Int] = ListBuffer(100, 1, 2, 3, 4, 3, 4)

scala> a.remove(0)
res11: Int = 100

scala> a
res12: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 3, 4)

scala> a.trimEnd(1)

scala> a
res15: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 3)

scala> a.trimStart(1)

scala> a

res17: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 4, 3)

scala> a.toList
res18: List[Int] = List(2, 3, 4, 3)

scala> a.toArray
res19: Array[Int] = Array(2, 3, 4, 3)

16、Set

17、Map

 

scala> val a=Map(1 -> "David",2 -> "Alice")
a: scala.collection.immutable.Map[Int,String] = Map(1 -> David, 2 -> Alice)

scala> a(1)
res0: String = David

scala> a(2)

res1: String = Alice

scala> a.contains(1)
res3: Boolean = true

scala> a.contains(3)
res4: Boolean = false

scala> a.keys

res5: Iterable[Int] = Set(1, 2)

scala> a.values
res7: Iterable[String] = MapLike(David, Alice)

scala> a+(3 -> "Bob")

res8: scala.collection.immutable.Map[Int,String] = Map(1 -> David, 2 -> Alice, 3 -> Bob)

scala> a ++ List(4 -> "Lily",5 -> "Lucy")
res11: scala.collection.immutable.Map[Int,String] = Map(1 -> David, 2 -> Alice, 4 -> Lily, 5 -> Lucy)

scala> a-1

res12: scala.collection.immutable.Map[Int,String] = Map(2 -> Alice)

scala> res11--List(1,2)

res16: scala.collection.immutable.Map[Int,String] = Map(4 -> Lily, 5 -> Lucy)

18、值可变的Map

scala> val a =scala.collection.mutable.Map(1 -> "Lucy",2 -> "Lily")
a: scala.collection.mutable.Map[Int,String] = Map(2 -> Lily, 1 -> Lucy)

scala> a(1)="Jack"

scala> a
res1: scala.collection.mutable.Map[Int,String] = Map(2 -> Lily, 1 -> Jack)

 

19、

scala> val a=scala.collection.mutable.HashMap[Int,String]()

a: scala.collection.mutable.HashMap[Int,String] = Map()

scala> a.getOrElse(1,-1)
res1: Any = -1

 

#工作中取值一定用这种方式取值，不然会有一大堆的报错

 

scala> a(1)="Lucy"

scala> a
res3: scala.collection.mutable.HashMap[Int,String] = Map(1 -> Lucy)

scala> a(2)="Lily"

scala> a
res5: scala.collection.mutable.HashMap[Int,String] = Map(2 -> Lily, 1 -> Lucy)

scala> a-=1

 

res6: a.type = Map(2 -> Lily)

注：

键值对的遍历：

for((key,value)<-a){

println(key+":"+value)

}

或者：

for(key<- a.keySet){

println(key+":"+m.getOrElse(key,0))

}

20、scala中的接口Trait