第四课、Scala集合

1.Scala中的List

     1）Scala中的List和Java中的不同，一旦创建了就不可改变

     2）List中元素的类型只能是一种

     3）List定义      val list=List(1,2,3)    或者    val  list=1::2::3

     4）List中常用方法

             :::    将两个list叠加,返回新的列表

                    list（1,2）: : :list(3,4)      ==>list(1,2,3,4)

             ::    将新元素组合到现有列表的最前端，然后返回新的列表

                     val list=List(1,2)

                     val  list1=3::list

                     print(list1)     ==>（3,1,2）

             Nil    空列表的简写

                     val list=List（1,2）

                     val list1=list::Nil

                     print(list1)    ==>(1,2)

            list(i)    返回list列表中索引位i的元素

                     val list=List（1,2,3,4）

                     print(list(2))    ==>3

            list..count(s => s.length == 4)       计算长度为4 的String的元素个数

                     val list=List("spark","hadoop","hive","hbase","sparksql")

                     val  i=list.count(s => s.length == 4)
                     print(i)     ==>1

            list.exists(s => s == "spark")       判断list是否含有'spark",返回true或false

                      val list=List("spark","hadoop","hive","hbase","sparksql")
                      print(list.exists(s => s == "spark"))     ==>true

            list.forall(s => s.endsWith("k"))      判断list中的所有元素是否都以"k"结尾，返回true或false

                      val list=List("spark","hadoop","hive","hbase","sparksql")

                     print(list.forall(s => s.endsWith("k")) )     ==> false

           list.foreach(s => print(s))    等价于    list.foreach(print)       输出list列表中的每个字符串

                      val list=List("spark","hadoop","hive","hbase","sparksql")

                       list.foreach(s => print(s))     ==>sparkhadoophivehbasesparksql

           list.head      返回list列表中第一个元素

                       val list=List("spark","hadoop","hive","hbase","sparksql")

                       print(list.head)      ==>spark

           list.last         返回list列表中最后一个元素

                       val list=List("spark","hadoop","hive","hbase","sparksql")

                       print(list.last)      ==>sparksql

           list.tail         返回list列表中除第一个元素后，所形成的新的列表

                        val list=List("spark","hadoop","hive","hbase","sparksql")

                        print(list.tail)      ==>List(hadoop, hive, hbase, sparksql)

           list.init         返回列表中除最后一个元素后，所形成的新的列表

                        val list=List("spark","hadoop","hive","hbase","sparksql")

                         print(list.init)    ==>List(spark, hadoop, hive, hbase)

           list.isEmpty        判断列表是否为空，返回true或false

                        val list=List("spark","hadoop","hive","hbase","sparksql")

                        print(list.isEmpty )      ==>false

           list.length           返回列表中元素的个数

                         val list=List("spark","hadoop","hive","hbase","sparksql")

                          print(list.length)       ==>5

           list.map(s => s + "y")           返回列表中每个元素都加了"y"之后返回的新列表

                         val list=List("spark","hadoop","hive","hbase","sparksql")

                          print(list.map(s => s + "y"))     ==>List(sparky, hadoopy, hivey, hbasey, sparksqly)

           list.mkString(", ")          返回用list元素创建的字符串

                           val list=List("spark","hadoop","hive","hbase","sparksql")

                           print(list.mkString(", "))      ==>spark, hadoop, hive, hbase, sparksql

           list.reverse          返回list列表反转后，形成的新的列表

                            val list=List("spark","hadoop","hive","hbase","sparksql")

                             print(list.reverse )       ==>List(sparksql, hbase, hive, hadoop, spark)

           list.drop(i)        返回去掉列表前i个元素后，形成的新的列表

                             val list=List("spark","hadoop","hive","hbase","sparksql")

                             print(list.drop(2))     ==>List(hive, hbase, sparksql)

           list.dropRight(i)           返回去掉列表后i个元素后，形成的新的列表

                             val list=List("spark","hadoop","hive","hbase","sparksql")

                             print(list.dropRight(2))     ==>List(spark, hadoop, hive)          

2.Scale中的Tuple

        1）和List一样，Tuple也是不可变的，但是与列表不同的是，Tuple中可以包含多种不同类型的元素

        2）Tuple元组的访问是从下标1开始的

                  val  pair=（99，“hello”）
                  print（pair._1）       ==>99
                  print（pair._2）       ==>hello

          3）Tuple的最大长度为22

          4)在企业级实际开发大数据的时候一定会反复的使用Tuple来表达数据结构，以及使用Tuple来处理业务逻辑

3.Scala中的Map

           1)默认情况下Map构造的是不可变的集合，里面的内容不可修改，一旦修改就变成新的Map，原有的Map内容保持不变

           2)Map的实例是调用工厂方法模式apply来构造Map实例，而需要主要的是Map是接口，在apply中使用了具体的实现

           3)如果想直接new出Map实例，则需要使用HashMap等具体的Map子类

           4)查询一个Map中的的值一定是采用getOrElse的语法的，一方面是在key不存的情况下不报告异常，另外还有一个神奇的作用就是提供默认值 而关于默认值的提供在实际开发中至关重要，在Spark中很多默认的配置都是通过getOrElse的方式来实现的

            5)使用SortedMap可以得到排序的Map集合

            6)LinkedHashMap可以记住插入的数据的顺序，这在实际开发中非常有用

                      Map定义：

                              val bigDatas = Map("Spark"->6, "Hadoop"->11)  //调用工厂方法模式apply来构造Map实例，而需要主要的是Map是接口，在apply中使用了具体的实现

                              print(bigDatas)  ==>Map(Spark -> 6, Hadoop -> 11)

                      Map排序：

                               val persons = scala.collection.immutable.SortedMap(("jialingege", 30),("dtspark", 1),("hadoop",11))
                               print(bigDatas)  ==>Map(dtspark -> 1, hadoop -> 11, jialingege -> 30)

                      改变Map中元素的值：
                               val programingLanguage = scala.collection.mutable.Map("Scala" -> 13, "Java"-> 23)
                               programingLanguage("Scala") = 15
                               for((name,age) <-programingLanguage) println(name + " : " + age)
                              println(programingLanguage.getOrElse("Python", "jialingege"))
    
                      定义LinkedHashMap：
                                val personsInformation = new scala.collection.mutable.LinkedHashMap[String, Int]
                                personsInformation += ("Scala" -> 13, "java"-> 23, "python" -> 10)
                                 for((name,age) <-personsInformation) println(name + " : " + age)   //按照键值对输出LinkedHashMap中的值
                                 for(key <- personsInformation.keySet) println(key)     //输出key

                                 for(value <- personsInformation.values) println(value)     //输出value