Scala基础

一：Scala安装

（一）Scala学习之路（一）Scala的安装

补充：下载速度慢，可以使用百度云等软件进行下载（将https改为http即可下载）

（二）命令行测试使用

（三）eclipse安装scala创建

https://baijiahao.baidu.com/s?id=1659239771083075892&wfr=spider&for=pc

二：Hello World测试

（一）配置lib

选择版本需要和安装的Scala一致

（二）helloworld测试

package test

object HelloWorld {
  def main(args:Array[String]):Unit={
    println("Hello World");
  }
}

三：基础数据类型

（一）Scala中所有的数据都是对象

Scala中所有的数据都是对象，也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法的。

举例：数字 1是一个对象，就有方法（函数）

可以不用指定数据的类型，Scala会自动进行类型的推荐

举例：下面的两条语句是一样的

val a:Int = 10
val b = 10  ----> b的类型就是Int　　一般这种就行

（二）Scala数据类型《首字母一定大写》

（1）数值类型：Byte、Short、Int、Long、Float、Double

（2）字符类型Char和字符串类型String

scala> var c1='x'                                                    
c1: Char = x                                                                                                                              
scala> var s1="adsaa"                                                
s1: String = adsaa                                                                                                                        
scala> s"666 ${s1} ${c1}"              插值处理需要加上s指定为字符串                              
res10: String = 666 adsaa x

（3）布尔类型

（4）Unit的类型

相当于void

说明返回值为空

（5）Nothing类型

Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。

（6）Any类型

Any是所有其他类的超类

（7）AnyRef类型

AnyRef类是Scala里所有引用类(reference class)的基类

Null是所有AnyRef的子类，在scala的类型系统中，AnyRef是Any的子类，同时Any子类的还有AnyVal。
对应java值类型的所有类型都是AnyVal的子类。
所以Null可以赋值给所有的引用类型(AnyRef)，不能赋值给值类型，这个java的语义是相同的。 
null是Null的唯一对象。 

Nothing是所有类型的子类，也是Null的子类。Nothing没有对象，但是可以用来定义类型。
例如，如果一个方法抛出异常，则异常的返回值类型就是Nothing(虽然不会返回)

四：变量与常量

在Scala中，常量用val关键字定义，变量用var关键字定义，注意在Scala里这两个关键字要用小写，否则会报错

五：函数与方法

Scala 中使用 val 语句可以定义函数，def 语句定义方法，但本质上两者没什么区别。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。

六：条件表达式if else

七：循环语句: for、while、do..while、foreach迭代

（一）for表达式（和其他有所差距）

写法一：使用list列表：

1 to 10生成一个list：

写法二：使用list

写法三：添加过滤器

补充：使用for和yield生成器

（二）while循环--差别不大

还有一个值得注意的是，对var再赋值等式本身也是unit值，假设使用以下的例子，编译的时候，Scala会警告comparing values of types Unit and String using `!=' will always yield true，所以循环会变成死循环

（三）foreach循环

八：函数参数

（一）函数参数说明

1.call by value：对函数实参进行求值，并且只求一次

调用：

func1(3+4,5)

执行过程：

1：fun1(7,5)
2：7+5
3：12

2.Call by name：函数实参在函数内部调用的时候，才会求值，每次都会求值。使用=>

调用：

func2(3+4,5)

执行过程:

1：func2(3+4,5)2：(3 + 4) +5
3：7 + 5
4: 12

3.举例说明

def bar(x:Int,y: => Int):Int = 1
def loop():Int = loop     //死循环函数
或者
def loop():Int ={
loop()
}

调用：

bar(1,loop)  输出:1
bar(loop,1)  进入了死循环

原因：bar(1,loop)调用的时候，x是call by value，y是call by name，所以这里会先对x做一个求值，x=1，而y在没有调用到它的情况下，是不会进行求值的；同样的bar(loop,1)也是一样的道理，对x做求值，这个时候程序就会进入一个死循环的情况。

（二）函数参数的类型

1.默认参数

2.代名参数

3.可变参数

在参数类型的后面加上星号（*），就说明参数的个数不确定，且均为这个类型

九：Scala的Lazy特性（懒执行特性）

当一个变量被申明是lazy，他的初始化会被推迟，直到第一次使用他的时候，才会被初始化。即便该变量异常，也是只会在第一次使用时才抛出异常。注意：只有val才有该特性

十：异常处理

可以像Java一样用try..catch..finally来进行异常捕获

十一：数组

Scala里使用new实例化对象，实例化过程中，可以用值和类型使对象参数化，参数化的意思是指在创建实例的同时完成对它的“设置”，数组同样可以如此。

（一）定长数组：Array

             数组的索引从0开始，最大值为数组的长度-1，整数类型的数组初始值全部为0，而String类型的为Null
                 限定数组长度
                     val a = new Array[Int](10) 
                     val b = new Array[String](5)
                 对数组直接进行初始化
                     val c = Array("Tom","Mary","Mike")
                     val a = new Array[Int](1，2，4，9，5) 
             注意，尽管使用的是val进行定义，但是数组内部的元素是可以被修改的，只是数组对象不能被重新赋值成新的数组
             对数组进行排序并输出，这里是降序排列
                 a.sortwith(_>_).foreach(print)

（二）变长数组：ArrayBuffer

              import scala.collection.mutable._
              val d = ArrayBuffer[Int]()
              往变长数组中添加元素
              d += 1
              d += 2
              d += 3
              
              一次添加多个元素
              d += (10,20,30)
              去掉数组中的元素
              d.trimEnd(2)

（三）多维数组：通过数组的数组来实现

import Array._
 
object Test {
   def main(args: Array[String]) {
 
      //定义二维数组，设定长宽
      var myMatrix = ofDim[Int](3,3)
      
      //初始化数组
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      //打印二维数组
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
    
   }

（四）区间数组：使用range方法生成数组

import Array._
 
object Test {
   def main(args: Array[String]) {
  
      //使用range方法生成数组，注意，是左闭右开区间，第三个参数为增长量
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)
 
      // 输出所有数组元素
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

十二：Map映射和Tuple元组

（一）映射

Map是一种可迭代的键值对（key/value）结构，所有的值都可以通过Key来获取，Map 中的Key都是唯一的。
Map 也叫哈希表（Hash tables）。
Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。
默认情况下 Scala 使用不可变 Map。如果需要使用可变集合，要引入 import scala.collection.mutable.Map 类

（二）元组

与List一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。
可以利用Scala的类型推断来隐式定义一个元组，也可以显式的new，但注意显式的情况下，Tuple后面要跟元组的长度，目前Scala Tuple的最大长度为22
Tuple不能直接用foreach来遍历，所以要使用迭代器再foreach进行遍历
Tuple还可以使用tostring方法来将元组转换成字符串