Scala 集合

最新推荐文章于 2022-06-05 19:24:08 发布

落花雨时

最新推荐文章于 2022-06-05 19:24:08 发布

阅读量188

点赞数

分类专栏： Scala 文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/mengxianglong123/article/details/121174260

版权

Scala 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

一、简介

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。
可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变，所以这里的不可变并不是变量本身的值不可变，而是变量指向的那个内存地址不可变
可变集合和不可变集合，在scala中该如何进行区分呢？我们一般可以根据集合所在包名进行区分:

scala.collection.immutable（不可变）
scala.collection.mutable（可变）

二、数组

2.1 不可变数组

基本语法

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        //（1）数组定义
        val arr01 = new Array[Int](4)
        println(arr01.length) // 4

        //（2）数组赋值
        //（2.1）修改某个元素的值
        arr01(3) = 10
        val i = 10
        arr01(i/3) = 20
        //（2.2）采用方法的形式修改数组的值
        arr01.update(0,1)

        //（3）遍历数组
        //（3.1）查看数组
        println(arr01.mkString(","))

        //（3.2）普通遍历
        for (i <- arr01) {
            println(i)
        }

        //（3.3）简化遍历
        def printx(elem:Int): Unit = {
            println(elem)
        }
        arr01.foreach(printx)
        arr01.foreach((x)=>{println(x)})
        arr01.foreach(println(_))
        arr01.foreach(println)
    }
}

基本操作

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        // 创建数组的另外一种方式
        val arr1 = Array(1,2,3,4)
        val arr2 = Array(5,6,7,8)
        // 添加数组元素，创建新数组
        val arr3: Array[Int] = arr1 :+ 5
        println( arr1 eq arr3 ) // false

        val arr4: Array[Int] = arr1 ++: arr2
        // 添加集合
        val arr5: Array[Int] = arr1 ++ arr2

        arr4.foreach(println)
        println("****************")
        arr5.foreach(println)
        println("****************")
        // 多维数组
        var myMatrix = Array.ofDim[Int](3,3)
        myMatrix.foreach(list=>list.foreach(println))
        // 合并数组
        val arr6: Array[Int] = Array.concat(arr1, arr2)
        arr6.foreach(println)

        // 创建指定范围的数组
        val arr7: Array[Int] = Array.range(0,2)
        arr7.foreach(println)

        // 创建并填充指定数量的数组
        val arr8:Array[Int] = Array.fill[Int](5)(-1)
        arr8.foreach(println)
    }
}

2.2 可变数组

基本语法

import scala.collection.mutable.ArrayBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val buffer = new ArrayBuffer[Int]
        // 增加数据
        buffer.append(1,2,3,4)
        // 修改数据
        buffer.update(0,5)
        buffer(1) = 6
        // 删除数据
        val i: Int = buffer.remove(2)
        buffer.remove(2,2)
        // 查询数据
        println(buffer(3))
        // 循环集合
        for ( i <- buffer ) {
            println(i)
        }
    }
}

基本操作

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

        val buffer3: ArrayBuffer[Int] = buffer1 += 5
        println( buffer1 eq buffer3 ) // true

        // 使用 ++ 运算符会产生新的集合数组
        val buffer4: ArrayBuffer[Int] = buffer1 ++ buffer2
        // 使用 ++= 运算符会更新之前的集合，不会产生新的数组
        val buffer5: ArrayBuffer[Int] = buffer1 ++= buffer2
        println( buffer1 eq buffer4 ) // false
        println( buffer1 eq buffer5 ) // true
    }
}

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
    }
}

三、Seq集合

3.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)
    }
}

基本操作

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

        // Seq集合
        val list1 = List(1,2,3,4)
        // 空集合
        val list2: List[Nothing] = List()
        val nil  = Nil
        println(list2 eq nil)

        // 创建集合
        val list3: List[Int]  = 1::2::3::Nil
        val list4: List[Int] = list1 ::: Nil

        // 连接集合
        val list5: List[Int] = List.concat(list3, list4)
        list5.foreach(println)

        // 创建一个指定重复数量的元素列表
        val list6: List[String] = List.fill[String](3)("a")
        list6.foreach(println)
    }
}

3.2 可变List

基本语法

import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        // 可变集合
        val buffer = new ListBuffer[Int]()
        // 增加数据
        buffer.append(1,2,3,4)
        // 修改数据
        buffer.update(1,3)
        // 删除数据
        buffer.remove(2)
        buffer.remove(2,2)
        // 获取数据
        println(buffer(1))
        // 遍历集合
        buffer.foreach(println)
    }
}

基本操作

import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        
        // 可变集合
        val buffer1 = ListBuffer(1,2,3,4)
        val buffer2 = ListBuffer(5,6,7,8)

        // 增加数据
        val buffer3: ListBuffer[Int] = buffer1 :+ 5
        val buffer4: ListBuffer[Int] = buffer1 += 5
        val buffer5: ListBuffer[Int] = buffer1 ++ buffer2
        val buffer6: ListBuffer[Int] = buffer1 ++= buffer2

        println( buffer5 eq buffer1 )
        println( buffer6 eq buffer1 )

        val buffer7: ListBuffer[Int] = buffer1 - 2
        val buffer8: ListBuffer[Int] = buffer1 -= 2
        println( buffer7 eq buffer1 )
        println( buffer8 eq buffer1 )
    }
}

3.3 可变集合和不可变集合转换

import scala.collection.mutable
import scala.collection.mutable.ListBuffer
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val buffer = ListBuffer(1,2,3,4)
        val list = List(5,6,7,8)
 
        // 可变集合转变为不可变集合
        val list1: List[Int] = buffer.toList
        // 不可变集合转变为可变集合
        val buffer1: mutable.Buffer[Int] = list.toBuffer
    }
}

四、Set集合

4.1 不可变Set

基本语法

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

        val set1 = Set(1,2,3,4)
        val set2 = Set(5,6,7,8)

        // 增加数据
        val set3: Set[Int] = set1 + 5 + 6
        val set4: Set[Int] = set1.+(6,7,8)
        println( set1 eq set3 ) // false
        println( set1 eq set4 ) // false
        set4.foreach(println)
        // 删除数据
        val set5: Set[Int] = set1 - 2 - 3
        set5.foreach(println)

        val set6: Set[Int] = set1 ++ set2
        set6.foreach(println)
        println("********")
        val set7: Set[Int] = set2 ++: set1
        set7.foreach(println)
        println(set6 eq set7)
    }
}

基本操作

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

        val set1 = Set(1,2,3,4)
        val set2 = Set(5,6,7,8)

        // 增加数据
        val set3: Set[Int] = set1 + 5 + 6
        val set4: Set[Int] = set1.+(6,7,8)
        println( set1 eq set3 ) // false
        println( set1 eq set4 ) // false
        set4.foreach(println)
        // 删除数据
        val set5: Set[Int] = set1 - 2 - 3
        set5.foreach(println)

        val set6: Set[Int] = set1 ++ set2
        set6.foreach(println)
        println("********")
        val set7: Set[Int] = set2 ++: set1
        set7.foreach(println)
        println(set6 eq set7)
    }
}

4.2 可变Set

基本语法

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = mutable.Set(1,2,3,4)
        val set2 = mutable.Set(5,6,7,8)

        // 增加数据
        set1.add(5)
        // 添加数据
        set1.update(6,true)
        println(set1.mkString(","))
        // 删除数据
        set1.update(3,false)
        println(set1.mkString(","))

        // 删除数据
        set1.remove(2)
        println(set1.mkString(","))

        // 遍历数据
        set1.foreach(println)
    }
}

基本操作

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val set1 = mutable.Set(1,2,3,4)
        val set2 = mutable.Set(4,5,6,7)

        // 交集
        val set3: mutable.Set[Int] = set1 & set2
        println(set3.mkString(","))
        // 差集
        val set4: mutable.Set[Int] = set1 &~ set2
        println(set4.mkString(","))
    }
}

五、Map集合

Map(映射)是一种可迭代的键值对（key/value）结构。所有的值都可以通过键来获取。Map 中的键都是唯一的。

5.1 不可变Map

基本语法

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

        val map1 = Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        // 添加数据
        val map3 = map1 + ("d" -> 4)
        println(map1 eq map3) // false

        // 删除数据
        val map4 = map3 - "d"
        println(map4.mkString(","))

        val map5: Map[String, Int] = map1 ++ map2
        println(map5 eq map1)
        println(map5.mkString(","))

        val map6: Map[String, Int] = map1 ++: map2
        println(map6 eq map1)
        println(map6.mkString(","))

        // 修改数据
        val map7: Map[String, Int] = map1.updated("b", 5)
        println(map7.mkString(","))

        // 遍历数据
        map1.foreach(println)
    }
}

基本操作

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

        val map1 = Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        // 创建空集合
        val empty: Map[String, Int] = Map.empty
        println(empty)
        // 获取指定key的值
        val i: Int = map1.apply("c")
        println(i)
        println(map1("c"))

        // 获取可能存在的key值
        val maybeInt: Option[Int] = map1.get("c")
        // 判断key值是否存在
        if ( !maybeInt.isEmpty ) {
            // 获取值
            println(maybeInt.get)
        } else {
            // 如果不存在，获取默认值
            println(maybeInt.getOrElse(0))
        }

        // 获取可能存在的key值, 如果不存在就使用默认值
        println(map1.getOrElse("c", 0))
    }
}

5.2 可变Map

基本语法

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = mutable.Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = mutable.Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        // 添加数据
        map1.put("d", 4)
        val map3: mutable.Map[String, Int] = map1 + ("e" -> 4)
        println(map1 eq map3)
        val map4: mutable.Map[String, Int] = map1 += ("e" -> 5)
        println(map1 eq map4)

        // 修改数据
        map1.update("e",8)
        map1("e") = 8

        // 删除数据
        map1.remove("e")
        val map5: mutable.Map[String, Int] = map1 - "e"
        println(map1 eq map5)
        val map6: mutable.Map[String, Int] = map1 -= "e"
        println(map1 eq map6)
        // 清除集合
        map1.clear()
    }
}

基本操作

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {

        val map1 = mutable.Map( "a" -> 1, "b" -> 2, "c" -> 3 )
        val map2 = mutable.Map( "d" -> 4, "e" -> 5, "f" -> 6 )

        val set: Set[(String, Int)] = map1.toSet
        val list: List[(String, Int)] = map1.toList
        val seq: Seq[(String, Int)] = map1.toSeq
        val array: Array[(String, Int)] = map1.toArray

        println(set.mkString(","))
        println(list.mkString(","))
        println(seq.mkString(","))
        println(array.mkString(","))

        println(map1.get("a"))
        println(map1.getOrElse("a", 0))

        println(map1.keys)
        println(map1.keySet)
        println(map1.keysIterator)
        println(map1.values)
        println(map1.valuesIterator)
    }
}

六、元组

在Scala语言中，我们可以将多个无关的数据元素封装为一个整体，这个整体我们称之为：元素组合，简称元组。有时也可将元组看成容纳元素的容器，其中最多只能容纳22个

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

        // 创建元组，使用小括号
        val tuple = (1, "zhangsan", 30)

        // 根据顺序号访问元组的数据
        println(tuple._1)
        println(tuple._2)
        println(tuple._3)
        // 迭代器
        val iterator: Iterator[Any] = tuple.productIterator

        // 根据索引访问元素
        tuple.productElement(0)
        
        // 如果元组的元素只有两个，那么我们称之为对偶元组，也称之为键值对
        val kv: (String, Int) = ("a", 1)
        val kv1: (String, Int) = "a" -> 1
        println( kv eq kv1 )
    }
}

七、队列

Scala也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方法分别为enqueue和dequeue。

import scala.collection.mutable
object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val que = new mutable.Queue[String]()
        // 添加元素
        que.enqueue("a", "b", "c")
        val que1: mutable.Queue[String] = que += "d"
        println(que eq que1)
        // 获取元素
        println(que.dequeue())
        println(que.dequeue())
        println(que.dequeue())
    }
}

八、并行

Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val result1 = (0 to 100).map{x => Thread.currentThread.getName}
        val result2 = (0 to 100).par.map{x => Thread.currentThread.getName}

        println(result1)
        println(result2)
    }
}

九、常用方法

常用方法

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)

        // 集合长度
        println("size =>" + list.size)
        println("length =>" + list.length)
        // 判断集合是否为空
        println("isEmpty =>" + list.isEmpty)
        // 集合迭代器
        println("iterator =>" + list.iterator)
        // 循环遍历集合
        list.foreach(println)
        // 将集合转换为字符串
        println("mkString =>" + list.mkString(","))
        // 判断集合中是否包含某个元素
        println("contains =>" + list.contains(2))
        // 取集合的前几个元素
        println("take =>" + list.take(2))
        // 取集合的后几个元素
        println("takeRight =>" + list.takeRight(2))
        // 查找元素
        println("find =>" + list.find(x => x % 2== 0))
        // 丢弃前几个元素
        println("drop =>" + list.drop(2))
        // 丢弃后几个元素
        println("dropRight =>" + list.dropRight(2))
        // 反转集合
        println("reverse =>" + list.reverse)
        // 去重
        println("distinct =>" + list.distinct)
    }
}

衍生集合

object ScalaCollection{
def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4)
        val list1 = List(1,2,3,4)
        val list2 = List(3,4,5,6)

        // 集合头
        println("head => " + list.head)
        // 集合尾
        println("tail => " + list.tail)
        // 集合尾迭代
        println("tails => " + list.tails)
        // 集合初始值
        println("init => " + list.init)
        // 集合初始值迭代
        println("inits => " + list.inits)
        // 集合最后元素
        println("last => " + list.last)
        // 集合并集
        println("union => " + list.union(list1))
        // 集合交集
        println("intersect => " + list.intersect(list1))
        // 集合差集
        println("diff => " + list.diff(list1))
        // 切分集合
        println("splitAt => " + list.splitAt(2))
        // 滑动（窗口）
        println("sliding => " + list.sliding(2))
        // 滚动（没有重复）
        println("sliding => " + list.sliding(2,2))
        // 拉链
        println("zip => " + list.zip(list1))
        // 数据索引拉链
        println("zipWithIndex => " + list.zipWithIndex)
    }
}

计算函数

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)
        val list1 = List(3,4,5,6)

        // 集合最小值
        println("min => " + list.min)
        // 集合最大值
        println("max => " + list.max)
        // 集合求和
        println("sum => " + list.sum)
        // 集合乘积
        println("product => " + list.product)
        // 集合简化规约
        println("reduce => " + list.reduce((x:Int,y:Int)=>{x+y}))
        println("reduce => " + list.reduce((x,y)=>{x+y}))
        println("reduce => " + list.reduce((x,y)=>x+y))
        println("reduce => " + list.reduce(_+_))
        // 集合简化规约(左)
        println("reduceLeft => " + list.reduceLeft(_+_))
        // 集合简化规约(右)
        println("reduceRight => " + list.reduceRight(_+_))
        // 集合折叠
        println("fold => " + list.fold(0)(_+_))
        // 集合折叠(左)
        println("foldLeft => " + list.foldLeft(0)(_+_))
        // 集合折叠(右)
        println("foldRight => " + list.foldRight(0)(_+_))
        // 集合扫描
        println("scan => " + list.scan(0)(_+_))
        // 集合扫描(左)
        println("scanLeft => " + list.scanLeft(0)(_+_))
        // 集合扫描(右)
        println("scanRight => " + list.scanRight(0)(_+_))
    }
}

功能函数

object ScalaCollection{
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)

        // 集合映射
        println("map => " + list.map(x=>{x*2}))
        println("map => " + list.map(x=>x*2))
        println("map => " + list.map(_*2))
        // 集合扁平化
        val list1 = List(
            List(1,2),
            List(3,4)
        )
        println("flatten =>" + list1.flatten)
        // 集合扁平映射
        println("flatMap =>" + list1.flatMap(list=>list))
        // 集合过滤数据
        println("filter =>" + list.filter(_%2 == 0))
        // 集合分组数据
        println("groupBy =>" + list.groupBy(_%2))
        // 集合排序
        println("sortBy =>" + list.sortBy(num=>num)(Ordering.Int.reverse))
        println("sortWith =>" + list.sortWith((left, right) => {left < right}))
    }
}

落花雨时

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Scala 集合

一、简介Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变，所以这里的不可变并不是变量本身的值不可变，而是变量指向的那个内存地址不可变可变集合和不可变集
复制链接

扫一扫