1、scala安装和基本语法

一、安装Scala

1、安装

因为Scala是基于Java虚拟机，也就是JVM的一门编程语言。
所有Scala的代码，都需要经过编译为字节码，然后交由Java虚拟机来运行。
所以Scala和Java是可以无缝互操作的。Scala可以任意调用Java的代码。
所以Scala与Java的关系是非常非常紧密的。

因为Scala运行在JVM上，所以应该首先配置好JDK环境；

下载安装包：https://www.scala-lang.org/download

使用下载下来的安装包安装Scala。

在PATH环境变量中，配置$SCALA_HOME/bin目录。

在windows命令行内即可直接键入scala，打开scala命令行，进行scala编程。

二、基础语法

1、Scala解释器的使用

·REPL:Read（取值）>Evaluation（求值）>Print（打印）>Loop（循环）。
scala解释器也被称为REPL，会快速编译scala代码为字节码，然后交给JVM来执行。

·计算表达式：在scala>命令行内，键入scala代码，解释器会直接返回结果给你。如果你没有指定变量来存放这个值，那么值默认的名称为res，
而且会显示结果的救据类型，比如Int、Double、Strng等等。
    ·例如，输入1+1，会看到res0：Int=2
    ·内置变里：在后面可以继续使用res这个变里，以及它存放的值。·例如，2.0*res0，返回res1：Double=4.0
    ·例如，“Hi，+res0，返回res2：String=Hi，2
    ·自动补全：在scala>命令行内，司以使用Tab建进行自动补全。
    ·例如，输入res2.to，敲击Tab键，解释器会显示出以下选项，toCharAray，toLowerCase，toString，todgperCase。因为此时无法判定你需要补全的是哪一个，
     因此会提供给你所有的选项。
    ·例如，输入res2toU，盖击Tab键，直接会给你补全为res2.toUpperCase。



###
scala> 1 + 1
res0: Int = 2

scala> 2.0 * res0
res1: Double = 4.0

scala> "Hi, " + res1
res2: String = Hi, 4.0

scala> res2.to
toCharArray   toLowerCase   toString   toUpperCase

scala> res2.toUpperCase
res3: String = HI, 4.0

2、声明变量

·声期val变量：可以声明/a变量来存放表达式的计算结果。
    ·例，val result=1+1
    ·后续这些常量是可以维续使用的，例如，2*resut
    ·但是常量声明后，是无法改变它的值的，例如，result = 1，会返回error:reassign ment to val的错误信息。

·声明var变量：如果要声明值可以改变的引用，可以使用var变量。
    ·例口，var myresult=1，myresut=2
    .但是在scala程序中，通常建议使用val，也就是常量，因此比如类似于spark的大型复杂系统中，需要大量的网络传输数据，如果使用var，
     可能会担心值被销误的更改。

·指定类型：无论声明val变量，还是声明var变量，都可以手动指定其类型，如果不指的话，scal会自动根据值，进行类型的推断。
    .例如，val name: String=nul
    .例如，val name: Any="leo"
·声明多个变量：可以将多个变量放在一起进行声明。
    ·例如，val name 1, name2 String=nul
    ·例如，val numm, nume=100




###############
##val：
scala> val result = 1 + 1
result: Int = 2

scala> result * 2
res1: Int = 4

scala> result = 1
<console>:11: error: reassignment to val
       result = 1
              ^

##var：
scala> var result = 2
result: Int = 2

scala> result = 1
result: Int = 1

scala> result
res2: Int = 1

##类型：
scala> val d = 2.0
d: Double = 2.0

scala> val s = "Hello Word"
s: String = Hello Word

scala> val i = 1
i: Int = 1

scala> val name:String = null
name: String = null

scala> val name:Any = "leo"
name: Any = leo

##声明多个：
scala> val name1, name2: String = null
name1: String = null
name2: String = null

scala> val num1, num2 = 100
num1: Int = 100
num2: Int = 100

2、数据类型与操作符

·基本数据类型：Bye、Char、Short、Int、Long、Float、Double、Boolean。


·乍一看与Java的基本数据类型的包装类型相同，但是scala没有基本数据类型与包装类型的概念，统一都是类。

scala自己会负责基本数据类型和引用类型的转换操作。


·使用以上类型，直接就可以调用大量的函数，例如，1.toString0，1.to（10）。


·类型的加强版类型：scaa使用很多加强类给数据类型增加了上百种增强的功能或函数。


·例如，String类通过Strin gOps类增强了大量的函数，“Hello”.intersect（"Worldr）。
·例如，Scala还提供了Richlnt、RichDouble、RichChar等类型，Richint就提供了to函数1.to（10），此处int先隐式转换为Richlnt，然后再调用其to函数；


·基本操作符：scala的算术操作符与java的算术操作符也没有什么区别，比如+、一、、/、
%等，以及&、I、A、>>、<<等。|
.但是，在scala中，这些操作符其实是数据类型的函数，比如1+1，可以写做1.+（1）
·例如，1.to（10），又可以写做1to 10
·scala中没有提供++、--操作符，我们只能使用+=和=，比如counter=1，counter++是错误的，必须写做counter+=1.

###############

scala> 1.to(10)
res4: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)        #Range

scala> 1 to 10
res5: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)       #Range

scala> "Hello".intersect("World")          #取交集
res6: String = lo

##+=    -=

scala> var c = 1
c: Int = 1

scala> c += 1

scala> c
res9: Int = 2

scala> c -= 1

scala> c
res11: Int = 1

3、函数调用和apply()函数

·函数调用方式：在scala中，函数调用也很简单。

   ·例如，import scala.math._，sqrt（2），pow（2，4），min（3，Pi）。
   ·不同的一点是，如果调用函数时，不需要传递参数，则scala允许调用函数时省略括号的，例如，"Hello Worl.distinct

·apply函数
   ·Scala中的apply函数是非常特殊的一种函数，在Scala的object中，可以声明apply函载。
    而使用“类名()”的形式，其实就是“类名.apply()”的一种缩写。通常使用这种方式来构造类的对象，而不是使用“new类名（）”的方式。
   ·例如，“Hello World（6），因为在StringOps类中有def apply（n:Int）：Char的函数定义，所以“Hello World（6），实际上是“Hello Worlr.apply（6）的缩写。
   ·例如，Array（1,2,3,4），实际上是用Array objec的apply()函数来创建Array类的实例，也就是一个数组。




###
scala> import scala.math._
import scala.math._

scala> sqrt(2)
res12: Double = 1.4142135623730951

scala> pow(2,4)
res13: Double = 16.0

scala> min(3,6)
res14: Int = 3

scala> "hello word".distinct
res15: String = helo wrd



###
scala> "hello word".apply(6)
res16: Char = w

scala> "hello word"(6)
res17: Char = w

scala> Array(1,2,3,4)
res18: Array[Int] = Array(1, 2, 3, 4)

三、条件控制与循环

1、if语句

·if表达式的定义：在Scala中，表达式是有值的，就是if或者else中最后一行语句返回的值。
    ·例如，val age=30；if（age>18）1 else 0
    ·可以将if表达式赋予一个变量，例如，val isAdult=if（age>18）1 else 0
    ·另外一种写法，var isAdult=-1；if（age>18）isAdult = 1 else isAdult = 0，但是通常使用上一种写法

·if表达式的类型推断：由于if表达式是有值的，而if和else子句的值类型可能不同，此时if表达式的值是什么类型呢？Scala会自动进行推断，取两个类型的公共父类型。
    ·例如，if（age>18）1 else 0，表达式的类型是Int，因为1和0都是Int
    ·例如，if（age>18）"adult" else 0，此时f和else的值分别是String和Int，则表达式的值是Any，Any是String和Int的公共父类型
    ·如果if后面没有跟else，则默认else的值是Unit，也用（）表示，类似于java中的void或者null。例如，val age=12；if（age>18）"adult"。
     此时就相当于if（age>18）"adult"else（）。

·将if语句放在多行中：默认情况下，REPL只能解释一行语句，但是表达式通常需要放在多行。
    .可以使用的方式，比如以下方式，或者使用:paste和ctrl+D的方式。




####
scala> val age = 30
age: Int = 30

scala> if(age > 18) 1 else 0
res19: Int = 1

scala> var isAdult = -1
isAdult: Int = -1

scala> if(age >18)  isAdult = 1 else isAdult = 0

scala> val age = 30
age: Int = 30

scala> val isAdult = if(age > 18) 1 else 0        #scala自动判断值类型
isAdult: Int = 1

scala> val isAdult = if(age > 18) "adult" else 0
isAdult: Any = adult



scala> if(age < 12) "children"
res21: Any = ()

scala> if(age < 12) "children" else ()
res22: Any = ()

scala> if(age < 12) {}

scala> if(age < 12) {
     | "children"} else ()
res24: Any = ()


##:paste进入，最后Ctrl+d结束
scala> :paste
// Entering paste mode (ctrl-D to finish)

if(age < 12) 
 "children"
else
 "adult"

// Exiting paste mode, now interpreting.

res25: String = adult

2、语句终止符

·默认情况下，scala不需要语句终结符，默认将每一行作为一个语句；

·一行放多条语句：如果一行要放多条语句，则必须使用语句终结符；

    ·例如，使用分号作为语句终结符，var a，b，c=0；if（a<10）{b=b+1；c=c+1}
    ·通常来说，对于多行语句，还是会使用花括受的方式
    if（a<10）{
        b=b+1
        c=c+1
    }

·块表达式：块表达式，指的就是{}中的值，其中可以包含多条语句，最后一个语句的值就是块表达式的返回值。
    ·例如，vard=if（a<10）{b=b+1；c+1}

3、输入和输出

·print和printin：print打印时不会加换行符，而printin打印时会加一个换行符。

    ·例如，print（"Hello World"）; printin（"Hello World"）

·printf:printf可以用于进行格式化
    ·例如，printf（"Hi，my name is %s，I'm %d  years old.
"，"Leo"，30）

·readLine“：readLine允许我们从控制台读取用户输入的数据，类似于java中的System.in和Scanner的作用。

·综合案例：游戏厅门禁
val name=readLine（"Welcome to Game House.Please tell me your name:"）
print（"Thanks.Then please tell me your age:"）
val age=readlnt（）
if（age>18）{
    printf（"Hi，%s，you are%d years old，so you legal to play our greatful games！"）
}else{
    printf（"Sorry，%s，boy，you are only a child，you are%d years old.you are illegal to come here.)
}





##############
scala> print("hello word")
hello word
scala> println("hello word")        #结果后面有换行符
hello word

scala> printf("hello, my name is %s, i am %d years old", "Leo", 30)    #格式化
hello, my name is Leo, i am 30 years old
scala> 

scala> readLine()
warning: there was one deprecation warning; re-run with -deprecation for details
res30: String = "hello "

4、循环

·while do循环：Scala有while do循环，基本语义与Java相同。
  var n=10
  while（n>0）{
      printin（n）
      n -= 1

·Scala没有for循环，只能使用while替代for循环，或者使用简易版的for语句；
    ·简易版for语句：var n=10；for（i <- 1 to n）printin（i）
    ·或者使用until，表式不达到上限：for（i <- 1 until n）println(i)
    ·也可以对字符串进行遍历，类似于java的增强for循环，for（c <- "Hello World"）print（c） 

·跳出循环语句
    ·scala没有提供类似于java的break语句。
    ·但是可以使用boolean类型变量、return或者Breaks的break函数来替代使用。
    import scala.util.control.Breaks.
    breakable{
        var n = 10
        for（c   <- "Hello Wold"）{
            if（n == 5）break；
            print(c)
            n -= 1
        }
    }




#########
#while：
scala> var n = 10
n: Int = 10

scala> :paste
// Entering paste mode (ctrl-D to finish)

while(n > 0) {
 print(n + " ")
 n -= 1
}

// Exiting paste mode, now interpreting.

10 9 8 7 6 5 4 3 2 1 


#for
scala> var n = 10
n: Int = 10

scala> for(i <- 1 to n) print(i + " ")
1 2 3 4 5 6 7 8 9 10 

scala> for(i <- 1 until n) print(i + " ")
1 2 3 4 5 6 7 8 9 
scala> 

scala> for(c <- "hello world") print(c + " ")
h e l l o   w o r l d


#跳出循环
scala> import scala.util.control.Breaks._
import scala.util.control.Breaks._

scala> :paste
// Entering paste mode (ctrl-D to finish)

breakable {
 var n = 10
 for(c <- "hello word") {
  if(n == 5) break;
  print(c)
  n -= 1
 }
}

// Exiting paste mode, now interpreting.

hello




#高级for循环：
·多重for循环：九九乘法表：
for（i <- 1 to 9；j <- 1 to 9）{       #先循环j
  if（j == 9）{
    println（i * j）
  } else {
    print(i * j + " "）
  }
}


·if守卫：取偶数
  for（i<- 1 to 100 if i % 2 == 0）println（i）

·for推导式：构造集合
scala> for(i <- 1 to 10) yield i
res39: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)