1、其类型首字母都要大写。
scala变量定义，首先需要一个关键字 val 或者 var 接着是变量名 ： 冒号后面跟着变量类型 = 等号后面跟着变量值
val a:Int =1 定义一个变量 a ，是整形 ，初始值是1
如果定义float类型的话，小数点后面要加一个f(因为有小数都认为是double类型)
还有一个对于String类型，用的都是双引号（可以是一个字符也可以是多个字符）
对于chart类型，用的都是单引号。（只能是一个字符）
boolean类型，是ture或者false
在应用中，scala编辑器是自动识别推断其类型，但是对应的单引号或者双引号要正确。
对于整形中的byte,long,short等类型，要指明确告诉它要将它定义成为其中的类型。
对于关键字val 与var，
val定义了一个变量值后，变量值是不能再改变了
var定义了一个变量值后，其变量值还可以改变
2、程序控制语句。
a、 if 语法结构
if ("about" == "yun") { println("about == yun") } else { print("about != yun") }
// 输出 about != yun
// 使用if 语法定义变量，x结果为0
val x = if ("about" == "yun") 1 else 0
b、 while 语法结构
var x = if ("about" == "yun") 1 else 0
while (x < 5){ x += 1 println("x: %s".format(x)) }
c、
val arrs = Array("aboutyun", "hadoop", "spark") //一个数组（可用while也可用for循环输出）
// 集合操作方式（常用） for (arr <- arrs){ println("arr: %s".format(arr)) } 但有前缀
// 间接操作方式
for (i <- 0 to arrs.length - 1){ println("arr: %s".format(arrs(i))) }//用的是to
for(i<-0 until arrs.length){println(arrs(i))}//用的是until
d、for循环
// 生成一个0到5的集合
val arrs = 0 to 5
// 针对arrs中的偶数乘以2生成一个新的集合 for (arr <- arrs if arr % 2 == 0) yield arr * 2
// for循环嵌套
for (i <- "abc"; j <- "xyz") println(s"$i+$j")
for (i <- "abc"; j <- "xyz") {println("i:%s,j:%s".format(i,j))}//其实%s,输出字符串时，将i,j替换前面的%
3、Array/List的基本操作
a、// 定义一个长度为5的整型数组
scala> val arrs = new Array[Int](5) //这里用new
arrs: Array[Int] = Array(0, 0, 0, 0, 0)
// 赋值给第一个索引
scala> arrs(0) = 100
scala> arrs// 直接输入数组名就能输出其内容
res22: Array[Int] = Array(100, 0, 0, 0, 0)
// 使用apply方法定义数组及赋值
scala> val arrs = Array[Int](100, 200, 300) //这里不用new，而是让它自动调用apply
arrs: Array[Int] = Array(100, 200, 300)
b、array的遍历
scala> val arrs = Array[Int](100, 200, 300)
arrs: Array[Int] = Array(100, 200, 300)
方式一：scala> for (arr <- arrs) println(arr) //表示对其遍历打印出来
方式二：scala>for(i<-0 until arrs.length){println(i)}//打印i是其索引。如果打印的是arrs(i)则是其里面的每个元素
c、List的定义和操作
// 构造List对象
scala> val list = List(1, 2, 3) //内部用的是apply的方式。直接定义名字
list: List[Int] = List(1, 2, 3)
// 使用Nil和 :: 追加符来构建
scala> val list = 1 :: 2 :: 3 :: Nil //方式二：nil 是一个空的list,可以直接输出空集合， 先创建一个空集合，：：就是不断添加元素
list: List[Int] = List(1, 2, 3)
// 添加元素
scala> list :+ 4 //方式三：集合后面添加一个冒号： 添加一个加号+ 然后就是要添加的元素了。也可以往前加
res60: List[Int] = List(1, 2, 3, 4)
scala> list
res61: List[Int] = List(1, 2, 3)
// mkString使用“_”拼接元素（制作字符串）
scala> list.mkString("_") //表示拼接时候用什么拼接
res62: String = 1_2_3
其他常用方法：head, last, take //list.head 是取第一个 list.last是最后一个元素 list.take是取多少个元素，并且生成新的list
d、List的遍历
// 方式一
scala> for (l <- list) print(l + ",") //直接打印每个元素，对于可循环的都能用
1,2,3,
// 方式二
scala> list.foreach(l => print(l + ","))//不需要再输入集合的名字了。l就表示list里面的每一个元素。
1,2,3,
在scala终端，输入一个list在输入一个点 . 回车后，会出list所有能调用的方法。
这两种方式的区别：
4、Set/Map/Tuple 操作
set有一个功能可以去重，元素不重复。map是映射，里面的元素是有两部分。Tuple里面的元素可以是不同类型的
a、Set的操作
Scala 默认导入一下的包：
import java.lang._ import scala._ import Predef._
Predef中默认包含了 不可变的Set/Map，如果要使用可变的集合需要手动导入scala.collection.mutable包
Set是一种不存在重复元素的集合，与数学中定义的集合是对应的。且是无顺序的。
// 定义Set
scala> val set = Set(1, 2, 1, 3)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3) 自动去重
// 增加元素
scala> set + 5
res98: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 5)
b、Map操作
Map 是一种键值对的集合，一般翻译成映射
// 定义不可变 Map 键与值之间用->进行分隔
scala> val map = Map("aboutyun" -> "a", "hadoop" -> "h", "spark" -> "s")
map: scala.collection.immutable.Map[String,String] = Map(aboutyun -> a, hadoop -> h, spark -> s)
// 定义可变 Map（在前面导入一个包名时候是可变的）
scala> val map2 = scala.collection.mutable.Map("aboutyun" -> "a", "hadoop" -> "h", "spark" -> "s")
map2: scala.collection.mutable.Map[String,String] = Map(spark -> s, hadoop -> h, aboutyun -> a)
// 添加元素，用put的方法
scala> map2.put("flume","f")
res128: Option[String] = None
scala> map2
res129: scala.collection.mutable.Map[String,String] = Map(spark -> s, hadoop -> h, aboutyun -> a, flume -> f)
可变的，是复制初始化后，还可以对其内容进行修改，增加。而不可变的一旦初始化后就不能变了。
c、Tuple 操作
Tuple 是一种可以包含多个类型元素的集合，一般翻译成元组
// 定义元组
scala> val tuple = ("aboutyun", "hadoop", 1) //tuple定义的时候要用括号，
tuple: (String, String, Int) = (aboutyun,hadoop,1) //回车后就会输出显示其类型
// 二元组特殊定义方式 （其实和map的键值对是差不多的）
scala> val tup = "aboutyun" -> 1
tup: (String, Int) = (aboutyun,1)
// 访问第一个元素
scala> tuple._1（返回第一个元素，与前面的取索引是不一样的。）
res141: String = aboutyun
// 模式匹配获取元素内容
scala> val (a, b) = tup
a: String = aboutyun
b: Int = 1
d、遍历方式
5、函数和常用高阶函数
a、函授的格式
def是一定要使用的， 函数体也是函数的功能。
b、函授字面量
函数字面量表示函数可以赋值给变量
Scala函数将最后的值作为函数的返回值，不需要return语句
// 定义一个自增函数
scala> def increase(x:Int): Int = {x+1}
increase: (x: Int)Int
scala> increase(1)
res145: Int = 2
// 使用incr引用increase函数，=>左侧表示输入，右侧表示转换操作
scala> val incr = (x: Int) => x + 1 （=>的的左边表示要接收的参数类型，右边是一个方法体）
incr: Int => Int = <function1> （函授赋值给变量也）
scala> incr(1)
res151: Int = 2
c、匿名函授
集合的map函数可以对集合中的每个元素进行操作，接受的参数为针对元素进行操作的函数，例如相对List(1, 2, 3)集合中每个元素加1，可以使用以下方法：
scala> println(List(1, 2, 3).map(incr)) （如果函授的参数又是另一个函授的话，则称之为高阶函数）
List(2, 3, 4)
// 使用匿名函数进行简化
scala> println(List(1, 2, 3).map((x:Int) => x + 1)) （这里不用写匿名函授了，而是直接写函授字面量）
List(2, 3, 4)
d、函授简化
// 简化匿名函数，自动判断类型
scala> println(List(1, 2, 3).map((x)=> x + 1))
List(2, 3, 4)
// 简化匿名函数，函数参数只有一个，可以省略 ()
scala> println(List(1, 2, 3).map(x=> x + 1))
List(2, 3, 4)
// 简化匿名函数，函数参数右侧只出现一次，可以进一步简化
scala> println(List(1, 2, 3).map(_ + 1))
List(2, 3, 4)
// 可以使用花括号{} 替代小括号 ()
scala> println(List(1, 2, 3).map{_ + 1})
List(2, 3, 4)
e、常用的高阶函数
map
map函数用于对集合中的每个元素进行转换
// 对列表中所有元素加1
scala> println(List(1, 2, 3).map(_ + 1))
List(2, 3, 4)
// 获取所有key
scala> println(Map("spark"->1,"hive"->2,"hadoop"->3).map(_._1))
List(spark, hive, hadoop)
// 等价于
scala> println(Map("spark"->1,"hive"->2,"hadoop"->3).map(x => x._1))
List(spark, hive, hadoop)
// 等价于
scala> println(Map("spark"->1,"hive"->2,"hadoop"->3).map{case (k, v) => k})
List(spark, hive, hadoop)
flatten
flatten 函数用于对嵌套的集合展开，函数接收的参数类型为集合类型
scala> println(List(List(1, 2, 3), List(5, 6)).flatten(x=>x.reverse))
List(3, 2, 1, 6, 5)
scala> println(List(List(1, 2, 3), List(5, 6)).flatten)
List(1, 2, 3, 5, 6)
flatMap
flatMap函数结合了flatten和map两个函数的功能
scala> println(List(List(1, 2, 3), List(5, 6)).flatMap(x => x.map(x => x + 1)))
List(2, 3, 4, 6, 7)
scala> println(List(List(1, 2, 3), List(5, 6)).flatMap(_.map(_ + 1)))
List(2, 3, 4, 6, 7)
filter
filter函数用于筛选集合中满足某些条件的元素
scala> println(List("List","Set","Array").filter(_.length>3))
List[String] = List(List, Array)
scala> println(Map("List"->3,"Set"->5,"Array"->7).filter(_._2>3))
Map(Set -> 5, Array -> 7)
reduce
reduce函数用于对集合做聚合，接受两个参数，常用于把当前结果和集合的下一个元素累加
scala> println(List(1, 2, 3, 4).reduce((x, y) => x + y))
10
// 简化
scala> println(List(1, 2, 3, 4).reduce(_ + _))
10