Scala 基础

Scala语言基础
一、Scala简介

1、Scala是一门多范式的编程语言，一种类似java的编程语言 ，设计初衷是实现可伸缩的语言 、并集成面向对象编程和函数式编程的各种特性。
    （*）面向对象
    （*）函数式编程（Scala最大的特点）
2、Scala基于JVM

二、安装Scala环境：类似Java

1、前提：先安装JDK
2、安装Scala：设置两个环境变量   下载  http://www.scala-lang.org/download/
    （*）SCALA_HOME
    （*）把%SCALA_HOME%/bin  ====> path路径

三、Scala中常用的开发工具
1、命令行：REPL

    (*) paste模式：相当于vi编辑器
            进入：：paste
            退出：ctrl+D

(*) 退出： :quit

2、IDEA
    (*) 默认：没有开发Scala的环境
    (*) 安装Scala的插件: SBT（需要联网，有点慢）

3、Scala IDE(基于Eclipse)

四、常用的数据类型（基本的数据类型）

注意：
（1）在Scala中，任何数据都是对象
举例：1 是一个对象，就有方法
        scala> 1.toString 把数字的1转成字符串的1
        res0: String = 1  定义一个新的变量 res0，类型是String

（2）在定义变量的时候，可以不用指定类型

    1、数值类型：Byte  Short  Int  Long Float Double
    (*)Byte: 8位有符号的数字   -128~127
    (*)Short: 16位有符号的数字  -32768 ~ 32767
    (*)Int   32位
    (*)Long  64位

//定义一个整数变量
val c:Int = 10
//也可以写成:
val b = 10
//Scala在定义变量的时候，会进行类型的推导

2、字符串  Char  String

//注意：在Scala，可以对字符串进行插值操作  ---> 前面加一个s
val s1="Hello World"

//在下面的字符串中引用上面的s1
s"My Name is ${s1}"
//res0: String = My Name is Hello World

3、Unit类型：相当于Java中的void类型

//举例:  
val f = () 
//相当于我们定义了函数，并且我们把该函数的值付给一个变量来保存
val f = {}

4、Nothing类型：一般表示在执行的过程中，产生了Exception

//举例: 定义函数
def myfunction = throw new Exception("Some Error")

五、变量var 常量 val
六、函数

//Scala的内置函数: 导入一个包:  
import scala.math._  //代表该包下面的所有类
//举例：求最大值:  max函数
max(10,20)

2、自定义函数

//自定义函数
def sum(x:Int,y:Int):Int= x + y

//还可以表示为
def add(x:Int,y:Int):Int = {
  x + y
}
//注意：返回值可以不写return，因为在Scala的函数中，函数的最后一条语句就是该函数的返回值

//复杂一点的例子  求一个数的阶乘
def myFactor(x:Int):Int={
  if( x == 1 )
  {
    1
  }
  else{
    x * myFactor(x-1)
  }
}
myFactor(6)

七、条件表达式：if … else …. 是一个表达式，就应该有返回值(不需要return)

//定义变量
val a:Int = 10
//if 语句  不需要return
if(a == 10){
  10
}
else {
  20
}

八、循环

//循环  演示for循环
//定义一个集合
var list = List("Mary","Tom","Mike")

//for 循环的第一写法  <- 是scala中的generator 提取符
for(s <- list) println(s)
/*
  Mary
  Tom
  Mike
  res2: Unit = ()
*/

//for 循环的第二种写法  对提取的每个元素进行处理
for {
  s <- list
  //只打印名字长度大于3
  if (s.length > 3)
} println(s)
//执行结果
/*
  Mary
  Mike
  res3: Unit = ()
*/

//for循环的第三种写法
for (s <- list if s.length <= 3) println(s)
/*
  执行结果
  Tom
  res4: Unit = () 
*/

//介绍一下：关键字yield 作用：产生一个新的集合
//举例：把所有的名字都改成大写
val newList = for{
  s <- list
  s1 = s.toUpperCase
}yield(s1)

//使用while循环
//变量
var i = 0
while(i < list.length){
  println(list(i))
  //自增
  i += 1
}

//使用do  while 循环
var a = 0
do{
  println(list(a))
  //自增
  a += 1
}while(a < list.length)

九、函数的参数

    （一）函数的求值策略
    1、call by name  对函数的实参求值，仅求一次
    2、call by value  函数的实参在函数体内部，每次调用的时候都会求值

//call by name 
def test1(x:Int,y:Int):Int = x + x

//call by value
def test2(x: => Int,y: => Int):Int = x + x

test1(3+4,8)
test2(3+4,8)


//一个复杂一点的例子: x是call by value, y是call by name

def bar(x:Int,y: => Int):Int = 1
//定义一个死循环函数
def loop():Int = loop

//考虑下面的两种情况：
//情况1：
bar(1,loop)  //---->  1
//情况2：
bar(loop,1)  //----> 死循环

（二）函数的求值策略
默认参数：不给参数赋值，就采用默认值

def func1(name:String="Tom"):String = "Hello " + name
func1()
func1("Mary")


//可变参数：求多个数字的和
def sum(args:Int*):Int = {
 var result = 0
    for(a <- args)
 result += a
 result  // ---> 就是函数的返回值
}       

十、Lazy值（懒值）：特点：延时加载

//如果某个变量定义成lazy，他的初始化会被推迟，直到我们首次对他求值的时候
val x:Int = 10
val y:Int = x + 1
lazy val z:Int = x + 2
//一个复杂点的例子：读取文件
//(*) 读取一个已经存在的文件
val words = scala.io.Source.fromFile("d:\\temp\\a.txt").mkString
lazy val words1 = scala.io.Source.fromFile("d:\\temp\\a.txt").mkString

//(*) 读一个不存在的文件
lazy val words2 = scala.io.Source.fromFile("d:\\temp\\b.txt").mkString  

十一、异常：类似Java

//如何处理异常
try{
  val words =  scala.io.Source.fromFile("d:\\temp\\b.txt").mkString
}catch {
  case ex1: java.io.FileNotFoundException => {
    println("File Not Found")
  }
  case ex2: IllegalArgumentException => {
    println("IllegalArgumentException")
  }
  case _: Exception => {
    println("Others Exception")
  }
}finally {
  println("******* Finally Block *******")
}

十二：数组 定长数组 变长数组

import scala.collection.mutable.ArrayBuffer

//Scala中的数组
//1. 定长数组
// 提一下：如果创建对象的时候，省略new关键字，需要定义对应的apply方法
val a = Array[Int](10)   //-----> Array有一个apply，接收Int
val b = new Array[String](3)
val c = Array("Tom","Mary","Mike")

//2.变长数组
val d = new ArrayBuffer[Int]()    //提供了对应Int的apply方法，可以省略new的关键字
//val e =  ArrayBuffer[Int]()

//往变长数组中添加元素
d += 1
d += 2
d += 3
d += 4

//一次添加多个元素
d += (10,20,30)

//变长数组的基本操作
d.trimEnd(2)  //去掉尾部的两个元素
d

//把一个ArrayBuffer转成一个Array
d.toArray

//遍历数组： for 、foreach
d.foreach(println)

//Scala中数组的常用操作

val myArray = Array(1,23,10,5,8,3)

//最大值
myArray.max
//最小值 求和
myArray.min
myArray.sum

//排序: 下面的两个排序是一样
myArray.sortWith( _  > _ )

myArray.sortWith((a,b) =>{
  if(a >b)
    true
  else
    false
})

//多维数组
//举例1：创建一个二维数组，数组中的每个元素都有固定长度
val a1 = Array.ofDim[Int](3,4)

// 赋值
a1(1)(2) = 10
a1

//举例2：创建一个二维数组，里面每个元素是一个数组，其长度不一致
//一个一维数组：1
//二个一维数组：2
//三个一维数组：3
val a2 = new Array[Array[Int]](10)

//赋值
for(i<- 0 until a2.length)
  a2(i) = new Array[Int](i+1)

a2

十三：映射

//映射
val english =  scala.collection.mutable.Map("Tom"->80,"Mary"->85,"Mike" -> 90)

//获取映射中的值
english("Mary")
//先判断
if(english.contains("Mary")){
  english("Mary")
}else{
  -1
}
//有一种简写
english.getOrElse("Mary",-1)

//修改映射中的值（前提是：可变）
english("Mary") = 95

//迭代
for(s <- english)
  println(s)

十四：元组 Tuple

//定义一个元组: Tuple后的数字表示里面有几个元素
val t2 = new Tuple4(1,2,3,"Mary")

//如何引用元组中的元素?
t2._3

//迭代: map和foreach区别：有没有返回值
t2.productIterator.foreach(println)