第3课 Scala中Array、Map、Tuple实战

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

推荐阅读更多精彩内容