Scala基础和函数

简介

Scala将面向对象和函数式编程结合在一个简洁的高级语言中。 Scala的静态类型有助于避免复杂应用程序中的错误，其JVM和JavaScript运行时可让你构建高性能系统，轻松访问庞大的库生态系统

Scala的安装

Windows版本安装

双击安装，无脑下一步
配置环境变量

SCALA_HOME=E:\scala
Path中追加 %SCALA_HOME\bin%

cmd进入黑窗口输入scala,出现如下信息说明配置成功

C:\Users\Administrator>scala
Welcome to Scala 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_161).
Type in expressions for evaluation. Or try :help.

Linux版本安装

[root@CentOSA ~]# rpm -ivh scala-2.11.12.rpm
Preparing...                ########################################### [100%]
   1:scala                  ########################################### [100%]
[root@CentOSA ~]# scala
Welcome to Scala 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_191).
Type in expressions for evaluation. Or try :help.
scala>

IDEA集成Scala开发

安装Scala插件，重启idea

变量

Scala语言中没有原始数据类型，这一点和Java语言不同，在Scala中一切且对象。以下是Scala语言中常见类型和类型间的继承关系。
在这里插入图片描述
在Java中常见的基本类型在Scala中都被剔除了,Scala将值类型和引用类型分离。所有的数值变量类型都是 AnyVal的子类，这些变量的值都有字面值。对于一些对象类型的变量都是 AnyRef的子类。对于 AnyRef类下的变量（除String类型），一般不允许直接赋值字面量，都需要借助 new关键创建。

变量声明

Scala语言是一种可以做类型自动推断的强类型的编程语言。变量的类型可通过编译器在编译的时候推断出最终类型。因此Scala中声明一个变量主需要告知编译器该变量的值是常量还是变量，例如：例如声明一个变量使用var即可，如果声明的是一个常量使用val关键字。因此Scala中变量声明的语法如下：var|val 变量名[:类型] = 变量值[:类型]

var a:Int = 1:Int
var b:Int = 1
var c = 1:Int
var d = 1

Scala所有的变量在声明时可以省略类型，并不意味之Scala是一种弱类型的编程语言，程序一旦编译后，类型固定，不可以更改。

数值转换

以下是黑窗口命令结果

scala> var i=1
i: Int = 1

scala> var b:Byte=i.asInstanceOf[Byte]
b: Byte = 1

scala> var b:Byte=i.toByte()
<console>:12: error: Byte does not take parameters
       var b:Byte=i.toByte()
                          
scala> var b:Byte=i.toByte
b: Byte = 1

用户可以使用asInstanceOf[类型]这种方式在数值间转换。该方式只适合类型兼容的时候使用，如果类型不兼容可以使用toInt、toChar、…等可以将常规参数自动转换为数值类型。

scala> var sex="true"
sex: String = true

scala> sex.toBoolean
res2: Boolean = true

scala> sex.asInstanceOf[Boolean]
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Boolean
  at scala.runtime.BoxesRunTime.unboxToBoolean(BoxesRunTime.java:85)
  ... 32 elided

数组

声明一个int类型的数组：

val array:Array[Int] = Array(1,2,3)

元组

元组是在Scala编程语言中的一种特殊变量，该变量可以组合任意几种类型的变量，构建一个只读的变量类型。访问元组的成员可以使用_元素下标访问。（一个元组最多有22个元素）

        //元组，只读
        var t:(String,Int)=("zhanghaonan",18)
        print(t._1+t._2+"岁")

        var t = (1,1,1,1,1,1,"adsf",1)
        print(t._7)

分支循环

if

修饰的代码分支可以赋值给一个变量

        var i:Int=new Random().nextInt(30)
        var a = if (i<30){
          "唵"
        }else if(i<60){
          "哞"
        }else if(i<90){
          "咪"
        }
        println(a)

Break

Scala 语言中默认是没有 break 语句，但是在 Scala 2.8 版本后可以使用另外一种方式来实现 break 语句。当在循环中使用 break 语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。Scala 中 break 的语法有点不大一样，格式如下：

var loop=new Breaks
loop.breakable({
  do{
    i -= 1
    print(i+"\t")
    if(i==1) {
      loop.break()
    }
  }while(i!=0)
})

for循环

遍历数组

var array = Array(1,2,3,4,5)
for(i<-array){
	println(i)
}

var array = Array("苦","海","翻","起","爱","恨")
for(i<-0.to(array.length-1)){
	print(array(i))
}

var array=Array("a","b","c")
for( index <- 0 until array.length){
  print(array(index)+"\t")
}

for循环可以使用多个循环因子

//99乘法表
for(i<-1 to 9;j <- 1 to i){
    print(s"$i*$j="+(i*j)+"\t")
    if(i==j) println()
}

for循环嵌套if

for(i<-1 to 9;if(i%2==0 || i%3==0) ){
    print(s"$i\t")
}

数组计算

var array=0 to 9
val results = for(i <- array;if(i%2==0)) yield i*i
for(i <- results){
    println(i)
}

模式匹配（类似Java中的switch-case）

模式匹配是检查某个值（value）是否匹配某一个模式的机制，一个成功的匹配同时会将匹配值解构为其组成部分。它是Java中的switch语句的升级版，同样可以用于替代一系列的 if/else 语句。

数值匹配

val x: Int = Random.nextInt(10)
var result= x match {
   case 0 => "zero"
   case 1 => "one"
   case 2 => "two"
   case 3 => "three"
   case 4 => "four"
   case _ => "other"
 }
 println(result)

类型匹配

var array=Array("zs",true,new Date(),1000.0)
var x=array(new Random().nextInt(array.length))
var result= x match {
   case v:String => "name"
   case v:Boolean => "sex"
   case x:Date => "birth"
   case x:Double => "salary"
   case _ => "未知"
  }
println(result)

函数

标准函数

def sum(x:Int,y:Int):Int={
	return x+y
}

//可以省略返回值类型
def sum(x:Int,y:Int)={
	x+y
}

可变长参数

def sum(args:Int*):Int={
	var sum:Int=0
	for(arg<-args){
		sum+=arg
	}
}

参数默认值

def hello(msg:String="hey",name:String="xiaoming"):Unit={
	print(msg+","+name)
}

内嵌函数

 def factorial(x:Int)={
    def mulit(i:Int):Int={
      if(i > 0){
        i*mulit(i-1)
      }else{
        1
      }
    }
    mulit(x)
  }
等价
def factorial(x:Int):Int={
   if(x>0){
      x*factorial(x-1)
   }else{
      1
   }
 }

柯里化（Currying）
在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数的函数，并且返回接受余下的参数的新函数的这种技术。

		def sum1 (x:Int,y:Int):Int={x+y}
		//sum1变成下面的形式
        
        def add(x: Int)(y: Int): Int = {
          x + y 
        }
        var result = add(1)(_)
        //下划线“_” 作为第二参数列表的占位符， 这个定义的返回值为一个函数，当调用时会给调用的参数加一
        print(result(2))
        //结果为3，在应用时应该使用这种形式：sum(1)(2)

add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。

匿名函数

Scala中，函数可以没有命名，此时函数被称为匿名函数。
可以直接定义匿名函数之后，将函数赋值给某个变量；也可以直接将定义的匿名函数传入其他函数中。
Scala 中定义匿名函数的语法：(参数名：参数类型)=>函数体

       var f:(Int,Int)=>Int = (x:Int,y:Int)=>{x*y}
       print(f(4,5))

	    def a(x: Int, y: Int)(b: (Int, Int) => Int): Int = {
	      b(x, y)
	    }
	   print(a(1,2)((i:Int,j:Int)=>i+j))

高阶函数的类型推断

高阶函数可以自动推断出参数类型，而不需要写明类型；而且对于只有一个参数的函数，还可以省去其小括号；如果仅有一个参数在右侧的函数体内只使用一次，则还可以将接收参数省略，并且可以参数用_来替代。

函数和变量

定义一个是变量的函数

var f:(Int,Int)=>Int = (x:Int,y:Int)=>Int

声明一个函数

sum:(Int,In)=>Int = (x,y)=>{x+y}

简介