Scala 使用

一. 安装环境

wget https://downloads.lightbend.com/scala/2.12.6/scala-2.12.6.tgz

vi ~/.bash_profile

export PATH=$SCALA_HOME/bin:$PATH

 

二. 运行

Scala是解释性JVM语言，编译后会生成*.class。也可在交互式CLI上编码。

ling-Pro:~ sun$ scala
Welcome to Scala 2.12.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_102).

scala> var list = List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> println("hello world")
hello world

 

三. 示例

新的语言总会有一些奇怪的语法或表达式。

//import java.util._			// All
//import java.awt.{Color, Font}  // Part

/**
 * trait相当于Interface，但可有方法体，支持多重继承
 */
trait MyTrait {
	def show()
	def foo(){
		println("Hello foo")
	}
}

/// Impl
class MyTraitImpl extends MyTrait{
	def show(){
		println("Hello show")
	}
}


/// Objec
object Test {
	def init(): String = {
		println("Init var")
		return "kettas"
	}

	/**
	 * 默认访问修饰符为 public
	 * 测试返回多个元素(元组)
	 * ReturnType = {}	比较奇怪
	 */ 
	def getMulit(a: Int) : Tuple2[Int, String] = {
		return (a, "Hello")
	}

	// 测试类型
	def testType(){
		var mystr:String = "hello"	
		var myVar = 10		// 类型推断
		val myVar1 = "world"

		// lambda
		val f = (x: Int) => x+3
		Console.println(f(5))
	}

	// 测试for循环
	def testLoop(){
		var list = List(1,2,3,4,5,6)

		// foreach <-操作符
		for (a <- list)
		{
			Console.print(a + "\t")
		}

		// range
		for (a <- 1 to 10)
		{
			Console.print(a + "\t")
		}

		Console.println()
	}

	/**
	 * 测试容器
	 * Uint =  相当于 void, 可省略
	 */
	def testContainer(): Unit = {
		val map: Map[Int, String] = Map(1 -> "hello", 2 -> "world")
		val v1: Option[String] = map.get(1)		// 可选值结构
		val v2: Option[String] = map.get(3)

		// Option vs Some
		println(v1)
		println("v1: " + v1.get)	// Some(hello) Some是一个类，通过some.get获取值
		println("v2: " + v2)	// None

		// 获取元组
		val tuple = getMulit(5)
		println(tuple._1)
		println(tuple._2)

		// ++操作符，用于连接两集合
		val l1 = List(1, 2)
		var l2 = List(3, 4)
		var l5 = l1 ++ l2	// (1,2,3,4)

		// 可变容器，链表实现
		val buf = collection.mutable.ListBuffer.empty[Int]
		buf += 1
		buf += 10 
		println(buf.toList)	// 1,10
	}

	/**
	 * lazy关键字使用
	 * 借鉴懒汉式单例模式实现思想，使用变量时才初始化
	 *
	 */
	def testLazy(){
		lazy val a = init();
		println("After init")
		println(a)		// After init; Init var; kettas
	}

	// main
	def main(args: Array[String]){
		// 基本类型测试
		testType()

		// 循环测试
		testLoop()

		// 容器测试
		testContainer()

		// 懒加载
		testLazy()

		// 测试类
		val p = new MyTraitImpl()
		p.show()
	}
}

 

 四. 其它语法

4.1 App

App 类连main方法都封装了，不过采用延迟加载方式。

object HelloScala extends App { 
	println("Hello scala!") 
}

 运行输出：Hello scala!

 

4.2 case语法

 1. case match

与java switch语法类似，新增=>操作分隔模式和表达式。

def matchTest(x: Int): String = x match {
  case 1 => "one"
  case 2 => "two"
  case _ => "many"
}

println( matchTest(1) )		// one

 

2. case class

// case类默认不可变，可通过模式匹配分解
case class Person(name: String, age: Int)

val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)

// 遍历用户列表
for (person <- List(alice, bob, charlie)) {
	person match {
		case Person("Alice", 25) => println("Hi Alice!")
		case Person("Bob", 32) => println("Hi Bob!")
		case Person(name, age) =>
		   println("Age: " + age + " year, name: " + name + "?")
	}
}

输出： 

Hi Alice!

Hi Bob!

Age: 32 year, name: Charlie?

 

五. Akka框架

Akka 是一组构建高并发，分布式，弹性消息驱动应用工具库，便于构建JVM的并发应用和分布式应用，支持java/scala。

 

基础示例：

import akka.actor._
import akka.util._
 
/** Simple hello from an actor in Scala. */
object Hello1 extends App {
  // 配置 
  val system = ActorSystem("actor-demo-scala")
  val hello = system.actorOf(Props[Hello])

  hello ! "Bob"		// ! 运算符是 Akka 中表示将一条消息发送到 actor 的便捷方式
  Thread sleep 1000
  system shutdown
  
  // 接收器 
  class Hello extends Actor {
    def receive = {
      case name: String => println(s"Hello $name")   // s 字符串插值器
    }
  }
}

 

 

 

 

参考：

https://akka.io