Scala学习笔记

---

一 约定

scala语法中，每一行代码后面可以不需要以分号结束

二 变量定义

val 变量名：变量类型 = 初始化值 （不可修改）
var 变量名：变量类型 = 初始化值（可修改） 

在scala中，val修饰的变量表示不可修改的变量（这个相当于java中的final 关键字），var 修饰的变量表示可修改变量。其中分号后面的变量类型可不填写，

var str:String = "zhoucg"
println(str)
val finalStr:String = "zhoucg"
var t1 = 3
println(t1)
val ch:Char = 'A'
val toInt = ch.toInt
println(toInt)

val修饰的变量可以通过lazy修饰，表示先不赋值，使用时再进行赋值操作
语法：
lazy val 变量名：变量类型 = 变量初始值

三 数据类型

scala和java一样，存在8种基本的数据类型，同时scala中没有像java那样存在基本数据类型的包装类，可以直接对scala的基本数据类型进行方法调用

四 访问修饰符

scala访问修饰符基本和java一致，分别：private protected public
如果没有执行访问修饰符，默认情况下，scala的对象访问级别都是public（java的默认访问修饰符是default：只能被本类访问）

五 运算符

基本的算术运算符：

基本的关系运算符：

基本的逻辑运算符：

六 基本表达式

1,if … else …表达式

逻辑运算的表达式
if() {
} else {
}
赋值
val test = if() str1 else str2

val x =2
val test = if(x>0) 1 else -1

2，块表达式{}

在scala种，{} 可以包含一系列的表达式，块中的最后一个表达式的值就是块的值

val x0 = 1
val y0 = 1
val x1 = 2
val y1 = 2
val distance = {
    val dx = x1 - x0
    val dy = y1 - y0
    Math.sqrt(dx*dx+dy*dy)
}
println(distance)

3，循环

scala的循环和java类似，提供了

while（）{}
do{} while()
for(i <-  表达式/数组/集合) {}

其中，for的基础用法和java不太相同，使用了 <- 指向对应的表达式的数据

val s = "hello"
for (i <- 0 to s.length-1) {println(s(i))}
for (i <-1 to 10) {println(i)}
for(i<- 1 unitl 10) println(i) //until包含左边不包含右边

提供scala对应跳出循环的操作，使用了函数式风格解决break和continue的功能，
首先导包：
import scala.until.control.Breas._

// 跳出循环实例,break,break:breanable()包住整个循环体
    breakable(
      for(i <-1 to 10){
        if(i == 5){
          break()
        }
      }
    )
    // 跳出循环实例，continue，break：breakable包住整个判断条件
    for(j<-1 to 10) {
      breakable{
        if(j == 5) {
          break
        }
        println(j)
      }
    }

七 方法函数定义

scala有方法和函数，scala方法是类的一部分，而函数是一个对象可以赋值给一个变量
换句话说，在类中定义的函数即使方法
Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
scala种使用val 语句定义函数，def语句定义方法

class Test{
  def m(x: Int) = x + 3
  val f = (x: Int) => x + 3
}

这一点：其实把函数理解成方法是没有问题的
方法的定义：

def funcionName（变量名）：（【参数，单个参数定义：参数名：参数类型，多个参数用英文逗号进行隔开】）：【return type】 = {}

如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。
如果方法没有返回值，可以使用Unti，整个类似java 的void

  def voidType:Unit = {
    println("这个是一个无参的函数信息");
  }

同时，可以给方法传入一个函数类型的参数
代码：

/**
   * 定义一个方法，
   * 方法m1参数要求是一个函数，参数的参数必须是两个Int类型
   * 返回值类型也是一个Int类型
   * @param f
   * @return
   */
  def m1(f:(Int,Int) => Int) :Int = {
    f(2,6)
  }

	//定义一个函数
    val f1 = (x:Int,y:Int) => x +y;
    println(f1)
    m1(f1)

scala函数的可变参数类型：
Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)

def printString(args:String*) : Unit = {
    var i:Int = 0;
    for(arg <- args) {
      println("Arg value[" + i + "] = " + arg)
      i = i+1
    }
  }

scala默认参数值
定义规则：

def functionName(【变量名：变量类型=默认值】)：【返回值类型】 = {}

def addInt( a:Int=5, b:Int=7 ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }

八 数组

scala声明数组的语法格式

定长数组：

val z：Array[String] = new Array[String] (3)
val z = new Arrayy[String] (3)

变长数组定义:
使用ArrayBuffer进行定义

// 定义变长数组的方法
var arr3 = new ArrayBuffer[Int](10)
// 等价于
var arr5 = new ArrayBuffer[Int]()

数组定义

var arr = Array(1,2,3)

九 集合

定义：

// 定义整型 List
val x = List(1,2,3,4)

// 定义 Set
val x = Set(1,3,5,7)

// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// 创建两个不同类型元素的元组
val x = (10, "Runoob")

// 定义 Option
val x:Option[Int] = Some(5)

Scala迭代器
Scala迭代器（Iterator）不是一个集合，它是一种用于访问集合的方式

object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
}

同时，使用迭代器（Iterator）能够查出最大值和对应的最小值（迭代器的常用方法可以参考对应的api）

val iterable = Iterator(listStr)
println(iterable.max)
println(iterable.min)

十 映射

在Scala中，把哈希表这种数据结构叫做映射
在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变。
创建一个不可变的Map

val scores = Map("zhangsan"->90,"lisi"->80,"wangwu"->70)
val scores = Map(("zhangsan",90),("lisi",80),("wangwu",70))

创建一个可变的Map

val scores = scala.collection.mutable.Map(("zhangsan",90),("lisi",80),("wangwu",70))

映射操作：
获取映射中的结果

val score1 = scores("lisi")
val score2 = if(scores.contains("lisi")) scores("lisi") else 0
val score3 = scores.getOrElse("lisi",0)  //0为默认值，如果不存在则返回默认值

修改对应的映射的值：

scores("tom") = 99  
scores("tom11") = 99  不存在时会添加一个值
scores.update("tom",66)

遍历：

val keys = scores.keySet set集合
val key = scores.keys 返回一个迭代器
val value = scores.values 返回值的迭代器
for((k,v)<-scores) println(k+" “+v) 返回键值对
for (item <- scores) print(item+” ") 返回键值对

集合的高级运用：（高级函数）
示例：

val seq = Seq(1,2,3,4,5)
seq.max
seq.min
seq.count(_%2==0) //根据条件计数

seq.filter(_%2==0)   返回符合Boolean条件的结果

map:（映射）列表元素
map函数的逻辑是遍历集合中的元素并对每个元素调用函数

val listStr = List(1,2,3,4)
val seq1 = Seq(1,2,3,4,5)
seq1.map(n => n*2) // 2 4 6 8 10
listStr.map(n =>n*2)

flatten:取集合里面的元素

学习参考

1：https://www.runoob.com/scala/scala-functions.html
2：https://blog.csdn.net/qq_35180983/article/details/83279013