Scala學習筆記2

rilley發表於2014-09-22

object Basic extends App
{
    /*
    class WordCount
    {
        // Java
        public static void main(String[] args)
        {
            String tx = "Good morning !It is really my honor to have this opportunity is for a interview,I hope i can make is a good performance today";
 
            Map<String, Integer> count = new HashMap<String, Integer>();
            for (String word : tx.split(" ")) {
                int number = count.containsKey(word) ? count.get(word) : 0;
                count.put(word, number + 1);
            }
        }
    }
    */
 
 
    /*
    <?PHP
    // PHP
    $text = "Good morning !It is really my honor to have this opportunity is for a interview,I hope i can make is a good performance today";
 
    foreach (explode(" ", $text) as $w) $count[$w] += 1;
    ?>
    */
 
 
    /*
    # python
    text = "Good morning !It is really my honor to have this opportunity is for a interview,I hope i can make is a good performance today"
 
    count = {}
    for word in text.split(" "): count[word] = count[word] + 1 if word in count else 1
    */
 
 
    /*
    // Scala
    object WordCount extends App
    {
        val text = "Good morning !It is really my honor to have this opportunity is for a interview,I hope i can make is a good performance today"
 
        (Map[String, Int]() /: text.split(" ")) { (i, j) => i(j) = i.getOrElse(j, 0) + 1; i }
    }
    */
 
 
 
    // 基本型別
    //Byte, Char, Short, Int, Long, Float, Double, Boolean
    1.toChar; "10".toInt
 
 
 
   // 變數 不變數 其中var 與 val 的區別在於，var 是變數，以後的值還可以改變， val的值只能在宣告的時候賦值，但是val不是常量，只能說是不變數或只讀變數
    val answer = 8 * 5 + 2
    var conter = 0
    val greeting: String = "Hello"
 
 
 
    // 列印
    print("Answer: ")
    println("53")
 
 
 
    // 高階For迴圈
    1 to 10 // Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    1 until 10 // Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
 
    for (i <- 1 to 10) print(_)
    for (i <- 1 to 10; if i % 2 == 0) print(_)
    for (i <- 1 to 3; j <- 1 to 3 if i != j) print((10 * i + j) + " ") // 12 13 21 23 31 32
    for (i <- 1 to 3; a = 4 - i; j <- a to 3) print((10 * i + j) + " ") // 13 22 23 31 32 33
 
 
 
    // 匹配模式
    val num = 10
    num match {
        case x if x == 1 => println("one, a lonely number")
        case x if (x == 2 || x == 3) => println(x)
        case _ => println("some other value")
    }
    val m = num match {
        case x if x == 10 => 5
        case "4" => 6
        case _ => 9
    }
 
 
    // 函式
    // 函式定義：
    def 方法名(引數名: 引數型別): 返回型別 =
    {
        //block內最後一一行行為返回值
    }
 
    當返回值為Unit時可以定義為:
    def 方法名(引數名: 引數型別)
    {
        //code
    }
 
 
    // 在Scala中，你需要為函式引數指定型別簽名。
    def addOne(m: Int): Int =
    {
        m + 1
    }
    addOne(2) // 3
    // 如果函式不帶引數，你可以不寫括號。
    def three() = 1 + 2
    def three = 1 + 2
    three // 3
 
 
    // 匿名函式
    // 你可以傳遞匿名函式，或將其儲存成不變數。
    val addTwo = (x: Int) => x + 1
    addTwo(1) // 2
    { i: Int =>
        println("hello world")
        i * 2
    }
 
 
    // 可變長度引數
    // 這是一個特殊的語法，可以向方法傳入任意多個同型別的引數。例如要在多個字串上執行String的capitalize函式，可以這樣寫：
    def capitalizeAll(args: String*) =
    {
        args.map { arg =>
            arg.capitalize
        }
    }
    capitalizeAll("rarity", "applejack") // ArrayBuffer(Rarity, Applejack)
 
 
    // 偏函式
    trait PartialFunction[A, B] extends (A) => B
 
    // 偏函式recieve在akka的Actor起到關鍵作用。例如：
    case object Greet
    case class WhoToGreet(who: String)
    case class Greeting(message: String)
 
    class Greeter extends Actor
    {
        var greeting = ""
        def receive : Actor.Receive =
        {
            case WhoToGreet(who) => greeting = s"hello, $who"
            case Greet           => sender ! Greeting(greeting)
        }
    }
    //而Actor.Receive的定義為：type Receive = PartialFunction[Any, Unit]
    //偏函式receive以case object, case class為message Domain，返回Unit (即receive不會返回一個普通型別（如：String, Int等）值)

object Collection extends App
{
    // Map List Tuple Array Set Queue Stack
 
    // Array
    // 10個正數的陣列，所有元素初始化為0
    val nums = new Array[Int](10);
    val array = Array("Hello", "World")
 
    // 變長陣列
    import scala.collection.mutable.ArrayBuffer
 
    val b = ArrayBuffer[Int]()
 
    b += 1
    b += (1, 2, 3)
    b ++= Array(1, 2, 3)
    b(0) // 取值
 
    // 迭代
    for (e <- b) println(e)
    b.foreach(e => println(e))
    b.foreach(println(_))
    b foreach println
 
    // Map
    import scala.collection.mutable.Map
 
    val source = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 5)
    val jMap: HashMap[String, Int] = new HashMap[String, Int]()
 
    val item = source("Bob")
    source("Fred") = 7
    source += ("Bob" -> 10, "Fred" -> 7)
 
    for ((k, v) <- source) println(s"$k => $v")
 
    // Tuple
    val tuple = (1, 3,14, "Fred")
 
    // Tuple3[Int, Doubel, java.lang.String]
    println(s"$tuple._1, $tuple._2, $tuple._3")
 
    // 模式匹配獲取元祖
    val (first, second, third) = tuple
 
    // List
    import scala.collection.mutable.ListBuffer
 
    val list = ListBuffer[Int]();
    list += 1
    list += 2
    list ++= List(3, 4, 5)
    list(0) + list(1) + list(2)
 
    // method [foreach filter map reduce sum max min count partition zip mkString]
    val names = List("Peter", "Paul", "Mary")
    val numbers = List(1, 2, 3, 4)
 
    // filter 移除任何使得傳入的函式返回false的元素。返回Boolean型別的函式一般都稱為斷言函式。
    names.filter(_.length < 5) // List("Paul", "Mary")
    numbers.filter((i: Int) => i % 2 == 0) // List(2, 4)
 
    def isEven(i: Int): Boolean = i % 2 == 0
    numbers.filter(isEven _) // List(2, 4)
 
    // map 在列表中的每個元素上計算一個函式，並且返回一個包含相同數目元素的列表。
    names.map(_.toUpperCase) // List("PETER", "PAUL", "MARY")
    numbers.map((i: Int) => i * 2) // List(2, 4, 6, 8)
 
    // foreach和map相似，只不過它沒有返回值，foreach只要是為了對引數進行作用。
    numbers.foreach((i: Int) => i * 2) //
 
    // reduce reduceLeft接受一個接受兩個引數的函式，reduceLeft會依次把前一次得到的結果和下一個列表元素傳遞給函式，最後得到一個單個元素
    List(2,4,6).reduceLeft(_+_) // 12   相當於: ((2 + 4) + 6)
    List(1,4,9,6,7).reduceLeft( (x,y)=> if (x>y) x else y ) // 9    ((((1 max 4) max 9) max 6) max 7)
 
    // sum max min count
    numbers.sum // 10
    numbers.max // 4
    numbers.min // 1
    numbers.count(_ > 0) // 4
 
    // partition
    val numList = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    numList.partition(_ % 2 == 0) // (List(2, 4, 6, 8, 10), List(1, 3, 5, 7, 9))
 
    // zip
    List(1, 2, 3).zip(List("a", "b", "c")) // List((1,a), (2,b), (3,c))
 
    // mkString
    names.mkString(", ") // Peter, Paul, Mary
    names.mkString("<", ", ", ">") // <Peter, Paul, Mary>
}

object Example extends App
{
    // 快速排序
    object QuickSort
    {
        def main(args: Array[String]): Unit =
        {
            var arrays = Array(123, 343, 5435, 23, 3213);
            println("排序前的結果");
            arrays.foreach(println)
            arrays = sort(arrays);
            println("排序後的結果");
            arrays.foreach(println)
        }
 
        def sort(xs: Array[Int]): Array[Int] =
        {
            if(xs.length <= 1)
                xs;
            else {
                val pivot = xs(xs.length / 2);
                Array.concat(
                    sort(xs filter (pivot > _)), xs filter (pivot == _), sort(xs filter (pivot < _))
                )
            }
        }
    }
 
    // 使用蒙特卡洛方法計算Pi值
    object SparkPi
    {
        def main(args: Array[String])
        {
            val conf = new SparkConf().setAppName("Spark Pi")
            val spark = new SparkContext(conf)
 
            val slices = if (args.length > 0) args(0).toInt else 2
            val n = 100000 * slices
 
            val count = spark.parallelize(1 to n, slices).map { i =>
                val x = random * 2 - 1
                val y = random * 2 - 1
                if (x * x + y * y < 1) 1 else 0
            }.reduce(_ + _)
 
            println("Pi is roughly " + 4.0 * count / n)
            spark.stop()
        }
    }
}

object Object extends App
{
    // 類
    class Calculator
    {
        val brand: String = "HP"
        @BeanProperty var color: String = _
        def add(m: Int, n: Int): Int = m + n
    }
 
    val calc = new Calculator
 
    calc.add(1, 2) // 3
    calc.brand // "HP"
    calc.brand = "PH"
    // 在Scala中getter和setter方法並非被命名為getXxx和setXxx,不過他們的意思是相同的
 
 
    /* Java
    public class Person
    {
        private int age;
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }
    }
    */
 
 
    // 繼承
    class ScientificCalculator(brand: String) extends Calculator(brand)
    {
        def log(m: Double, base: Double) = math.log(m) / math.log(base)
    }
 
 
 
    // 過載 & 重寫
    class EvenMoreScientificCalculator(brand: String) extends ScientificCalculator(brand)
    {
        def log(m: Int): Double = log(m, math.exp(1))
        override def add(x: Int, y: Int) = x + y
    }
 
 
    // 抽象類 你可以定義一個抽象類，抽象類可以定義一些方法，但是不需要實現它們。相反，繼承抽象類的子類需要實現這些方法。抽象類是不能被例項化的。
    abstract class Shape
    {
        def getArea():Int // subclass should define this
    }
 
    class Circle(r: Int) extends Shape
    {
        def getArea():Int = { r * r * 3 }
    }
 
 
    // 不能例項化一個抽象類
    val s = new Shape // error: class Shape is abstract; cannot be instantiated val s = new Shape
    val c = new Circle(2)
 
 
    // Traits traints表示一系列可以擴充套件或者混入到你的類裡的成員和行為。
    trait Car
    {
        val brand: String
    }
 
    trait Shiny
    {
        val shineRefraction: Int
    }
 
    class BMW extends Car
    {
        val brand = "BMW"
    }
 
    // 通過with關鍵字，一個類可以擴充套件多個traint：
    class BMW extends Car with Shiny
    {
        val brand = "BMW"
        val shineRefraction = 12
    }
 
    /*
    什麼時候你需要使用Trait代替抽象類? 如果你想定義一個類似介面的型別，
    那麼你很難在trait和抽象類之間做出選擇。它們都可以讓你定義一個具有某些行為的型別，
    然後要求擴充套件者去實習其他的行為。下面是一些經驗法則：
    優先使用traint。一個類可以擴充套件多個traint，但是隻能擴充套件一個抽象類。
    如果你需要在構造類的時候傳入引數的話，那就是用抽象類。抽象類的構造器可以傳入引數，trait則不能。
    例如，你不能這樣寫trait t(i:Int) {} ；引數i是非法的。
    */
 
 
    // 伴生類
    class Pizza (var crustType: String)
    {
        override def toString = "Crust type is " + crustType
    }
 
    object Pizza
    {
        val CRUST_TYPE_THIN = "thin"
        val CRUST_TYPE_THICK = "thick"
        def getFoo = "Foo"
    }
 
    var p = new Pizza(Pizza.CRUST_TYPE_THICK)
}

Scala學習筆記
2020-05-25
筆記
Scala學習筆記（2）-基礎語法
2018-10-26
筆記
Scala 學習筆記（2）之類和物件
2014-09-26
筆記物件
scala學習筆記：控制抽象
2015-02-28
筆記抽象
Scala 學習筆記（1）：初見
2017-07-21
筆記
scala學習筆記：理解stream和view
2015-03-01
筆記View
scala學習筆記：理解並行集合par
2015-02-28
筆記並行
Scala 學習筆記（1）之入門篇
2013-08-11
筆記
Scala學習 2 Scala物件導向
2017-10-05
物件
scala學習筆記：各種奇怪的寫法
2015-02-26
筆記
scala學習筆記：變數宣告中的模式
2015-02-28
筆記變數模式
Vue學習筆記2
2018-09-12
Vue筆記
MySQL學習筆記2
2020-12-20
MySql筆記
RocketMQ學習筆記 2
2020-10-17
MQ筆記
Oracle學習筆記2
2017-03-22
Oracle筆記
react學習筆記2
2018-06-07
React筆記
mysql學習筆記-2
2016-08-18
MySql筆記
jQuery學習筆記（2）
2013-12-01
jQuery筆記
TestNG—學習筆記2
2015-05-21
筆記
autolayout學習筆記_2
2015-05-25
筆記
學習筆記2（下）
2024-03-10
筆記
Scala學習記錄01
2020-09-26
koa2學習筆記
2020-02-19
筆記
hibernate學習筆記（2）
2021-09-09
筆記
Python學習筆記(2)
2019-01-05
Python筆記
Android學習筆記(2)
2017-03-24
Android筆記
koa@2學習筆記
2017-10-25
筆記
C#學習筆記2
2011-05-30
C#筆記
db2學習筆記
2005-06-05
DB2筆記
藍芽學習筆記2
2016-05-22
藍芽筆記
PL/SQL學習筆記-2
2007-06-13
SQL筆記
iproute2學習筆記
2015-11-18
筆記
Flex學習筆記(Day 2)
2012-08-29
Flex筆記
2-SAT 學習筆記
2024-04-06
筆記
強化學習-學習筆記2 | 價值學習
2022-07-04
強化學習筆記
ASP.NET學習筆記2
2020-04-06
ASP.NET筆記
Ext2.x學習筆記
2020-04-05
筆記
學習筆記（2）IPC機制
2019-04-27
筆記

Scala學習筆記2

相關文章