学习spark--(3)--scala(3)

1.元组

1)概念
            元祖是scala中一个非常有用的容器对象,用于存放不同类型的数据元素,当然他是不可变的
            关键字:不同类型  长度不可变

2)元组的创建

demo:
val tuple=(1,"abc",false)
val tuple1 = new Tuple2(1,2)

3)元组的操作
           元组是通过下划线+下标索引进行访问的,并且是从1开始

val tuple = (1, 2, 3, 4)
// println()
val a = tuple._1 + tuple._2 + tuple._3 + tuple._4
println(s"元祖中所有元祖的和是: $a")

2.数组

1)概念
            数组是一个存放相同类型元素的集合
            分为可变数组和定长数组

2)数组创建方式
            --1--.定长数组的创建

val array = new Array[String](3)
val arr02 =  Array("a", "b", "c")

--2--.变长数组创建

val arrayBuffer = new ArrayBuffer[String]()
val arrayBuffer01 = ArrayBuffer()

3)数组的操作使用
            --1--.定长数组的赋值和访问   注意:数据的访问时通过下标索引,是从0开始的

array(0) = "a"
array(1) = "b"
array(2) = "c"
println(array(0))
println(array(1))
println(array(2))

 --2--.变长数据的赋值和访问

arrayBuffer.append(1)
arrayBuffer.append(2)
arrayBuffer.append(3)
println(arrayBuffer(0))
println(arrayBuffer(1))
println(arrayBuffer(2))

 --3--定长数组遍历操作    

for (item <- array) {
   println(item)
}

            --4--变长数组遍历操作    

for (item<-arrayBuffer){
     println(item)
}

            --5--数组的常用函数

//元素求和
println(arrayBuffer.sum)
//最大值
println(arrayBuffer.max)
//最小值
println(arrayBuffer.min)
//排序(默认是升序)
println(arrayBuffer.sorted)
//降序
println(arrayBuffer.sortWith(_>_))

3.集合 

1)展示一张关系图

2).集合的分类
                List(列表) :有序 可重复
                Set(集合)  :无序 不可重复
                Map(映射)  :键值对 (key  不可重复)
                tuple(元祖):是不同类型值的集合
                Vector(容器):是一个容器,可以保存不同数据对象

3)List(列表) :有序 可重复
                列表类似于元祖,他们所有的元素的类型都是一样
                --1--list的定义
                //为什么不需要new:不适用new 关键字创建对象 而是通过object   apply :类似于构造器
                   //1.字符串列表
                     val strings = List("abc","d","e")
                    //2.整数列表
                    val ints = List(1,2,3,4)
                    //3.二维列表
                    val intses = List(List(1,2,3,4),List(1,2,3,4))
                --2--List的操作
                    for循环遍历打印列表中的元素
                    //循环遍历集合
                     for(i<- 0 until strings.length ){
                         println( strings(i))
                        }
                    //
                           for (item <- list) {
                          println(item)
                        }
                    list.head:返回列表第一个元素
                    list.tail:返回一个列表  处理第一元素以外的其他元素
                    list.isEmpty:列表如果为空的时候返回
                    list.last  :获取最后一个元素

//合并两个列表(两种方式)
// val strss=strings:::strings01
val strss = List.concat(strings, strings01)
// 适应.fill创建一个重复次数为n次的列表
val site = List.fill(3)("gao") 
println( "site : " + site  )
println(site(0).getClass.getName)

--3--.scala中List 和listBuffer的区别

//可变的
    val buffer = ListBuffer[String]()
//向可变的buffer中添加元素,并打印查看
    buffer.append("a")
    buffer.append("b")
    buffer.append("c")
    println(buffer)
//元素移除
    buffer.remove(1)

4)Set(集合)  :没有重复的对象集合,所有元素都是唯一
                            特点:无序 ,不重复
                            --1--.Set的定义
                                不能变集合定义
                                val set=Set(1,2,3)
                                可变集合的定义
                                 val set = collection.mutable.Set[String]()
                            --2--.Set的操作
                                增加元素
                                a.赋值
                                添加元素
                                set.add("a")
                                set.add("b")
                                set.add("c")
                                set+="d"
                                减少元素
                                set.drop(1)
                                set-="b"
                                b.打印
                                set.foreach(item => {
                                  println(item)
                                })
            5)Map(映射) 
                    参考一下:https://www.runoob.com/scala/scala-maps.html
                    Map(映射)是一种可迭代的键值对（key/value）结构
                    key不可重复
                    分类:可变的不可变
                            --1--.Map的定义
                                //不可变
                                var A:Map[Type,Type] = Map()
                                val map = Map("key01" -> "value01", "key02" -> "value02")
                                //可变的 
                                val map = collection.mutable.Map[String,String]()
                                //添加
                                map.put("", "")
                                //去除
                                map.remove("k1")
                                //获取所有的keys
                                println(map.keys)
                                //获取所有的value
                                println(map.values)
                                //判断是否为空
                                println(map.isEmpty)

6).Vector 是Scala标准包的一部分，我们可以直接使用，不需要导包
               --1--创建 Vector
              无需使用new关键字就可以创建 Vector 容器实例。创建实例的同时我们可以放入元素
              

//创建Vector对象
               val vec = Vector(1,2,3)
               //Vector通过索引下标访问元素,Vector 的元素索引是从0开始的， 使用 圆括号将索引号括起来可以获得指定元素
               println(vec(0))
               //Vector的遍历
                 for (item <- vec) {
                  println(item)
                }
                //倒转 Vector
                  val vec = Vector(1, 2, 3)
                  println(vec)
                  println(vec.reverse)
                //Vector的排序
                val vec = Vector(1, 2, 3,1,4,7,1,3,9)
                println(vec)
                println(vec.sorted)
                //返回第一元素
                vec.head  
                //返回除了第一个元素的所有元素
                vec.tail