Scala 知识点掌握1

Scala知识点巩固

1、Scala简介

Scala是一门面向对象和面向函数的编程语言，是一门静态编程语言，如 Java Scala（变量类型在编译阶段确定）；源码文件需要基于 JVM 运行的。

动态编程语言如Python

2、Scala的特点

1.速度快 2.优雅(代码量比Java要少许多）

3、Scala中的表达式

Scala中的表达式是有返回值的
一般情况下是最后一条语句的执行结果作为返回值

# 条件表达式 
val a = 1
val res = if( a > 0 ) "true" else "false"

# 块表达式
val res = { val a = 10
            val b = 20 
            a + b
          }

4、Scala中的循环控制

Scala中有 for \ while \ do———while

1 to 3 表示1~3的集合包含边界值3
1 until 3 表示1~3的集合但不包含边界值3
yield 返回是一个集合

# for循环语法  for循环是Scala中最常用的循环控制语句
for ( 1 <- 条件表达式\数组\集合 ) { 表达式 }  # 如果｛｝中只有一条语句则大括号可以省略

# 多重for循环语法 (多重循环以分号隔开，if 后面可以加条件语句)
for ( i <- 1 to 3; j <- 1 to 3; if i != j ) {
    println( "i"+"j"+ i + j ) 
}

# 遍历字符串
val str = "Hello Scala"
for (i <- 0 until str.length) {
    println(str(i))
}

# 遍历数组
val arr = Array[Int](1,3,2,5,4)  //声明一个数组
for (i <- arr) println(i)        //遍历

# 遍历集合
val list = List("a","b","c")     //声明一个List集合
for (i <- list) println(i)

# for循环的推倒式 yield 返回是一个集合
val res = for (i <- 1 to 10) yield i*10
println(res)

#元组
val t1 = ("xiaoming",18,"男")
println(t1._1 + "---" + t1._2 + "---" + t1._3)  //元组的下标从1开始

# while循环语法
while (条件语句) { 表达式 }

# do———while循环语法
do { 表达式 } while （条件语句)

5、Scala中的方法与函数

Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。
Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象
Scala 中使用 val 语句可以定义函数，def 语句定义方法。
Scala 中的方法可以转换成函数（1.将一个方法作为参数传递给其它方法或函数时系统自动把方法转换成函数，2.使用空格加下划线显示的转换如：方法名 _）

# 声明方法语法
def 方法名（参数列表）：返回类型 = 方法体   //如果不是声明的递归方法，返回类型可以省略不写
def add(a:Int,b:Int):Int = a + b

# 匿名函数语法   
val fun1 = (x:Int,y:Int) => {    //一般是将一个匿名函数赋值给一个变量
    x + y
} 

# 普通函数语法 

# 柯里化函数，基于普通函数语法定义有多个参数列表

# 高阶函数，基于普通函数语法定义，把方法作为参数列表传递

6、数组

定长数组

val arr0 = new Array[Int](10)   //定义一个长度为10的Int类型的定长数组

变长数组(需要引入包: import scala.collection.mutable.ArrayBuffer)

# 引入包
import scala.collection.mutable.ArrayBuffer
var arr1 = new ArrayBuffer[Int]()   //定义一个Int类型的变长数组

例：给定一个数组 val arr2 = (1, 3, -5, 6, -2, 5, -7, 9) 要求将这个数组中的正数放前面，负数放后面，顺序不变

# 原数组
val arr1 = Array[Int](1,3,-5,6,-2,5,-7,9) 
# 定义两个变长数组
import scala.collection.mutable.ArrayBuffer
var arr2 = new ArrayBuffer[Int]()
var arr3 = new ArrayBuffer[Int]()
# 遍历原数组 通过判断将正数和负数分别放入两个变长数组
for(tmp <- arr1){
    if(tmp > 0) arr2.append(tmp)
    else arr3.append(tmp)
}
# 将两个变长数组进行拼接
arr2 ++= arr3

数组转换（把原数组转换成另一个数组）

# 把数组中的每一个数乘以10变成另一个数组
val arr1 = Array[Int](1,3,-5,6,-2,5,-7,9) 
# 使用推倒式yield
for(e <- arr1) yield e*10
# 调用.map方法
arr1.map(_*10)
# 对数组每一个元素取出来进行过滤（取出数组中的偶数生成新的数组）
arr1.filter(_%2 == 0)

7、集合（需重点掌握）

不可变集合：一旦定义完成是不可以修改的，但可以模拟修改或删除等。
可变集合：定义之后可以修改，可以更新或扩充。
分类：List / set / Map / 序列
List

# 声明不可变List 对不可变集合进行模拟添加元素 会生成新的集合，原集合不会被改变
var list1 = List(1,2,3)
# 在头部添加元素
0 :: list1  或者 0 +: list1 
# 在尾部添加元素
list1 :+ 4
# 两个不可变list集合拼接
list1 ++: list2

# 声明可变List 需要引入包import scala.collection.mutable.ListBuffer
# 引包
import scala.collection.mutable.ListBuffer
var list2 = ListBuffer(1,2,3)
# 追加元素
list2 += 4  或者 list2.append(4)
# 两个可变list集合拼接
list1 ++ list2

# 创建不可变Map集合 
val map1 = Map("Zhang" -> 90, "Li" -> 89)   // scala.collection.immutable.Map
val map2 = Map(("zh",80),("li",85))  //另一种写法
# 创建可变Map需要声明或者引入 scala.collection.mutable.Map 这个包
import scala.collection.mutable.Map
val map3 = Map("java" -> 80,"scala" -> 90)

# 根据键取值，如果键不存在，刚程序会报异常
map1("Zhang")
...
# 加判断取值，键有的情况下再取出，不存在返回-1
if(map2.contains("zh")) map2("zh") else -1
map2.getOrElse("zh",-1) //简便写法
# 返回Map集合中所有的键
map3.keys
# 返回Map集合中把有的值
map3.values
# 通过键修改对应的值 
map3("java") = 95 //值的修改只对可变Map有效，如果对应的键存在则修改对应的值，如果键不存在刚加入集合
# 添加键值对
map3 += ("WangWu" -> 99)
# 删除键值对
map3 -= "WangWu"
# 遍历Map集合
for ((k,v) <- map3) println(k+" : "+v)

# 元组:可以是不同数据类型的对象的集合，并通过 "元组名._索引" 的方式取值；索引从1开始；元组里面的元素值   不允许修改
val v1 = ("java","version",11)     //声明
v1._1；v1._2 //取第一个元素和第二个元素

# 取别名方式创建元组，可直接通过别名a,b,c进行取值
val v2,(a,b,c) = ("scala","java",2019)
println(a)  //输出内容为 scala

# 通过new Tuple[n]("a",2,第n个元素)创建元组
val v3 = new Tuple3("hi","java",11)

# 元组的遍历
v3.productIterator.foreach(println(_))