2.Spark学习（集合用法）

集合用法

1. 集合概述

1.1 简介

• Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。
  • Seq：是一个有先后次序的值的序列，比如数组或列表。IndexSeq允许我们通过它们的下标快速的访问任意元素。举例来说，ArrayBuffer是带下标的，但是链表不是。
  • Set：是一组没有先后次序的值。在SortedSet中，元素以某种排过序顺序被访问。
  • Map：是一组（键、值）对。SortedMap按照键的排序访问其中的实体。

1.2 可变集合

• 可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。

• scala.collection.immutable

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0LUUC6OQ-1655393424628)(assets/1648536124515.png)]

1.3 不可变集合

• 不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变，所以这里的不可变并不是变量本身的值不可变，而是变量指向的那个内存地址不可变可变集合和不可变集合，在scala中该如何进行区分呢？我们一般可以根据集合所在包名进行区分:

• scala.collection.mutable

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mJl1lurh-1655393424629)(assets/1648536092474.png)]

2. 数组用法

2.1 不可变数组

2.1.1 数组特点

• Scala默认提供的集合都是不可变。

• scala中给数组一个特定的类型：Array

• 可以根据索引访问数组的元素，中括号在scala中表示泛型，所以不能在索引操作中使用，使用小括号

2.1.2 数组定义

// String[]
// 构建Scala中的数组，其实等同于构造Java的数组
val array = new Array[String](3)
// 使用集合的伴生对象构建集合，并同时初始化
val array1 = Array(1,2,3,4)
val array2 = Array(5,6,7,8)
//val array2 = Array.apply(1,2,3,4)

2.1.3 数组访问

• 可以根据索引访问数组的元素

// 访问
// 可以根据索引访问数组的元素
//array.update(1, "abc")
// 中括号在scala中表示泛型，所以不能在索引操作中使用，使用小括号
array(1) = "abc"

2.1.4 数组遍历

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

// foreach方法是一个循环的方法，需要传递一个参数，这个从参数的类型是函数类型
//  函数类型 ： Int => U
def foreachFunction(num:Int): Unit = {
   
	println(num)
}

//array1.foreach(foreachFunction)
//array1.foreach((num:Int)=>{println(num)})
//array1.foreach((num:Int)=>println(num))
//array1.foreach((num)=>println(num))
//array1.foreach(num=>println(num))
array1.foreach(println(_))

2.1.5 运算符操作

package com.gec.demo2


object ScalaDemo {
   

  def main(args: Array[String]): Unit = {
   
    //定义不可变数组
    val array1 = Array(1,2,3,4)
    val array2 = Array(5,6,7,8)

    //调用+:方法，参数为5，将参数5添加到数组数据前面
    val ints_1: Array[Int] = array1.+:(5)
    //调用+:方法，参数为5
    val ints_2=5+:array1

    println(ints_1.mkString(","))
    println(ints_2.mkString(","))

    //调用:+方法，参数为5，将参数5添加到数组数据后面
    val ints_3 = array1.:+(5)
    val ints_4=array1:+5
    println(ints_3.mkString(","))
    println(ints_4.mkString(","))
  }
}

2.2 可变数组

2.2.1 概述

• 导入scala.collection.mutable.ArrayBuffer这个类

2.2.2 用法

package com.gec.demo

import scala.collection.mutable.ArrayBuffer

object Scala02_Collection {
   

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

    // TODO - 集合 - 数组 - 可变数组
    //val buffer = new ArrayBuffer[String]()
    val buffer = ArrayBuffer("a", "b", "c")
    println(buffer)
    // TODO 操作
    //buffer.append("a", "b", "c", "d")
    // buffer.appendAll(Array("a", "b", "c"))
    //buffer.insert(7, "f")

    //buffer.update(0, "e")
    //buffer(0) = "e"

    //buffer.remove(2)
    //buffer.remove(2,2)

    val strings: ArrayBuffer[String] = buffer - "a"

    println(buffer eq strings)
    println(buffer)
    println(strings)

  }

}

2.3 可变数组和不可变数组转换

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer
object ScalaCollection{
   
    def main(args: Array[String]): Unit = {
   
        val buffer = ArrayBuffer(1,2,3,4)
        val array = Array(4,5,6,7)

        // 将不可变数组转换为可变数组
        val buffer1: mutable.Buffer[Int] = array.toBuffer
        // 将可变数组转换为不可变数组
        val array1: Array[Int] = buffer.toArray
    }
}

3. Seq集合

3.1 不可变List

• 有序、可重复的数据

3.1.1 如何创建List集合

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

        // Seq集合
        val list = List(1,2,3,4)

        // 增加数据
        val list1: List[Int] = list :+ 1
        println(list1 eq list)
        list1.foreach(println)
        val list2: List[Int] = 1 +: list
        list2.foreach(println)
        println("*****************")
        val list3: List[Int] = list.updated(1,5)
        println(list eq list3)
        List3.foreach(println)
    }
}

3.1.2 基本操作

// 数据操作
val ints: List[Int] = list :+ 5
val ints1: List