Scala进阶之路-高级数据类型之集合的使用

　　　　　　　　　　　　Scala进阶之路-高级数据类型之集合的使用

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

　　Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable 特质在 Scala 中集合有可变（“scala.collection.mutable” 包下存放）和不可变（“scala.collection.immutable” 包下存放）两种类型，immutable 类型的集合初始化后就不能改变了（注意与 val 修饰的变量进行区别）。

一.Seq  序列

1>.不可变的序列 import scala.collection.immutable._

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function

object SetOperation {
    def main(args: Array[String]): Unit = {
        //定义一个list
        var list = List("yinzhengjie","Python","Golang","Java","Scala")
        //查看list的头
        print(s"list.head=====> ${list.head}
")
        //查看list的尾，尾就是出了头部的数据
        print(s"list.tail=====> ${list.tail}
")
        //Nil表示为空，此时的list为空
        list = Nil
        print(s"list=====> ${list}
")
        /**
          *     "::" 操作符是将给定的头和尾创建一个新的列表。
          *     注意,"::" 操作符是右结合的，如 100::200::300::Nil 相当于 100::(200::(300::Nil))
          */
        var list2 = 100::200::300::list
        println("list2=====>"+list2)
        //“+”是拼接操作
        var list3 = list2 + ("666666")
        print(s"list3=====> ${list3}
")
        //“++”是将两个集合进行拼接操作，最终会返回一个新的list对象，将右边的集合的每一个元素追加在左边集合的尾部
        var list4 = list2 ++ List("J","Q","K")
        print(s"list4=====> ${list4}
")
        //“++:”是将右边的集合的每一个元素元素放置在左边集合的头部哟
        var list5 = list2.++:(List("J","Q","K"))
        print(s"list5=====> ${list5}
")
        //“+:”是将右边的集合的放置在左边集合的头部，并非是将右边的集合的每个元素放进去！
        var list6 = list2.+:(List("J","Q","K"))
        print(s"list6=====> ${list6}
")
        //“:+”是将右边的集合的放置在左边集合的尾部部，并非是将右边的集合的每个元素放进去！
        var list7 = list2.:+(List("J","Q","K"))
        print(s"list7=====> ${list7}
")
        //“::”方法是将右边集合的每个元素和左边的集合合并为一个新的集合
        var list8 = list2::(List("J","Q","K"))
        print(s"list8=====> ${list8}
")
        //判断list9集合中存在偶数的个数
        val list9 = List(9,2,3,6,8,7,1,4,5)
        val  res1 = list9.count(x => x % 2 == 0)
        print(s"res1=====> ${res1}
")
        //判断list9集合中偶数的值
        val res2 = list9.filter(x => x % 2 == 0)
        print(s"res2=====> ${res2}
")
        //对list9进行升序排序
        val  res3 = list9.sorted
        print(s"res3=====> ${res3}
")
        //list9进行降序排序,如果我们不用负号("-")，那么默认是以升序排序
        val res4 = list9.sortBy(x => -x)
        print(s"res4=====> ${res4}
")
        //根据wordCount中的Int类型进行排序
        val wordCount = List(("yinzhengjie",100),("Scala",80))
        val res5 = wordCount.sortWith((x,y) => x._2 > y._2)
        print(s"res5=====> ${res5}
")
        //指定每个分组允许的最大个数
        val  lis10 = List("yinzhengjie","Shell","Python","VBS","HTML","CSS","JavaScript","Golang","Java","Scala")
        val res6 = lis10.grouped(3)
        res6.foreach(x => print(x  + "	"))
        print(s"res6=====> ${res6}
")
        /**
          * 注意fold(定义初始值)(叠加的函数)
          *     分析：val  res7 = list11.fold(0)(_+_)
          *     fold(0)中的初始值为 : 0
          *     (_+_)是叠加的函数，左边的下划线是初始值，右边的下划线是list11中的每一个元素
          *     综上所述：
          *         list11.fold(0)(_+_)会进行三次运算,因为list11的长度为3.
          *         第一次运算，计算结果为: (0+9)
          *         第二次运算的初始值是第一次计算的结果，计算结果为: (9+2)
          *         第三次运算的初始值是上一次计算的结果，计算结果为: (11+3)
          *         因此，我们可以得到最终的结果应该为: 14
          */
        val list11= List(9,2,3)
        val  res7 = list11.fold(0)(_+_)         //其实我们也可以这样写:val  res7 = list11.fold(0)((x,y) => x + y)
        print(s"res7=====> ${res7}
")
        /**
          * 相信你理解了上面的fold的方法，那么下面的fold的方法你估计也再熟悉不过了，因为fold底层调用的就是foldLeft方法。
          */
        var res8 = list11.foldLeft(0)(_+_)
        var res9 = list11.foldLeft(0)(_-_)
        print(s"res8=====> ${res8}
")
        print(s"res9=====> ${res9}
")
        /**
          * 在你理解foldLeft的工作原理后，相信foldRight对你来说更是小菜一碟啦，因为foldLeft和fold都是从左往右计算
          *     第一次运算,计算结果为: (9-0)
          *     第二次运算的初始值是上一次计算的结果,计算结果为: (2-9)
          *     第三次运算的初始值是上一次计算的结果，计算结果为: (3-(2-9))
          *     因此，我们可以得到最终的结果应该为: 10
          */
        var res10 = list11.foldRight(0)(_-_)
        print(s"res10=====> ${res10}
")
        //反转list的值，使用reverse方法
        var list12 = List("yinzhengjie","Shell","Python","Scala")
        list12 = list12.reverse
        print(s"list12=====> ${list12}
")
        //将列表进行聚合操作，如果列表中有字符串就直接拼接，如果全部是int类型就累加操作
        val res11 = list12.reduce((x,y) => x + y)
        print(s"res11=====> ${res11}
")
        //aggregate(在Spark已经把它封装为reduceByKey)可以模拟并行化集合，可以把集合打散，在非并行化底层还是调用的foldLeft
        var res12 = list11.aggregate(0)(_ + _,_+_)
        print(s"res12=====> ${res12}
")
        //计算出两个集合中的并集，就可以调用union方法
        var list13 = List(1,3,5,7,9,0,8)
        var list14 = List(8,0,7,2,4,6)
        var res13 = list13.union(list14)
        print(s"res13=====> ${res13}
")
        //计算交集,调用intersect方法即可
        var res14 = list13.intersect(list14)
        print(s"res14=====> ${res14}
")
        //计算两个集合的差集，即可以理解为不同元素
        var res15 = list13.diff(list14)
        print(s"res15=====> ${res15}
")
        //拉链函数,可以把两个元素集合的没有索引进行咬合，新城一个新的元组。如果一个集合中比另一个集合元素要少，那么会以较少元素个数的集合进行匹配。
        var res16 = list13.zip(list14)
        print(s"res16=====> ${res16}
")
        //格式化字符串操作,比如以“|”将list13中的每个元素隔开，并将结果以字符串的形式返回
        var res17 = list13.mkString("|")
        print(s"res17=====> ${res17}
")
        //计算集合的大小或者是长度
        var res18 = list13.size
        var res19 = list13.length
        print(s"res18=====> ${res18}
")
        print(s"res19=====> ${res19}
")
        //对应list取切片操作，和Python语法有点像，同样也是挂前不顾后！
        var list15 =List("yinzhengjie","Hadoop","Nginx","MySQL","TomCat","Httpd")
        var res20 = list15.slice(1,3)
        print(s"res20=====> ${res20}
")
        //对一个Int类型的结合进行求和运算
        var list16 = List(1,2,3,4,5,6,7,8,9,10)
        var res21 = list16.sum
        print(s"res21=====> ${res21}
")
    }
}


/*
以上代码执行结果如下:
list.head=====> yinzhengjie
list.tail=====> List(Python, Golang, Java, Scala)
list=====> List()
list2=====>List(100, 200, 300)
list3=====> List(100, 200, 300)666666
list4=====> List(100, 200, 300, J, Q, K)
list5=====> List(J, Q, K, 100, 200, 300)
list6=====> List(List(J, Q, K), 100, 200, 300)
list7=====> List(100, 200, 300, List(J, Q, K))
list8=====> List(List(100, 200, 300), J, Q, K)
res1=====> 4
res2=====> List(2, 6, 8, 4)
res3=====> List(1, 2, 3, 4, 5, 6, 7, 8, 9)
res4=====> List(9, 8, 7, 6, 5, 4, 3, 2, 1)
res5=====> List((yinzhengjie,100), (Scala,80))
List(yinzhengjie, Shell, Python)    List(VBS, HTML, CSS)    List(JavaScript, Golang, Java)    List(Scala)    res6=====> empty iterator
res7=====> 14
res8=====> 14
res9=====> -14
res10=====> 10
list12=====> List(Scala, Python, Shell, yinzhengjie)
res11=====> ScalaPythonShellyinzhengjie
res12=====> 14
res13=====> List(1, 3, 5, 7, 9, 0, 8, 8, 0, 7, 2, 4, 6)
res14=====> List(7, 0, 8)
res15=====> List(1, 3, 5, 9)
res16=====> List((1,8), (3,0), (5,7), (7,2), (9,4), (0,6))
res17=====> 1|3|5|7|9|0|8
res18=====> 7
res19=====> 7
res20=====> List(Hadoop, Nginx)
res21=====> 55
 */

2>.可变的序列 import scala.collection.mutable._

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.function

import scala.collection.mutable.ListBuffer

object ListOperationDemo {

    def main(args: Array[String]): Unit = {
        //构建一个可变列表，初始有 3 个元素 1,2,3
        val res = ListBuffer[Int](1,2,3)
        print(s"res=====> ${res}
")

        //创建一个空的可变列表
        val res2 =  new ListBuffer[Int]
        print(s"res2=====> ${res2}
")

        //向 res2 中追加元素，注意：没有生成新的集合
        res2+= 4
        res2.append(5)
        print(s"res2=====> ${res2}
")

        //将 res2 中的元素追加到 res 中， 注意：没有生成新的集合
        res ++= res2
        print(s"res=====> ${res}
")

        //将 res 和 res2 合并成一个新的 ListBuffer 注意：生成了一个集合
        val res3 = res ++ res2
        print(s"res3=====> ${res3}
")

        //将元素追加到 res 的后面生成一个新的集合
        val res4 = res :+ 10
        print(s"res4=====> ${res4}
")
    }
}




/*
以上代码执行结果如下 :
res=====> ListBuffer(1, 2, 3)
res2=====> ListBuffer()
res2=====> ListBuffer(4, 5)
res=====> ListBuffer(1, 2, 3, 4, 5)
res3=====> ListBuffer(1, 2, 3, 4, 5, 4, 5)
res4=====> ListBuffer(1, 2, 3, 4, 5, 10)
 */

二.Set集合

1>.不可变的 Set

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function


object setOperationDemo {
    def main(args: Array[String]): Unit = {
        var s1 =Set(1,2,3,5)
        var s2 =Set(2,3,4)
        //计算交集
        val res1 = s1.intersect(s2)
        val res2 = s1 & s2
        println(s"res1 ======> ${res1}")
        println(s"res2 ======> ${res2}")
        //计算并集
        val res3 = s1.union(s2)
        val res4 = s1 | s2
        println(s"res3 ======> ${res3}")
        println(s"res4 ======> ${res4}")
        //计算差集
        val res5 = s1.diff(s2)
        val res6 = s1 &~ s2
        println(s"res5 ======> ${res5}")
        println(s"res6 ======> ${res6}")

        /**
          * 查看当前使用的是哪个类
          */
        println(s1.getClass)
    }
}



/*
以上代码执行结果如下 :
res1 ======> Set(2, 3)
res2 ======> Set(2, 3)
res3 ======> Set(5, 1, 2, 3, 4)
res4 ======> Set(5, 1, 2, 3, 4)
res5 ======> Set(1, 5)
res6 ======> Set(1, 5)
class scala.collection.immutable.Set$Set4
 */

2>.可变的 Set

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function

import scala.collection.mutable

object setOperationDemo {
    def main(args: Array[String]): Unit = {
        /**
          * 创建一个可变的 HashSet
          */
        val set1 =  new mutable.HashSet[Int]()
        print(s"set1=====> ${set1}
")
        /**
          * 向“HashSet ”中添加元素 :
          *     1>.由于set的顺序是无序的，因此插入过程中可能不存在 ;
          *     2>.add一般用于追加一个元素 ;
          *     3>.如果想要一次性追加多个元素可以用".+="的方式添加，也可以使用“++=”操作符 ;
          */
        set1.add(4)
        set1 += (100,500)
        set1.+=(300,200)
        set1 ++= Set (1,3,5)
        print(s"set1=====> ${set1}
")

        /**
          * 向“HashSet”中删除元素 :
          *     1>.删除一个元素一般用"remove"方法 ;
          *     2>.如果要删除多个元素
          */
        set1 -= (100,200)
        set1.-=(3,4)
        set1.remove(5)
        print(s"set1=====> ${set1}
")

        /**
          * 查看当前使用的是那个类
          */
        println (set1.getClass)
    }
}



/*
以上代码执行结果如下 :
set1=====> Set()
set1=====> Set(1, 300, 100, 5, 3, 500, 4, 200)
set1=====> Set(1, 300, 500)
class scala.collection.mutable.HashSet
 */

三.Map映射

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar

import scala.collection.mutable

object MapDemo {
    def main(args: Array[String]): Unit = {
        //定义不可变的map
        val map = Map[String,Int]("尹正杰" -> 18)
        print(s"map=====> ${map}
")

        //定义一个可变的map
        val changeableMap = mutable.HashMap[String,Int]()
        print(s"changeableMap=====> ${changeableMap}
")

        //往可变map中添加元素，这种添加方式和Java如出一辙
        changeableMap.put("尹正杰", 26 )
        changeableMap += "yinzhengjie" -> 18                    //当然Scala也可以使用“+=”添加元素哟
        changeableMap +=(("JDK",8),("Scala",2),("Hadoop",2))    //如果想要一次性添加多个元素，每个元素有逗号分隔即可
        print(s"changeableMap=====> ${changeableMap}
")

        //删除map中元素
        changeableMap.remove("Scala")
        print(s"changeableMap=====> ${changeableMap}
")
        changeableMap.-=("Hadoop")                              //当然Scala也可以使用“-=”删除元素哟
        print(s"changeableMap=====> ${changeableMap}
")

        //获取Map中的元素
        val  res1 = map.get("尹正杰").get
        print(s"res1=====> ${res1}
")
        val res2 = changeableMap.get("尹正杰").get
        print(s"res2=====> ${res2}
")

        //getOrElse方法是判断Map中是否有某个key，如果有就返回具体的值，若没有则返回我们提前设定的值
       val res3 = changeableMap.getOrElse("Python",100)
       val res4 = changeableMap.getOrElse("JDK",200)
        print(s"res3=====> ${res3}
")
        print(s"res4=====> ${res4}
")

        /**
          * 扩充知识点:
          *     在Scala 中Option 类型样例类用来表示可能存在或也可能不存在的值(Option 的子类有Some
          * 和None)。Some 包装了某个值，None 表示没有值。
          *         Option 是Some 和None 的父类
          *         Some 代表有（多例），样例类
          *         None 代表没有（单例），样例对象
          */
        var res5:Option[Any] = Some("yinzhengjie","python","shell","vbs")
        print(s"res5=====> ${res5}
")
        //取出Option的值
        val  res6 = res5.get
        print(s"res6=====> ${res6}
")
        //判断Option是否为空
        val  res7 = res5.isEmpty
        print(s"res7=====> ${res7}
")

        /**
          *    Option 的get方法返回的为Option, 也就意味着res6可能取到也有可能没取到,如果res5=None 时，
          * 会出现异常情况:  NoSuchElementException: None.get
          */
        res5=None
        val res8 = res5.isEmpty
        print(s"res8=====> ${res8}
")
//        val res9 = res5.get
//        print(s"res9=====> ${res9}
")
    }
}



/*
以上代码执行结果如下 :
map=====> Map(尹正杰 -> 18)
changeableMap=====> Map()
changeableMap=====> Map(yinzhengjie -> 18, Hadoop -> 2, 尹正杰 -> 26, Scala -> 2, JDK -> 8)
changeableMap=====> Map(yinzhengjie -> 18, Hadoop -> 2, 尹正杰 -> 26, JDK -> 8)
changeableMap=====> Map(yinzhengjie -> 18, 尹正杰 -> 26, JDK -> 8)
res1=====> 18
res2=====> 26
res3=====> 100
res4=====> 8
res5=====> Some((yinzhengjie,python,shell,vbs))
res6=====> (yinzhengjie,python,shell,vbs)
res7=====> false
res8=====> true
 */

四.元组（Tuple）

　　Scala 元组将固定数量的项目组合在一起，以便它们可以作为一个整体传递。与数组或列表不同，元组可以容纳不同类型的对象，但它们也是不可变的。元组是类型Tuple1，Tuple2，Tuple3 等等。目前在Scala 中只能有22 个上限，如果您需要更多个元素，那么可以使用集合而不是元组。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar

object TupleDemo {

    def main(args: Array[String]): Unit = {

        //定义一个元组
        val tuple = ("yinzhengjie",2018,true,Unit)

        //访问元素中的第一个元素，根据下标访问即可，默认是从1开始计数的
        val res1 = tuple._1
        print(s"res1=====> ${res1}
")

        /**
          * productIterator:
          *     可以将一个元组转换成一个数组
          * foreach:
          *     可以遍历迭代器中的每一个元素
          */
        tuple.productIterator.foreach(x => print(x + "	"))
        println()

        /**
          * 对偶元组:
          *     顾名思义。对偶元组指的是元组中元素的个数只有2个。
          */
        val tuple1 = ("yinzhengjie",2018)
        print(s"tuple1=====> ${tuple1}
")
        val res2 = tuple1.swap
        print(s"res2=====> ${res2}
")

    }

}



/*
以上代码执行结果如下:
res1=====> yinzhengjie
yinzhengjie    2018    true    object scala.Unit    
tuple1=====> (yinzhengjie,2018)
res2=====> (2018,yinzhengjie)
 */

五.Scala中的并行化集合

　　Scala结合Hadoop中的MapReduce思想，可以模拟分布式计算，使用par方法即可。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function

object MyListPar {
    def main(args: Array[String]): Unit = {
        var list = (1 to 10).toList
        println(list)

        /**
          * 在没有开启并行化时,我们会看到执行map任务时都在主线程执行
          */
        list.map(e => {
            //获取当前线程名称
            val name = Thread.currentThread().getName()
            println(name + " : " + e)
            //将listl列表中的数据乘以2
            println(e * 2)
        })

        println("
==============我是分割线=============
")

        /**
          * Scala结合Hadoop中的MapReduce思想，可以模拟分布式计算，使用par方法即可。
          *     使用par方法将list对象转成并行化集合，我们会看到执行map任务时开启了多个线程执行，缺点是执行顺序不一致啦！
          */
        list.par.map(e => {
            //获取当前线程名称
            val name = Thread.currentThread().getName()
            println(name + " : " + e)
            //将listl列表中的数据乘以2
            println(e * 2)
        })
    }
}



/*
以上代码执行结果如下 :
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
main : 1
2
main : 2
4
main : 3
6
main : 4
8
main : 5
10
main : 6
12
main : 7
14
main : 8
16
main : 9
18
main : 10
20

==============我是分割线=============

scala-execution-context-global-11 : 1
2
scala-execution-context-global-11 : 2
4
scala-execution-context-global-14 : 8
scala-execution-context-global-12 : 6
12
scala-execution-context-global-12 : 7
14
scala-execution-context-global-13 : 3
6
scala-execution-context-global-13 : 4
8
scala-execution-context-global-13 : 5
10
16
scala-execution-context-global-14 : 9
18
scala-execution-context-global-14 : 10
20

 */

六.小试牛刀

1>.对数组的字符串进行单词统计

 　　不知道你是否感觉到了，大数据统计不管是MapReduce还是Spark他们最终的计算都类似于之中WordCount，因此想要学习大数据，练习写WordCount是你必经之路，我们可以对一个数组的数据进行单词统计，以及排序等操作，只需要一行就可以搞定，而且速度那是相当的快呀！下面我介绍4中单词统计的方式，其实万变不离其宗。具体代码如下:

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar

object WordCount {

    def main(args: Array[String]): Unit = {
        //定义需要统计的单词
        val words = Array("hello Scala","hello Spark","hello Java","Java Scala")

        // 实现方式一
        val res1 = words .flatMap(_.split(" "))                // 对数组中的每个元素进行切分, 并进行扁平化操作
            .map((_, 1))                                       // 将数组的每个元素转换成一个对偶元组, 元组的第二个元素为1
            .groupBy(_._1)                                     // 对集合中的所有元素进行按单词分组, 相同单词的元组分到一组
            .mapValues(_.length)                               // 对每个key 的value 集合进行求长度操作
            .toList                                            // 将map 转换成List
            .sortBy(t => - t._2)                               // 实现降序排列，默认是升序排列

        // 实现方式二
        val res2 = words .flatMap(_.split(" ")).groupBy(x => x).map(t => (t._1,t._2.length)).toList.sortBy(t => t._2)

        //实现方式三
        val res3 = words.flatMap(_.split(" ")).map(x =>(x,1)).groupBy(x=>x._1).mapValues(t=>t.foldLeft(0)(_+_._2))

        //实现方式四
        val res4 = words.flatMap(_.split(" ")).map(x =>(x,1)).groupBy(x =>x._1).mapValues(t=>t.foldRight(0)(_._2 + _)).toList.sortBy(t => - t._2)

        print(s"res1=====> ${res1}
")
        print(s"res2=====> ${res2}
")
        print(s"res3=====> ${res3}
")
        print(s"res4=====> ${res4}
")

    }
}



/*
以上代码执行结果如下:
res1=====> List((hello,3), (Scala,2), (Java,2), (Spark,1))
res2=====> List((Spark,1), (Scala,2), (Java,2), (hello,3))
res3=====> Map(Spark -> 1, Scala -> 2, Java -> 2, hello -> 3)
res4=====> List((hello,3), (Scala,2), (Java,2), (Spark,1))
 */

2>.