Scala快速概览

时间：2016-10-11 21:38:14 阅读：241 评论：0 收藏：0 [点我收藏+]

标签：

IDEA工具安装及scala基本操作

一、安装Scala. 3

1、确保Java安装成功... 3

2、解压scala-2.10.4.tgz. 3

3、配置Scala环境变量... 3

4、启动Scala命令行... 3

二、 Windows下安装IDEA的Scala插件... 3

1、在IDEA中File打开Setting. 3

2、安装Scala插件... 4

3、重启IDEA后，新建项目对话框，就可以看到Scala模板。... 5

三、 HelloWord. 6

1、下载Window版本的Scala-2.10.4. 6

(5) break、coutinue. 13

1、确保Java安装成功

[hadoop@spark01-61cdh scala-2.10.4]$ java -version

java version "1.7.0_111"

[hadoop@spark01-61cdh scala-2.10.4]$ echo $JAVA_HOME

/opt/modules/jdk1.7.0_6

2、解压scala-2.10.4.tgz

[hadoop@spark01-61cdh modules]$ tar -zxf /opt/software/scala-2.10.4.tgz -C /opt/modules/

3、配置Scala环境变量

export SCALA_HOME=/opt/modules/scala-2.10.4/bin

export PATH=$PATH:$SCALA_HOME

[hadoop@spark01-61cdh scala-2.10.4]$ source /etc/profile

4、启动Scala命令行

直接输入scala，回车就进入scala命令行。

[hadoop@spark01-61cdh scala-2.10.4]$ scala

-bash: scala: command not found

[hadoop@spark01-61cdh scala-2.10.4]$ sudo vim /etc/profile

[hadoop@spark01-61cdh scala-2.10.4]$ source /etc/profile

[hadoop@spark01-61cdh scala-2.10.4]$ scala

Welcome to Scala version 2.10.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_67).

Type in expressions to have them evaluated.

Type :help for more information.

scala>

二、 Windows下安装IDEA的Scala插件

1、在IDEA中File打开Setting

左边选择Plugins，在右侧的查找框中找Scala，看是否已经安装了，如果没有安装，则点击下面的“Install JetBrains Plugin…”进行安装Scala插件。

技术分享

2、安装Scala插件

搜索Scala，右侧点击Intall进行下载安装。

技术分享

3、重启IDEA后，新建项目对话框，就可以看到Scala模板。

技术分享

三、 HelloWord

1、下载Window版本的Scala-2.10.4

2、创建项目

技术分享

Scala SDK版本选择时，点击Create按钮，在打开的对话框中点击Browse，找到Scala目录下的lib目录。

技术分享

3、创建程序目录

File中点击Project Structure，左侧选择Modules，在右侧代码目录下创建如下目录。

技术分享

4、创建包

创建一个包：scala.com.chybinmy.scala.spark

5、创建一个Object

技术分享

这里选择Object类型。

6、写main方法

package scala.com.chybinmy.scala.spark

  

  /**

  * Created by 鸣宇淳 on 2016/9/27.

  */

  object HelloWorld {

  def main(args: Array[String]) {

    println("Hello World!")

  }

}

7、运行程序

在代码编辑页面右击选择Run “Hello World”，进行运行，可以看到输出了“Hello World!”

技术分享

四、 Scala基本语法

1、函数

(1) 最典型的函数

def max(x: Int, y: Int): Int = {

  if (x > y)

    x

  else

    y

}

² def关键字是定义一个max

² max是函数名称

² x是第一个参数名，:Int是指定参数x的类型为Int，y是第二个参数名称

² 小括号后面的：Int是表示函数返回值为Int

² =后面是函数体，=符号可以理解为将后面的函数体赋值给前面的函数定义。当函数显示地指定了返回值时，这个=是不可以省略的，如果没有显示定义返回值可以省略这个=。

² Scala和JavaScripte里类似，一行的结束可以不用分号;

² Scala的函数可以没有return，运行时，执行的最后一条语句的返回值就是函数的返回值。

在Scala命令行中运行函数定义和调用：

scala> def max(x:Int,y:Int):Int={ //定义函数

| if(x>y)

| x

| else

| y

| }

max: (x: Int, y: Int)Int

scala> max(2,3) //调用函数

res0: Int = 3

(2) 无参数，无返回值的函数

def add1() = {

  println("add1....")

}

  

  //无参数的函数可以省略 =

  def add2() {

  println("add2....")

}

  

  //无返回值的函数，返回值其实是Unit类型的，

  // Unit可以省略，就像第一个add1一样

  def add3(): Unit = {

  println("add3....")

}

调用时，如果函数没有参数，可以省略()

scala> def add3(): Unit = {

| println("add3....")

| }

add3: ()Unit

scala> add3 //可以省略()

add3....

(3) 函数体就一行代码时

//当函数体只有一行代码时，可以将花括号{}省略

  //所以当无参数、无返回值、一行代码的函数，可以写为这样

  def add4() = println("add3....")

(4) 匿名函数

//一个函数

def add5(x: Int, y: Int) = x + y

//改为匿名函数

  (x: Int, y: Int) => x + y

匿名函数的函数体前面要用 => 符号。

(5) 将函数赋值为常量

//将匿名函数赋值给常量

  val add6=(x: Int, y: Int) => x + y

//一个无参数函数

  def add8() = println("add8")

  //一个有参数函数

  def add9(x: Int, y: Int) = x + y

  

  //将无参数函数赋值给常量

  val add10 = add8;

  //将有参数函数赋值为常量，必须加 _

  val add11 = add9 _;

(6) 在函数中调用函数

如果想将上面的add6传递给另外一个函数add7，add7应该定义如下：

//将函数赋值给函数

  def add7(f: (Int, Int) => Int): Int = {

  f(3, 8)

}

上面的(Int,Int)=>Int是定义了一个类型，类型是个匿名函数，参数f的类型就是个函数，这个函数的输入参数是两个Int类型的值，返回值也是个Int类型的值，另外add7函数的返回值也是个Int类型。

函数体中f(3,8)是说，函数体是去执行输入的那个匿名函数。

(7) 默认参数值

//name参数可以不传递，不传递时使用默认值：xiaoming
def sayName(name: String = "xiaoming") {
println("Hello!" + name)
}

定义函数时可以给参数指定一个默认值，当不传递这个函数时函数体就使用指定的默认值。一般惯例是将有默认值的参数参数列表的最后面。

(8) 变长函数

def printCourse2(course: String*): Unit = {
course.foreach(x => println(x))
}

def printCourse(course: String*): Unit = {
var txt = "";
course.foreach(x => (txt += (x + ",")))
println("input：" + txt)
}

在Scala中，定义函数时，最后一个参数可以变长，变长的意思是：参数的个数不确定，可以有很多个，类型后面添加一个*字符表示这个参数是可以变长的，调用时如下：

printCourse2("a","b","c")

2、循环

(1) 循环表达式

² 1 to 10：循环1到10，包括1和10，包头包尾。

² 1.to(10) 同1 to 10

² 1 until 10 : 循环1到10，不包含10，包头不包尾。

² 1.until(10) 同 1 until 10

² Range(1,10) 同 1 to 10

² Range(1,10,2) 是从1到10，步长为2，就是循环1、3、5、7、9

(2) for 循环

def main(args: Array[String]) {
var sum = 0;
for (i <- 1 to 10) {
sum += i
}
println(sum)
}

参与循环的变量i与i取值范围之间用<-表示。

1 to 10明确表明了取值范围是1到10，包括1和10。

sum = 0
for (i <- 1 until 10)
sum += i
println(sum)

until是不包括10的，取值是1到9

for (c <- "Hello")
println(c)

遍历字符串并不需要下标。

(3) for循环嵌套

for (i <- 1 to 3; j <- 1 to 3)

  println(i.toString + j.toString)

(4) for循环中判断

for (i <- 1 to 3; j <- 1 to 3 ; if i>j)

  println(i.toString + j.toString)

(5) break、coutinue

Scala中没有break和coutinue关键字，如果想实现类似功能，可以使用scala.util.control.Breake来是实现。

object BreakDemo {
def main(args: Array[String]) {
    //定义一个集合
    val numList = List(1, 2, 3, 4, 5, 6, 7, 8)
    //实例化一个Breaks对象，
    val loop = new Breaks
    loop.breakable(
      //将循环放入loop.breakable中
      for (num <- numList) {
        println(num)
        if(4==num)
          {
            //使用loop.break()方法来实现跳出
            loop.break()
          }
      }
    )
}
}

3、数组

(1) 定长数组

² 定长数组定义：val list=Array(1,2,3,4,5) 或者 val list2=new Array[Int](5)

² 赋值：list(0)=11。下标用小括号来指定，而不像Java中一样用方括号。

(2) 变长数据

² 变长数组定义：val listBuffle=scala.collection.mutable.ArrayBuffer[Int](1,2,3)

² 添加一个元素：listBuffle+=2 添加一个元素2。

² 添加多个元素：listBuffle++=Array(5,6,7) 添加了三个元素到变长数组里。

listBuffle+=(8,9,10) 添加了一个元组。

² 插入元素：listBuffle.insert(0,0)在0的位置插入一个值0。

² 删除元素：listBuffle.remove(4) 删除4位置的元素。

(3) 变长数据转为定长数组

scala> listBuffle.toArray

res17: Array[Int] = Array(0, 1, 2, 3, 5, 6, 7, 8, 9, 10)

(4) 遍历数组

for(i<-listBuffle) println(i)

(5) 数组变长字符串

listBuffle.mkString("|") 将数组变为字符串，用 | 字符隔开

listBuffle.mkString("[","|","]") 将数组变为字符串，用|隔开，前面添加[，后面添加]。

4、元组

元组是可以存储不同类型元素的集合。

有两个元素的元组叫二元组。

(1) 定一个元组

scala> val tuple=(1,2,4,"a")

tuple: (Int, Int, Int, String) = (1,2,4,a)

元组在Spark中很常见，比如key、value对可能就是个元组，{1001:”beijing”}

(2) 获取元素

可以用tuple._1获取第一个元素，注意元素的下标从1开始。

(3) 遍历元组

for(i<- 1 to tuple.productArity-1 ) println(tuple.productElement(i))

² tuple.productArity是获取元组的长度

² tuple.productElement是获取元组的某一个下标的元素，请注意这里的下标是从0开始。

5、集合

(1) Scala集合介绍

² Scala有一个非常丰富、强大可组合的集合库，集合都在scala.collection包中。

² Scala集合中有定长集合和变长集合，定长集合在scala.collection. immutable中，变长集合在scala.collection. mutable中

(2) Scala集合结构

技术分享

(3) List集合

² 定义一个List：val list=List(1,2,3,4,5)

² List由head和tail组成：

scala> list.head

res34: Int = 1

scala> list.tail

res35: List[Int] = List(2, 3, 4, 5)

head是集合中第一个元素，tail是除了head外的其他元素组成的集合，也就是tail是个List集合，tail也有head和tail，如下：

scala> list.tail.tail.tail

res36: List[Int] = List(4, 5)

² 空集合用Nil表示，同List()

² 另外一种定义集合方式，是用head和tail方式定义，如下：

//head为1，tail为空集合

scala> var list2=1::Nil

list2: List[Int] = List(1)

//head为2，tail为一个集合

scala> var list3=2::list2

list3: List[Int] = List(2, 1)

//另一种定义方式

scala> var list4=1::2::3::list3

list4: List[Int] = List(1, 2, 3, 2, 1)

//上面方式可以理解为这种方式

scala> var list5=(1::(2::(3::list3)))

list5: List[Int] = List(1, 2, 3, 2, 1)

² List转换为数组

scala> list.toArray

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

² List中添加、减少元素

List是定长集合，所以不能添加元素，但是变长List可以添加元素。

//定义一个变长集合

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

list2: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

//添加元素

scala> list2+=2

res4: list2.type = ListBuffer(2)

//添加一个元组

scala> list2+=(3,4)

res5: list2.type = ListBuffer(2, 3, 4)

//添加一个集合

scala> list2++=List(5,6)

res6: list2.type = ListBuffer(2, 3, 4, 5, 6)

//减少一个元素

scala> list2-=3

res7: list2.type = ListBuffer(2, 4, 5, 6)

//减少一个集合

scala> list2--=List(5,4)

res8: list2.type = ListBuffer(2, 6)

(4) Set

² Set中的元素是无序不重复的集合。

² 定义一个Set集合：scala> var set=Set(1,2,3,4,5)

² 定义要给可变长Set集合：val set1=scala.collection.mutable.Set[Int]()

² 对变长Set集合，+ 、+=、++=是不同的

set1+1是创建另外一个可变Set集合，内容为添加了一个1。

set1+=1 是在原来的Set集合中添加一个元素1

(5) Map集合

² Map是键值对的集合

² 定义一个定长Map: scala> val map=Map("zhangsan"->20,"lisi"-> 25)

² 获取值

scala> map("zhangsan") 是根据key获取值。

scala> map.getOrElse("zhangsan",0) 根据Key获取值，如果是空则返回0。

² 赋值

同Set一样，只有可变的Map集合才能赋值。

--定义一个可变的Map

scala> val b=scala.collection.mutable.Map("zs"->20,"lisi"->30)

b: scala.collection.mutable.Map[String,Int] = Map(lisi -> 30, zs -> 20)

--第一种赋值方式，添加一个wangwu

scala> b("wangwu")=35

--显示当前b的内容

scala> b

res1: scala.collection.mutable.Map[String,Int] = Map(lisi -> 30, zs -> 20, wangwu -> 35)

--第二种，添加内容方式，用+=

scala> b+=("wangma"->35,"hanliu"->40)
--删除内容，用-=

scala> b-="zs"

² 遍历Map

//第一种遍历方法

scala> for((key,value)<-b)

| println("key="+key+",value="+value)

key=lisi,value=30

key=wangma,value=35

key=hanliu,value=40

key=wangwu,value=35

//第二种遍历方式

scala> for(ele <- b.keySet)

| println("key="+ele+",value="+b.getOrElse(ele,0))

key=lisi,value=30

key=wangma,value=35

key=hanliu,value=40

key=wangwu,value=35

//只遍历值

scala> for(ele<-b.values)

| println("value="+ele)

value=30

value=35

value=40

value=35

//遍历的另外一种方式，value不一定有值时

scala> for((key,_)<-b)

| println("key="+key+",value="+b.getOrElse(key,0))

key=lisi,value=30

key=wangma,value=35

key=hanliu,value=40

key=wangwu,value=35

6、模式匹配

Java中只能对数值进行模式匹配，但是在Scala中，除了可以对值进行模式匹配外，还可以对类型进行模式匹配，对Array和List的元素进行匹配、对case class进行匹配、甚至对有值或者没有值进行匹配。

(1) 模式匹配值

package scala.com.chybinmy.scala.spark

  object MatchDemo {

  def main(args: Array[String]) {

    judge("A")

    judge("E")

  }

  

  def judge(tag: String): Unit = {

    tag match {

      case "A" => println("Excellent")

      case "B" => println("Good")

      case "C" => println("Just so so")

      case _ => println("You need word hard")

    }

  }

}

def judge(tag: String,name:String): Unit = {
tag match {
    case "A" => println("Excellent")
    case "B" => println("Good")
    case "C" => println("Just so so")
    case _ if name.equals("xiaoming")=>println(name+",come on!")
    case _ => println("You need word hard")
}
}

(2) 匹配类型

package scala.com.chybinmy.scala.spark
object ExceptionTest extends App {
try {
    val i = 1 / 0
}
catch {
    case e: ArithmeticException => throw new RuntimeException("not zero!")
    case e: Exception => println(e.getMessage)
}
finally {
    println("finally")
}
}

当匹配类型时，case 后面的e为变量名，冒号后面的是要匹配的类型名称。

(3) 匹配classs

package scala.com.chybinmy.scala.spark

class Person
case class Teacher(name: String, subject: String) extends Person
case class Student(name: String, classroom: String) extends Person

object CaseMathTest {
def judge(person: Person): Unit = {
    person match {
      case Teacher(name, subject) => println("Teacher:" + name + "," + subject)
      case Student(name, classroom) => println("Student:" + name + "," + classroom)
      case _ => println("error!")
    }
}

def main(args: Array[String]) {
    judge(new Teacher("xuanyu","spark"))
    judge(new Student("ming","7 ban"))
    judge(null)
    judge(new Person)
}
}

(4) 匹配Option

Scala中的Option是一种特殊的类型，Option有两种值：Some表示有值，None表示没有值。模式匹配Option用于判断某个变量有值还是没有值。

package scala.com.chybinmy.scala.spark

object OptionMathDemo {
def getGrade(name: String): Unit = {
    val grades = Map("xx" -> "A", "yy" -> "B", "zz" -> "C")
    val g = grades.get(name)
    g match {
      case Some(course) => println(name + ",your grade is " + course)
      case None => println(name + ",no your grade")
    }
}

def main(args: Array[String]) {
    getGrade("xx")
    getGrade("aa")
}
}

7、异常处理

package scala.com.chybinmy.scala.spark

  object ExceptionTest extends App {

  try {

    val i = 1 / 0

  }

  catch {

    case e: ArithmeticException => throw new RuntimeException("not zero!")

    case e: Exception => println(e.getMessage)

  }

  finally {

    println("finally")

  }

}

8、高阶函数

输入参数的类型为函数的函数为高阶函数（higher-order function）。

package scala.com.chybinmy.scala.spark
object HigherDemo {

//定义一个高阶函数
def greetin(f: (String) => Unit, name: String): Unit = {
    f(name)
}

def main(args: Array[String]) {
    //定义一个函数赋值为常量
    val sayHelloFunc = (name: String) => println("Helllo!" + name)
    //将函数类型的常量做为参数，传递给高阶函数
    greetin(sayHelloFunc, "老王！")

    //将一个匿名函数做为参数传递给高阶函数
    greetin((name: String) => println(name + "好！"), "张sir")

    //省略匿名函数参数的类型
    greetin((name) => println(name + "hao"), "小明")

    //如果只有一个参数，可以省略括号
    greetin(name => println("早" + name), "小红")

    //List.map是个高阶函数
    var list = List(1, 2, 3, 4, 5)
    println(list)
    println(list.map((x: Int) => x + 1))
    println(list.map(x => x + 1))
    //只有一个参数，并函数体中只用到一个这个参数，可以用_表示
    println(list.map(_ + 1))
}
}

将函数做为参数传递给另外一个函数，是一种封装。

9、隐式转换

(1) 一个例子

package scala.com.chybinmy.scala.spark

  

  //定义一个特殊人群类

  class SpecialPerson(val name: String)

  //定义一个学生

  class Stu(val name: String)

  //定义一个老人类

  class Older(val name: String)

  

  object ImplicitDemo {

  def main(args: Array[String]) {

    //将Stu类型隐式转换为SpecialPerson类型

    val stu = new Stu("xiaoping")

    val ticket = buySpecialTicker(stu)

    println("Buy ticket:" + ticket)

  

    //将Oler类型隐式转换为SpecialPerson类型

    val older = new Older("laoli")

    val ticket2 = buySpecialTicker(older)

    println("Buy older ticket:" + ticket2)

  }

  

  //买票函数，这个函数定义输入参数是SpecialPerson类型的

  var ticketNumber = 0

  def buySpecialTicker(p: SpecialPerson): String = {

    ticketNumber += 1

    "T-" + ticketNumber

  }

  

  //定义一个隐式转换函数，定义了那些类型可以隐式转换为SpecialPerson

  implicit def objectToSpecialPerson(obj: Object): SpecialPerson = {

    if (obj.getClass == classOf[Stu]) {

      val stu = obj.asInstanceOf[Stu]

      new SpecialPerson(stu.name)

    }

    else if (obj.getClass == classOf[Older]) {

      val older = obj.asInstanceOf[Older]

      new SpecialPerson(older.name)

    }

    else

      new SpecialPerson("未知名字")

  }

}

这段程序是特殊人群买票的例子，objectToSpecialPerson定义了Stu类和Older类可以隐式转换为SpecialPerson类，所以虽然buySpecialTicker函数的输入参数为SpecialPerson类型，但是调用时，可以传递Stu和Older类型的值进去，因为自动做了隐式转换。