Array
//声明变量arr为Array整数类型的数组，包含5个元素。
scala> val arr= new Array[Int](5)
arr: Array[Int] = Array(0, 0, 0, 0, 0)
//访问第三个元素
scala> arr(2)
res15: Int = 0
//修改第三个元素
scala> arr(2)=8
//再次查看arr数组，发现第三个元素值已经变成8了。
scala> arr
res17: Array[Int] = Array(0, 0,8,0, 0)
补充说明，刚才声明arr数组变量时，所以把它声明为val不可变变量，这只是表明arr的地址不可以变，但是数组里面的元素还是可以变化的。
//在Spark中，更常见地创建数组是直接通过类名
scala> val arr1 = Array("Scala", "Spark")
arr1: Array[String] = Array(Scala, Spark)
该示例中，声明arr1为数组变量时，没有使用new关键字，也没有指定String类型，系统默认根据元素值，自动推导出元素的类型为String。
没有使用new关键字，其实它内部调用了apply方法，apply是工厂类构造器。等同于下面的写法：
scala> val arr1 = Array.apply("Scala", "Spark")
arr1: Array[String] = Array(Scala, Spark)
//给Array增加元素。下面写法会出错，给arr1数组增加一个元素，比如：
scala> arr1(2)="Hadoop"
java.lang.ArrayIndexOutOfBoundsException: 2
at .(:16)
at .()
……
如果需要给Array增加元素，那么此时就应该使用ArrayBuffer类型。
ArrayBuffer
//首先导入库
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
//定义一个ArrayBuffer类型的变量arrbuffer
scala> val arrbuffer=ArrayBuffer[Int]()
arrbuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
//向arrbuffer中增加一个元素，值为10
scala> arrbuffer += 10
res23: arrbuffer.type = ArrayBuffer(10)
//向arrbuffer中增加多个元素
scala> arrbuffer += (11,1,3,5)
res25: arrbuffer.type = ArrayBuffer(10, 11, 1, 3, 5)
//查看arrbuffer的内容
scala> arrbuffer
res26: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5)
//向arrbuffer中增加一个数组
scala> arrbuffer ++= Array(1,2,3,4)
res27: arrbuffer.type = ArrayBuffer(10, 11, 1, 3, 5, 1, 2, 3, 4)
//截掉arrbuffer后面的3个元素
scala> arrbuffer.trimEnd(3)
//再次查看arrbuffer的内容，发现元素：2, 3, 4被截掉
scala> arrbuffer
res29: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5, 1)
//在第5个位置，插入元素值100
scala> arrbuffer.insert(5,100)
//查看arrbuffer的内容
scala> arrbuffer
res32: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5,100, 1)
//在第2个位置，插入多个元素：200,300,400
scala> arrbuffer.insert(2,200,300,400)
//查看arrbuffer的内容
scala> arrbuffer
res34: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11,200, 300, 400,1, 3, 5, 100, 1)
//从arrbuffer中移除第3个位置上的元素
scala> arrbuffer.remove(3)
res35: Int = 300//被移除的值是300
//再次查看arrbuffer的内容，发现第3个位置上的元素300不见了。
scala> arrbuffer
res36: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 200, 400, 1, 3, 5, 100, 1)
//从arrbuffer中移除第2个位置开始的，3个元素，即：200, 400, 1
scala> arrbuffer.remove(2,3)
//再次查看arrbuffer的内容，发现三个元素：200, 400, 1不见了。
scala> arrbuffer
res38: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 3, 5, 100, 1)
//可变数组变成不可变数组,此时arr2是一个不可变数组
scala> val arr2 = arrbuffer.toArray
arr2: Array[Int] = Array(10, 11, 3, 5, 100, 1)
//Array.toBuffer的结果变成一个ArrayBuffer
scala> arr2.toBuffer
res40: scala.collection.mutable.Buffer[Int] = ArrayBuffer(10, 11, 3, 5, 100, 1)
//遍历一个数组：
scala> for(elem <- arr2) println(elem)
10
11
3
5
100
1
//遍历数组时加上条件
scala> arr2
res42: Array[Int] = Array(10, 11, 3, 5, 100, 1)
//遍历时的条件，跳过偶数位上的元素
scala> for(i <- 0 until (arr2.length, 2)) println(arr2(i))
10
3
100
此时打印出来的结果，跳过了元素：11、5、1
//从尾部开始遍历
scala> for(i <- (0 until arr2.length).reverse) println(arr2(i))
1
100
5
3
11
10
//对数组进行排序
//导入排序包
scala> import scala.util.Sorting
import scala.util.Sorting
//排序之前
scala> arr2
res42: Array[Int] = Array(10, 11, 3, 5, 100, 1)
//对arr2进行排序
scala> Sorting.quickSort(arr2)
//排序之后
scala> arr2
res49: Array[Int] = Array(1, 3, 5, 10, 11, 100)
//显示arr2中内容
scala> arr2
res49: Array[Int] = Array(1, 3, 5, 10, 11, 100)
//拼接arr2中的每个元素，用逗号拼接，生成一个字符串
scala> arr2.mkString(",")
res50: String = 1,3,5,10,11,100
//循环arr2里面的每个元素，对其进行自乘运算，并把结果收集起来，产生一个新的数组，赋给arr3
scala> val arr3 = for(i <- arr2) yield i*i
arr3: Array[Int] = Array(1, 9, 25, 100, 121, 10000)
// for循环再加上if条件判断，仍然是循环arr2里面的每个元素，对其进行自乘运算，并把结果收集起来，产生一个新的数组，赋给arr3
scala> val arr3 = for(i <- arr2 if i%3==0) yield i*i
arr3: Array[Int] = Array(9)
此时arr3中只有一个元素。
//在scala实际会用它的函数式编程来实现以上代码
scala> arr2.filter(_%3 ==0).map(i => i*i)
res61: Array[Int] = Array(9)
这种写法非常优雅简洁，生成的结果跟上面一样。map本身是一个函数，里面传入的参数仍然是一个函数。
//上一行示例中的括号，其实可以改成花括号。
scala> arr2.filter{_%3 ==0}.map{i => i*i}
res62: Array[Int] = Array(9)
//甚至可以省略map前面的点号
scala> arr2.filter{_%3 ==0}map{i => i*i}
res63: Array[Int] = Array(9)
效果跟上一行是一样的。
Map
//Map里面的元素是Key、Value对，如下所示：
scala> val persons = Map("Spark" -> 6, "Hadoop"->11)
persons: scala.collection.Map[String,Int] = Map(Spark -> 6,Hadoop -> 11)
//访问Key为"Hadoop"的元素，获得该键值对中的Value
scala> persons ("Hadoop")
res65: Int = 11
//申明一个可变Map变量，Key是String，Value是Int类型
scala> val pesons = scala.collection.mutable.Map("Spark" -> 6, "Hadoop"->11)
pesons: scala.collection.mutable.Map[String,Int] = Map(Hadoop -> 11, Spark -> 6)
//对其进行增加元素操作
scala> persons += ("Flink" -> 5)
res67: persons.type = Map(Hadoop -> 11, Spark -> 6,Flink -> 5)
//对其进行减元素操作
scala> persons -= "Flink"
res68: persons.type = Map(Hadoop -> 11, Spark -> 6)
//通过条件判断来获取map元素的值，判断该元素是否存在
scala> val sparkValue = if(persons.contains("Spark")) persons("Spark") else 1000
sparkValue: Int = 6
//Map自带getOrElse函数用于获取某个元素
//首先查看persons的内容
scala> persons
res70: scala.collection.mutable.Map[String,Int] = Map(Hadoop -> 11, Spark -> 6)
//访问时存在Spark元素
scala> val sparkValue = persons.getOrElse("Spark",1000)
sparkValue: Int = 6
//访问时不在Flink元素
scala> val sparkValue = persons.getOrElse("Flink",1000)
sparkValue: Int =1000
//循环遍历Map中的元素
scala> for((key,value) <-persons) println("key:"+key+",value:"+value)
key:Hadoop,value:11
key:Spark,value:6
//注意，此时(key,value)其实是一个Tuple
//遍历Map中的全部的Key
scala> for(key <-persons.keySet) println("key:"+key)
key:Hadoop
key:Spark
//SortedMap
scala> val persons = scala.collection.immutable.SortedMap("Spark" ->6, "Hadoop" -> 11)
persons: scala.collection.immutable.SortedMap[String,Int] = Map(Hadoop -> 11, Spark -> 6)
此时Hadoop元素排在Spark元素的前面
Tuple
一个元组里面有很多不同的类型的元素，接收函数的多个参数时，Tuple特别有用！
//定义了一个Tuple，里面有三个不同类型的元素
scala> val tuple = ("Spark",6,99.01)
tuple: (String, Int, Double) = (Spark,6,99.01)
//访问Tuple变量的第1个元素，注意是顺序从1开始！
scala> tuple._1
res72: String = Spark
//访问Tuple变量的第2个元素。
scala> tuple._2
res73: Int = 6
