Scala基础浅谈

Scala基础浅谈

一、什么是Scala?

      Scala是一门多范式编程（面向对象编程、函数式编程）语言，设计初衷是实现可伸缩的语言，并集成面向对象编程和函数式编程的各种特性，具有表达能力强，代码精简的优点。

二、Scala的特性:

(1)面向对象特性:

• 每个值都是对象
• 对象的数据类型和行为由类（Class）和特征（Trait，类似于interface）描述
• 利用特征实现混入式多重继承

(2)函数式编程特性:

• 每个函数都是一个值
• 支持高阶函数、柯里化(currying)、样例类（case class）及模式匹配

(3)Scala是静态类型语言
(4)扩展性好

三、Scala变量与常量定义方法：

(1)变量:赋值后可以改变，生命周期中可以被多次赋值,一般情况下，无需显示指定类型，Scala编译器会自动推断出类型。

var 变量名称:类型=xxx
//例如
var a:Int=5

(2)常量:赋值后不可变，类似于Java中的final变量。

val 常量名称:类型=xxx
val b:String="Json"

四、类型别名:

      Scala支持使用Type关键字定义类型别名:

type 类型别名=类型
//例如
type T=String

五、Scala数据类型层次结构

• Any：所有类型的超类（顶级类型）
• AnyVal：表示值类型的超类
• AnyRef：表示引用类型的超类，对应java.lang.Object
• Unit：表示无值，类似Java中的void
• Nothing：所有类型的子类
• Null：表示null或空引用

六、Scala数组

• 存储固定大小的元素
• 数组索引从0开始
  创建方法:

// 法1
var a1:Array[String] = new Array[String](3)
a1(0)="Jason"
a1(1)="Marie"
a1(2)="Jimmy"
//法2
var a2=Array("Jason","Marie","Jimmy"）
// 法3，仅限区间数组
var a3=Array.range(1,10,2)

七、Scala元组

• 可以包含不同类型的元素
• 最多支持22个元素 （Tuple1~Tuple22）
• 使用下划线“_"访问元素，“_1"表示第一个元素
  创建方法:

//法1
var tp1 = ("Mike", "123 ABC street", 58)
println(tp1._1)
println(tp1._2)
println(tp1._3)
//迭代元组
tp1.productIterator.foreach{ i =>println("Value = " + i )}

//法2
var tp2 = new Tuple3("Mike", "123 ABC street", 58)

//法3
def mike = "Mike" -> 5

八、Scala集合

• Seq:序列，元素按顺序排列
• Set：集合，元素不重复
• Map：映射，键值对集合
• 不可变集合：scala.collection.immutable，默认Scala选择不可变集合
• 可变集合：scala.collection.mutable，可以修改、添加或移除一个集合的元素

九、Scala函数

• 函数是Scala的核心
• 函数定义

def 函数名([参数列表]):[返回值]={
    函数体
    return [表达式]}

//例如
def square(x: Int): Int = { 
    println(x)
    x * x    //return
}

• 函数调用

函数名(参数列表)
//例如
square(5)

十、匿名函数

• 指不含函数名称的函数
• 匿名函数定义：=>”左边为参数列表，=>”右边为函数体

//例如
(x:Int)=>x*x

十一、函数嵌套：

      Scala函数内可以定义函数，函数内的函数也称局部函数或者内嵌函数。

//使用函数嵌套实现阶乘运算
def factorial(i: Int): Int = {
      def fact(i: Int, accumulator: Int): Int = {
         if (i <= 1)
            accumulator
         else
            fact(i - 1, i * accumulator)
      }
      fact(i, 1)	//不能在factorial()之外调用
   }

十二、柯里化（Currying）

      方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数，该函数接收剩余的参数列表作为其参数。这被称为柯里化。

def modN(n: Int,x: Int) = ((x % n) == 0)
//柯里化
def modN(n: Int)(x: Int) = ((x % n) == 0)
def f1(n: Int, x: Int) = modN(n)(x) 
//新函数接收剩余的参数列表作为其参数
def f2(x: Int) = modN(10)(x) 
def f3(n: Int) = modN(n)(10) 
def f4 = modN(10)(_)

十三、Scala的参数：

(1)隐式参数:方法可以具有隐式参数列表，由参数列表开头的implicit 关键字标记。

def sum(x:Int)(implicit y:Int)=x+y
implicit var a=10	//将作为Int类型隐式值自动传递
sum(10)	//执行结果为20

(2)命名参数:通常情况下，传入参数与函数定义的参数列表一一对应,命名参数允许使用任意顺序传入参数。

def printName(first:String, last:String) = {
    println(first + " " + last)
}
 
//Prints "John Smith"
printName("John","Smith")
printName(first = "John",last = "Smith")
printName(last = "Smith",first = "John")

(3)参数缺省值:Scala函数允许指定参数的缺省值，从而允许在调用函数时不指明该参数。

def printName(first:String="John", last:String="Smith") = {
    println(first + " " + last)
} 
//Prints "John Smith"
printName()