快学Scala学习记录（一、scala简介）

一、概述

1.1面向对象特性

Scala是一种纯面向对象的语言，每个值都是对象。对象的数据类型以及行为由类和特质描述。

类抽象机制的扩展有两种途径：一种途径是子类继承，另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。

1.2函数式编程

Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。

更进一步，程序员可以利用Scala的模式匹配，编写类似正则表达式的代码处理XML数据。

二、安装

2.1下载并解压

2.2修改配置文件

vim /etc/profile

export SCALA_HOME=/usr/local/scala-2.12.8
export PATH=$PATH:$SCALA_HOME/bin

source /etc/profile

2.3验证

 三、基础语法

//声明一个常量
val answer = 2*6
//声明一个变量
var answer = 2*6
//声明常量数据类型
val answer: String = "Hello"

四、基础用法

//条件表达式
if (1>0) 1 else -1
//循环遍历
val a = "hello"
    for (i <- 0 to 4) {
      print(a(i))
    }
//双重循环并加条件
for (i <- 1 to 3; j <- 1 to 3 if (i != j)) {
      print(10 * i + j+" ")
    }
//循环添加变量
for (i <- 1 to 3; a = i - 1; j <- a to 3) {
      print(10 * i + j + " ")
    }
//for推导式
for (i <- 0 to 10) yield i % 3
//自定义函数
def sumAB(x: Int, y: Int):Int = {
      var sum = 0
      sum = x + y
      sum
    }

    print(sumAB(1, 2))
//带参数默认值的函数
    def decorate(str: String, left: String = "[", right: String = "]") = {
      left + str + right
    }

    println(decorate("A"))
    println(decorate("A","左边","右边"))
//自定义函数参数个数不限
def sum(args: Int*) = {
      var result = 0
      for (arge <- args) {
        result += arge
      }
      result
    }

    println(sum(1))
    println(sum(1, 2))
//相当于sum(1,2,3,4,5)
    println(sum(1 to 5: _*))

五、数组

//初始化数组 ，int类型默认为0，string类型默认为null，Array为定长数组
    val nums = new Array[Int](10)
    val a = Array("Hello","World")
//初始化动态数组    
    val num = new ArrayBuffer[Int]()
    num += 1
    num += (2, 3, 4)
//动态数组方法
//移除数组最后一个元素
num.trimEnd(1)
//在下标为2的元素后加上数字5,6,7
num.insert(2,5,6,7)
//移除下标为1的元素
num.remove(1)
//对当前数组进行操作
val a = Array(1, 2, 3, 4)
val b = for (i <- a) yield 2 * i
//挑选数组中的偶数进行操作
for (i <- a if i % 2 == 0) yield 2 * i

六、Map映射

 //定义Map数组并获取Key对应的值   
    val scores = Map(("Alice" -> 10), ("Bob" -> 5), ("Cindy" -> 8))
//  val scores2 = if (scores.contains("Bob")) scores("Bob") else 0
    val scores2 = scores.getOrElse("Bob",0)
    print(scores2)
//Map元素的加减
    scores += ("Sam"->3)
    scores -= "Bob"
//对Map迭代
for ((k,v)<- scores) print(k+" ")
//对Map排序
var scores = scala.collection.immutable.SortedMap(("Alice"->10), ("Cindy" -> 8),("Bob" -> 5))

七、元组

//初始化元组    
    var t = (1,3.14,"Fred")
    print(t._1)
//将元组转化为Map映射
    var t = Array("a", "b", "c")
    var num = Array(1, 2, 3)
    var pairs = t.zip(num).toMap

八、类

//新建class文件并声明两个方法
class Counter {
  private var value = 0

  def increment(): Unit = {
    value += 1
  }
  def current() = value
}
//简化定义类
class Person1(var name:String,age:Int)
//新建object文件调用方法
object ScalaTest {
  def main(args: Array[String]): Unit = {
    val myCounter = new Counter
    myCounter.increment()
    print(myCounter.current())
  }
}
//Scala默认自带getter,setter方法
class Person {
  var age =0
}
object ScalaTest {
  def main(args: Array[String]): Unit = {
    val fred = new Person
    println(fred.age)
    fred.age = 21
    print(fred.age)
  }
}
//自定义get,set方法
class Person {
  private var PrivateAge = 0
  def age = PrivateAge
  def age_(newValue: Int) {
    if (newValue > PrivateAge) PrivateAge = newValue
  }
}
    val fred = new Person
    println(fred.age)
    fred.age_(21)
//定义只有get方法，没有set方法
  private val PrivateAge = 0
  def age = PrivateAge
//定义一个没有set方法但属性值可变
class Person {
  private var value = 0
  def increment() {value += 1}
  def current = value
}
    val fred = new Person
    fred.increment()
    print(fred.current)
//匿名函数
    val values = (a:Int,b:Int)=>{a+b}
    println(values(3,4))

九、文件

//获取文件内容并转换成字符串
    val source = Source.fromFile("C://myfile.txt","UTF-8")
    //获取字符串
    var content = source.mkString
    println(content)
    source.close()
//读取文件中的字符
    val source = Source.fromFile("C://myfile.txt","UTF-8")
    //获取字符串
    val iter = source.buffered
    while(iter.hasNext){
      if (iter.next == 'H') println("H")
    }
    source.close()

10.模式匹配

object ScalaTest {
  def main(args: Array[String]): Unit = {
    val value = (1, "hello", true, 1.0, 2.0, 'h')
    val iter = value.productIterator
    while (iter.hasNext) {
      MatchTest(iter.next())
    }
  }
  //模式匹配可以匹配类型和值，从上往下匹配，匹配到就结束，匹配过程中会自动进行类型转换
  def MatchTest(o: Any): Unit = {
    o match {
      case 1 => println("value is 1")
      case i: Int => println("value is int")
      case "hello" => println("value is hello")
      case s: String => println("value is string")
      case d: Double => println("value is double")
      //"_"默认匹配，放在最后
      case _ => println("default...")
    }
  }
}

11.样例类

//当参数类型为val时，默认声明get方法。参数为var时，默认声明get，set方法，参数类型默认声明为val
case class Person(name:String,var age:Int)
object ScalaTest {
  def main(args: Array[String]): Unit = {
    val person1 =new Person("Sam",12)
    println(person1.name)
    println(person1.age)
    person1.age = 18
    println(person1.age)
  }
}

12.通信模型Actor

//Actor相当于java中的线程
object ScalaTest {
  def main(args: Array[String]): Unit = {
    val actor1 = new Actor1
    actor1.start()
    //发送消息，固定格式：消息发送者+空格+叹号+空格+消息
    actor1 ! "hello"
  }

  class Actor1 extends Actor {
     def act(): Unit = {
      receive {
        case s: String => println("value is " + s)
        case _ => println("default...")
      }
    }
  }
}