自我认知Scala

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。
Scala 运行在Java虚拟机上，并兼容现有的Java程序。

Scala 源代码被编译成Java字节码，所以它可以运行于JVM之上，并可以调用现有的Java类库。

1.object HelloWorld {
   /* 这是我的第一个 Scala 程序
    * 以下程序将输出'Hello World!'
    */
   def main(args: Array[String]) {
      println("Hello, world!") // 输出 Hello World
   }
}

2.for循环
var s = “abcde”
for(i <- s) println(i)

//定义数组
var arr = Array(1,2,3,4,5)
for(i <- arr) println(i)

//泛型
var arr = Array[Strinig](“a”,”b”,”c”)
//将一个int数组中的每个值 +1 后再生成一个数组
var arr = Array(1,2,3,4,5,6,7,8,9)
arr.map(_ + 1) //原数组不动，生成新的数组
//将偶数查出，再乘以10
arr.filter(_ % 2 == 0) 或 arr.filter(i => i % 2 == 0).map(_ * 10)

3.定义方法
def main() { println(“123”)}
// 关键字，方法名，参数，返回类型，返回结果
def m1(a: Int, b: Int) : Int = a + b
def m2(a: Int, b: Int) = {
a + b
“abc”
}
不定义返回类型会自动推断，最后一行等于返回值
Unit == void
递归方法必须有返回值类型

4.定义函数
必须有一个对象引用
val f1 = (a: Int, b: Int) => a + b

//与方法的区别，函数可以当作参数传入方法中
arr.map(_ * 100) //括号中是匿名函数
arr.map( (a: Int) => a *100 ) //与上边等价
arr.map( (a) => a *100 ) //不写类型，可自动推断
arr.map( a => a *100 ) //只有一个参数，可省略括号
优点：可以将业务逻辑封装成函数后当作参数传递，数据源不变，而不用事先写好方法（不灵活）
val f2:(Int, Double) => (Double, Int) = {(a, b) => (b, a * 10)}
val 函数名:参数 => 返回类型(多个用括号) = {(参数1, 参数2) => (返回值1, 返回值2)}

5.定义方法参数为函数
参考 def m2(a: Int) { println( a ) }
def m2(a: (Int, Int) => Int) {
val x = 4;
val y = 5;
println( a(x, y) )
}
val f2 = (i: Int, j: Int) => i * j //定义函数
m2(f2) //传参

6.var a = 0;
for( a <- 1 to 10){
println( "Value of a: " + a );
}
for( a <- 1.to(10)){
println( "Value of a: " + a );
}
to 换成 until

for( a <- 1 to 3; b <- 1 to 3){
    println( "Value of a: " + a );
    println( "Value of b: " + b );
} //双层 for 循环

Value of a: 1
Value of b: 1
Value of a: 1
Value of b: 2
Value of a: 1
Value of b: 3
Value of a: 2
Value of b: 1
Value of a: 2
Value of b: 2
Value of a: 2
Value of b: 3
Value of a: 3
Value of b: 1
Value of a: 3
Value of b: 2
Value of a: 3
Value of b: 3

7.数组
val arr = Array(“a”,”b”)
arr(0) //获取值
arr(0) = “aa” //?能否改变
val arr = new Array[Int](5) //定长数组
import scala.collection.mutable.ArrayBuffer //变长数组需要导入包
val arr = new ArrayBuffer[Int]
arr.append(1) 或 arr += 1 //增加值
arr ++= Array(3,4,5) //追加另一个集合
arr.sum、arr.max、arr.min、arr.length

8.集合
val list: List[String] = List("Runoob", "Google", "Baidu")
list.apply(2)
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable._ 包
import scala.collection.mutable._ //引入所有，不是*
val list: ListBuffer[String] = ListBuffer("Runoob", "Google", "Baidu")
val set = Set(1,2,3,4,5)
set += 6 //如果是不可变set会报错
同上需要引入mutable.Map
val map = Map[String, Int]()
map += (“a” -> 12)

9.元组
val t = (1, 3.14, "hello")
t._1 //结果是 1
t._2 //结果是 3.14
t._3 //结果是 Fred
val t = new Tuple3(1, 3.14, "hello")

10.wordcount——统计数字出现次数，排序

val line = "hello world da jia hao hello all hello kitty"
line.split(" ") == 一个数组，
//如果是一个多行数组
val arr = Array("hello world", "da jia hao", "hello all hello kitty")
arr.map(l => l.split(" "))
arr.map(l => l.split(" ")).flatten 等价于 arr.flatMap(l => l.split(" "))
最终简写：arr.flatMap(_.split(" "))
将单词转成元组：arr.flatMap(_.split(" ")).map((_, 1))
arr.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1) //按元组1分组
……上略：.map(t => (t._1, t._2.length)) //元组2的个数
排序：.toList.sortBy(_._2).reverse //map无法排序转list，按Tuple2

11.对象，类
一个Scala源文件中可以有多个类，类名和文件名不必一致

import java.io._

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);
   }
}

12.伴生对象
伴生对象：与类共享名字，可以访问类的私有属性和方法（同文件中）
private[this] //彻底私有，伴生对象也不可访问
object 类名 //静态，可直接访问其属性，没有构造器
class 类名 //需要new，才可访问其属性
主构造器的参数可当作类属性
class Test(var a: Int) { }
val t = new Test(100)；println(t.a) //没错
辅助构造器：def this(a: Int, b: Int){ this(a) } //第一行必须调一下主构造器
class 类名 private[包名] (var i: Int) { } //该类只能被本包或子包类调用

13.特性
实现接口用 extends ，如果多个后面用 with
object：静态对象、单例对象、伴生对象
extends App //继承App对象不用写main方法
match匹配：
object Test {
def main(args: Array[String]) {
println(matchTest(3))
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
:: 代表拼接 val list = "Facebook" :: ("Taobao" :: Nil)
case class；case object；类对象可以模式匹配
Option 子类 final case class Some 和 case object None，Map[Int].get(“key”)返回对象是option

14.并行计算
list.par //
list.aggregate(0)(_+_.sum, _+_)