Scala入门笔记

[toc]

0 hello world

object Hello {  
  def main(args: Array[String]) = println("Hello world")  
}

or

object Hello extends App {
  println("Hello World")
}

1变量

• val 定义 immutable variable
• var 定义 mutable vraiable
• lazy val 赋值是不会计算值,调用才计算
  可以不显示指定变量的类型,scala会自动进行类型推导

2 类型

scala类型系统以Any为根，分为AnyRef和AnyVal 两个分支体系，在AnyRef分支的最底层，有个Null类型的特殊类型，它被当作是所有AnyRef类型的子类型。更进一步在两个分支共同的最底层类型是Nothing类型，它被当作所有AnyRef和AnyVal类型的子类型。

2.1 umerical类型

• Byte 1字节
• Short 2
• Int 4
• Long 8
• Foat
• Double
  高精度类型 a = 低精度类型 b (同c自动转换)
  低精度类型 b = 高精度类型 a (error :type mismatch)

2.2 Boolen 类型

false
true

2.3 Char 类型

16 bit unsigned Unicode character. Range from U+0000 to U+FFFF

2.4 Unit 类型

it is not represented by any object in the underlying runtime system
A method with return type Unit is analogous to a Java method which is declared void.

val p=()

2.5 Null

Null类型只有一个唯一的值：null，可以被赋给所有的AnyRef类型变量
List(Null,Null,1)

2.6 Nothing

程序异常返回

2.7 String

val name =jin
s"my name is ${name}"

3 Block代码块

Block 也是一个表达式,其最终的求得的值是最后一个表达式的值

# 单行
{exp1;exp2}

{
exp1
exp2
}

4 函数

4.0 一等公民

• 函数作为实参传递给另一函数
• 函数作为返回值
• 把函数赋值为变量
• 把函数储存在数据结构里

4.0 .1函数类型

函数的类型格式为:A => B,表示一个接受A的参数,并返回B的参数

Int => String 是把整型函数映射为字符串的函数类型

4.0.2 高阶函数

用函数作为形参或者返回值的函数

// 参数是一个函数,这个函数有两个Int的参数,返回一个Int参数.
def operate(f:(Int, Int) =>Int) ={
    f(4,4)
def add() = (x:Int, y:Int) => { x+ y}
}

4.1 定义

def functionName (param: Param Type):Reurn Type = {
//function body:expression 
}
# 单行
def functionName (param: Param Type):Reurn Type = function body:expression 

def hello(para:String):String={   "hello"+ para}

4.2 调用方式的不同

• call by value 调用时计算参数的值
  def test(x:Int, y:Int) = x+y
• call by name 调用时不计算参数的值
  def test(x:=>Int y:=>Int Y) = x+y

def bar(x:Int,y:=>Int) = 1
def loop():Int = loop
bar(1,loop()) # 1
bar(loop(),1)  # 死循环

疑问?

def loop():Int = loop
loop

为什么会死循环呢?
https://stackoverflow.com/questions/43561397/scala-def-loop-unit-loop-why-loop-forever

4.3 匿名函数

匿名函数的定义:
(形参列表) => { 函数体 }

(x:Int, y:Int) => { x+ y}
val add = (x:Int, y:Int) => { x+ y}

4.4 柯里化,偏函数

柯里化函数(Curried Function) 把具有多个参数的函数转化为一条函数链,每一个节点上是单一函数

def add(x:Int, y:Int) = x+y
def add(x:Int)(y:Inr) = x+y

def curriedAdd(a:Int)(b:Int) = a+b
curriedAdd(2)(2)

val addOne = curriedAdd(1)_
def curriedAdd1(a:Int, b:Int) = a+b

def curriedAdd(a:Int,b:Int) = a+b
def addTwo = curriedAdd( _:Int , 1:Int)

4.5 可变长度参数

参数:类型* 类似于Python的参数收集args,*kwargs

def capitalizeAll(args: String*) = {
  args.map { arg =>
    arg.capitalize
  }
}

5 控制语句

5.1 if 表达式

if(logical) vala else valb
if( x == 10 ){
         println("Value of X is 10");      } 
else if( x == 20 ){ 
         println("Value of X is 20");      }
 else if( x == 30 ){ 
         println("Value of X is 30");      }
 else{         println("This is else statement");      }

5.2 for

for( a <- 1 to 10){ 
         println( "Value of a: " + a );

// for loop execution with a range
for( a <- 1 until 10){ 
       println( "Value of a: " + a );      }

• 多个参数

            // for loop execution with a range
for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }

• 过滤

val numList = List(1,2,3,4,5,6,7,8,9,10);
// for loop execution with multiple filters
for( a <- numList   if a != 3; if a < 8 ){
         println( "Value of a: " + a );
      }

• 列表推导

var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
var retVal = for{ a <- numList 
                            if a != 3; 
                            if a < 8;
                            s = a +1 }
                            yield s

5.3 while 和 do while

var a = 10;
     // while loop execution
      while( a < 20 ){
         println( "Value of a: " + a ); 
         a = a + 1;}

 // do loop execution
do {        
        println( "Value of a: " + a );
         a = a + 1;
      }
      while( a < 20 )   }

5.4 match表达式

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 + "?")
         }
      } 
   }
#这个类是特殊的用以比较的类
case class Person(name: String, age: Int)
>>>
Hi Alice!
Hi Bob! 
Age: 32 year, name: Charlie?

6 异常

try {         
        val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")}
         case ex: IOException => {   
         println("IO Exception") } 
      } finally { 
         println("Exiting finally...")
        throw new RuntimeException("n must be even")
      }

7 类

7.1 class

7.1.1 定义

• 构造函数
  构造函数不是特殊的方法，他们是除了类的方法定义之外的代码。

class MyClass(x: Int, y: Int) {           // Defines a new type MyClass with a constructor  
  require(y > 0, "y must be positive")    // precondition, triggering an IllegalArgumentException if not met  
  def this (x: Int) = { ... }             // auxiliary constructor   
  def nb1 = x                             // public method computed every time it is called  
  def nb2 = y  
  private def test(a: Int): Int = { ... } // private method  
  val nb3 = x + y                         // computed only once  
  override def toString =                 // overridden method  
      member1 + ", " + member2 
  }

new MyClass(1, 2) // creates a new object of type

7.1.2 承继

abstract class TopLevel {     // abstract class  
  def method1(x: Int): Int   // abstract method  
  def method2(x: Int): Int = { ... }  
}

class Level1 extends TopLevel {  
  def method1(x: Int): Int = { ... }  
  override def method2(x: Int): Int = { ...} // TopLevel's method2 needs to be explicitly overridden  
}

object MyObject extends TopLevel { ... } // defines a singleton object. No other instance can be created

7.1.3 Case Classes

Case Class 是一种特殊的class类型,默认的case class 是不可变类型 .可以通过值比较.
基本的定义如下

case class Point(x: Int, y: Int)

可以不通过new 关键字实例化

val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)

比较

if (point == anotherPoint) {
  println(point + " and " + anotherPoint + " are the same.")
} else {
  println(point + " and " + anotherPoint + " are different.")
}
// Point(1,2) and Point(1,2) are the same.
if (point == yetAnotherPoint) {
  println(point + " and " + yetAnotherPoint + " are the same.")
} else {
  println(point + " and " + yetAnotherPoint + " are different.")
}
// Point(1,2) and Point(2,2) are different.

7.2 object 单例

作为一个定义的类的单例

object IdFactory {
  private var counter = 0
  def create(): Int = {
    counter += 1
    counter
  }
}

val newId: Int = IdFactory.create()
println(newId) // 1

7.3 Traits特质

类似于java8的借口
是一些字段和行为的集合，可以扩展或混入（mixin）你的类中。

trait Car {
  val brand: String
}

trait Shiny {
  val shineRefraction: Int
}

class BMW extends Car {
  val brand = "BMW"
}

通过with关键字，一个类可以扩展多个特质：

class BMW extends Car with Shiny {
  val brand = "BMW"
  val shineRefraction = 12
}

8 collection 内置数据结构

Immutable Collections 不可变对象

• List (linked list, provides fast sequential access)
• Stream (same as List, except that the tail is evaluated only on demand)
• Vector (array-like type, implemented as tree of blocks, provides fast random access)
• Range (ordered sequence of integers with equal spacing)
• String (Java type, implicitly converted to a character sequence, so you can treat every string like a Seq[Char])
• Map (collection that maps keys to values)
• Set (collection without duplicate elements)

Mutable Collections 可变对象

• Array (Scala arrays are native JVM arrays at runtime, therefore they are very performant)
• Scala also has mutable maps and sets; these should only be used if there are performance issues with immutable types