版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/myvanguard/article/details/86605941
第1章 Scala光速入门
本章通过Scala基础与语法以及Array、Map等数据结构的丰富的代码实战带领大家快速掌握Scala入门需要的知识。
1.1Scala 基础与语法入门实战
1.1.1Scala基本数据类型
Scala包括8种常用数据类型：Byte、Char、Short、Int、Long、Float、Double和Boolean。
String也是Scala基本数据类，String属于java.lang包，其余的所有基本类型都是Scala的包成员，例如Int是scala.Int。Scala中基本类型包和java.lang包是默认导入的。
1.1.2Scala变量声明
Scala通过var和val来声明变量。
- 定义val类型变量
val类型变量定义后不可以重新赋值。val类型变量相当于Java中final修饰的变量。 - 定义var类型变量var类型变量确定以后值可以修改。
1.1.3算术操作符介绍
Scala有丰富的内置运算符，Scala的操作符也是函数，可以通过“对象.运算符()”
1.1.4条件语句
条件语句语法结构的两种方式如下。
方式一：写在同一行。
if(布尔表达式)x else y
方式二：写在不同行并且有多条语句组成的结构体。
if(布尔表达式){
}else{
}
var t2 =10
var result = if(t2==10){10}
1.1.5循环
Scala中循环结构有for、while、do-while循环等。
（1）for循环
for循环语句可以重复执行某条语句，直到某个条件得到满足，才退出循环for 语法：
for(变量<-集合){
循环体
}
object ObjFor {
def main(args: Array[String]): Unit = {
val t1 = if (3 > 1) 8 else 1
println(t1)
var t2 = 10
if (t2 < 20) {
println(t2 + "<=" + 20)
} else {
println(t2 + ">" + 20)
}
var result = if (t2 == 10) {
10
}
println(result)
for (i <- 1 to 10) print(i + " ")
for (i <- 1 to 10 if i % 2 == 0) print(i + "") //for循环中使用守卫
for (i <- 1 to 10 if i % 2 == 0; if i != 2) print(i + "")
//嵌套枚举是指由多个循环条件的for结构体，循环次数为n*m次
for (i <- 1 to 5; j <- 1 to 5 if i % 2 == 0) print(i * j + "")
val vl = for (i <- 1 to 5) yield i //利用yield关键字返回一个新集合
}
}
（2）while循环
while语句为条件判断语句，利用一个条件来控制是否要继续反复执行循环体中的语句。
while(条件表达式){
循环体
}
在for和while中都没有用到break和continue，这是因为在scala中没有break和continue两个关键字，continue可以通过if条件语句来控制是否要向下执行，而break 语句在scala中有特殊的实现
import scala.util.Random
import scala.util.control.Breaks._
object ControlStatementBreak {
def main(args: Array[String]): Unit = {
breakable {
while (true) {
val r = new Random()
val i = r.nextInt(10)
println("i==" + i)
if (i == 5) {
break
}
}
}
}
}
（3）do-while循环
do-while循环语句先执行while循环中的循环体至少要执行一次
do{
循环体
}while(条件表达式)
var count = 4
//do-while循环语句先执行一次循环语句，再判断条件是否成立
do{
println(count)
count -= 1
}while(count >=0)
1.1.6异常控制
Scala的异常处理有两种方式：捕获异常和抛出异常。
（1）抛出异常使用关键字throw 例如：
throw new IllegalArgumentException
（2）捕获异常 例如：
try{
}catch{
case e1:NulPointException =>e1.printStackTrace()
case en:InterruptException =>en.printStackTrace()
}finally{
println("finally 语句不一定会有，如果有一定会执行")
println("通常用来释放资源！！！")
}
import java.io.FileNotFoundException
import scala.io.Source
object ReadFileTest {
def main(args: Array[String]): Unit = {
try{
val file = Source.fromFile("F://2.txt")
val lines = file.getLines()
for(content <- lines){
println(content)
}
}catch {
case ex:FileNotFoundException => println("输入的文件不存在"+ex)
case ex:Exception => println(ex)
}finally {
println("通常用来释放资源!!!")
}
}
}
1.2 Scala中Array、Map 等数据结构实战
1.2.1定长数组和可变数组
Scala中数组分为可变和不可变数组。默认情况下定义的是不可变（Immutable）数组;若定义可变数组，需要显示导入包import Scala.collection.mutable.ArrayBuffer。
1.2.2数组常用算法
import scala.collection.mutable.ArrayBuffer
object ObjectArray {
def main(args: Array[String]): Unit = {
val strArray = Array("Scala", "Spark")
//直接赋值
val intArray = new Array[Int](10)
//初始化10个长度的数组
val arrayBuffer = ArrayBuffer[Int]() //可变长数组
strArray(0) = "Storm" //修改数组的参数值
strArray.mkString(",") //指定分隔符
strArray.toBuffer; //将不可以变化的数组转化为可以变化的数组
//遍历数组
for (i <- 0 until strArray.length) println(strArray(i))
for (elem <- strArray) println(elem) //增强for循环
Array(1, 2, 3, 4).sum //求和
arrayBuffer += 1 //+=在尾端添加元素
arrayBuffer += (2, 3, 4, 5) //同时在尾端添加多个元素
arrayBuffer ++= arrayBuffer //++=追加任何集合
arrayBuffer.trimEnd(2) //移除最后2个元素
arrayBuffer.remove(2) //移除2+1个元素
arrayBuffer.remove(2, 4)
//第三个元素开始移除4个元素
val arrayBufferInt = arrayBuffer.toArray; //把数组缓冲转换为数组Array
}
}
1.2.3Map映射
Scala映射就是键值对的集合Map。默认情况下，Scala中使用不可变的映射。如果想使用可变集，必须明确地导入scala.collection.mutable.Map类。
object ObjectMap {
def main(args: Array[String]): Unit = {
val map = Map("Scala" -> 25, "Hadoop" -> 30, "Spark" -> 35)
map("Scala") //获取map值
map.contains("Hadoop") //是否包含key hadoop
map.getOrElse("Spark", 70) //存在则返回value 否则返回70
map.mkString("{", ",", "}") //添加分隔符
map.drop(2) //从0开始 丢掉脚本为2的元素 即为Spark
val mapVar = scala.collection.mutable.Map("Scala" -> 25, "Hadoop" -> 30, "Spark" -> 35) //创建可变map
mapVar("Spark") = 100
mapVar += ("Kafka" -> 90) //添加键值对
mapVar -= ("Kafka") //删除键值对
//遍历map
for ((k, v) <- map) println(k + " " + v)
//遍历key
for (k <- map.keySet) println(k)
//遍历value
for (v <- map.values) println(v)
}
}
1.2.4Tuple元组
元组是由两个小括号包住的数据集合，里面可以存放不同的类型。
val tuple1 = (1,2,3,"Hadoop","Spark")
tuple1._1//访问第一个元素
tuple1._2//访问更多元素通过_n
1.2.5 List列表
Scala中列表是非常类似于数组，所有元素都具有相同的类型，
但有两个重要的区别。
第一，Scala列表是不可变的，元素可以不被分配来改变。
第二，Scala列表表示一个链表。
object ObjectList {
def main(args: Array[String]): Unit = {
val fruits: List[String] = List("apple", "orange", "pear")
//定义整型数组
val nums: List[Int] = List(1, 2, 3, 4, 5)
//定义int类型的数组
val empty: List[Nothing] = List()
//定义空List
val dim: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6))
//使用Nil和::来构建模块 Nil表示空列表
val fruit = "apple" :: ("orange" :: ("pear" :: Nil))
val num = 1 :: (2 :: (3 :: (4 :: Nil)))
println(fruit.head)
println(fruit.tail)
println(fruit.isEmpty)
//使用:::运算符或者列表List.:::()或者List.concat()方法
var f1 = "apple" :: ("orange" :: ("pear" :: Nil))
var f2 = "mongo" :: ("banana" :: Nil)
var f3 = f1 ::: f2
println(f3)
var f4 = List.concat(f1, f2)
println(f4)
}
}
1.2.6Set集合
Scala集合是不包含重复元素的集合。Set集合分为不可改变的和可变的。可变和不可变的对象之间的区别在于，当一个对象是不可变的，对象本身不能被改变。
object ObjectSet {
def main(args: Array[String]): Unit = {
var s:Set[Int] = Set()//定义空Set集合
var s1:Set[Int]=Set(1,2,3,4)
var s2 = Set(12,3,4)
var s3:Set[String]=Set("Scala","Spark")
s3.head
s3.tail
s3.isEmpty
}
}
1.2.7Scala集合方法大全
