Scala 集合collection

lambda-小张

已于 2022-05-20 17:06:10 修改

阅读量414

点赞数 1

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

于 2022-05-20 16:34:05 首次发布

本文链接：https://blog.csdn.net/m0_55834564/article/details/124885385

版权

scala 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

1.默认情况下Scala 使用的是不可变集合，

2.输出 Map 的 keys 和 values

Scala的集合最大的包是collection，分为可变mutable的和不可变的immutable集合

可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

一、List列表

List的特征是其元素以线性方式存储，集合中可以存放重复对象。

例如：
// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")

// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)

// 空列表
val empty: List[Nothing] = List()

// 二维列表
val dim: List[List[Int]] =
   List(
      List(1, 0, 0),
      List(0, 1, 0),
      List(0, 0, 1)
   )

构造列表的两个基本单位是 Nil 和 ::

Nil 也可以表示为一个空列表。

例如：
// 字符串列表
val site = "Runoob" :: ("Google" :: ("Baidu" :: Nil))

// 整型列表
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))

// 空列表
val empty = Nil

// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
          (0 :: (1 :: (0 :: Nil))) ::
          (0 :: (0 :: (1 :: Nil))) :: Nil

1. 列表基本操作

Scala列表有三个基本操作：

head 返回列表第一个元素
tail 返回一个列表，包含除了第一元素之外的其他元素
isEmpty 在列表为空时返回true

val list = "z":: ("list" ::("wangwu" :: Nil))
    val list2 = "c" ::("list" ::("wangwu" :: Nil))
    val list3 = list:::list2

    println(list.head)
    println(list.tail)
    println(list.isEmpty)

运行结果：

z
List(list, wangwu)
false

2.连接列表

你可以使用 ::: 运算符或 List.:::() 方法或 List.concat() 方法来连接两个或多个列表。实例如下:

/*连接列表*/
    val r = "i" :: ("a" :: Nil)
    val a = "1" ::("20"::("u" :: Nil))
    //使用 ::: 运算符
    //val z = r:::a


    //调用方法
    //val z = r.:::(a)

    //使用concat方法
    val z= List.concat(r,a)
    println(z)

3.List的Api

package com.lenovo.scala2

object ListApi {
  def main(args: Array[String]): Unit = {
    /**1.集合的长度*/
    val list = List(1,5,3,8,9,2,3,4,6,8,1)
    val list2 = List(1,3,3,8,9,4,6,8,2)
    println(list.length)
    println(list.size)

    /**2.集合是否为空*/
    println(list.isEmpty)

    /**3.判断集合是否包含某个元素*/
    println(list.contains(9))

    /**4.取集合的前几个元素/ 后几个元素*/
    println(list.take(2))
    println(list.takeRight(2))

    /**5.从集合中查找满足条件的第一个元素*/
    def fung(i:Int):Boolean={i%2==0}
    println(list.find(fung))
    println(list.find(_%2 ==0))

    /**6.丢弃前几个或者丢弃后几个元素*/
    println(list.drop(2))
    println(list.dropRight(2))

    /**7.反转集合*/
    println(list.reverse)

    /**8.去重*/
    println(list.distinct)
    println(list.toSet)

    /**9. 集合头(集合的第一个元素)*/
    println(list.head)

    /**10.集合尾(第一个元素后面的所有的元素)*/
    println(list.tail)

    /**11. 集合的最后一个元素*/
    println(list.last)

    /**12. 集合初始化*/
    println(list.init)

    /**13. 集合的并集*/
    println(list.union(list2))

    /**14. 集合的交集*/
    println(list.intersect(list2))

    /**15. 集合的差集*/
    println(list.diff(list2))
  }
}

运行结果：

11
11
false
true
List(1, 5)
List(8, 1)
Some(8)
Some(8)
List(3, 8, 9, 2, 3, 4, 6, 8, 1)
List(1, 5, 3, 8, 9, 2, 3, 4, 6)
List(1, 8, 6, 4, 3, 2, 9, 8, 3, 5, 1)
List(1, 5, 3, 8, 9, 2, 4, 6)
HashSet(5, 1, 6, 9, 2, 3, 8, 4)
1
List(5, 3, 8, 9, 2, 3, 4, 6, 8, 1)
1
List(1, 5, 3, 8, 9, 2, 3, 4, 6, 8)
List(1, 5, 3, 8, 9, 2, 3, 4, 6, 8, 1, 1, 3, 3, 8, 9, 4, 6, 8, 2)
List(1, 3, 8, 9, 2, 3, 4, 6, 8)
List(5, 1)

进程已结束，退出代码为 0

4.添加元素(产生新的集合)

val list1 = List(1, 2, 3, "abc")
val list5 = 4 :: 5 :: 6 :: list1 :: Nil //打印：List(4, 5, 6, List(2, 3, 4))
val list7 = 4 :: 5 :: 6 :: list1 ::: Nil //打印：List(4, 5, 6, 2, 3, 4)
val list5 = 4 :: 5 :: 6 :: list1 :: 9 // 错误：最右边9不是集合无法添加元素

5.列表listBuffer(可变)

ListBuffer是可变的list集合，可以添加，删除元素,ListBuffer属于序列

定义：

val lst0 = ListBuffer[Int](1, 2, 3)
val lst1 = new ListBuffer[Int]

添加元素

//向原集合中添加元素
lst1 += 4
lst1.append(5，6) //一次可添加多个元素

//生成新的集合
lst0 ++= lst1
val lst2 = lst0 ++ lst1
val lst3 = lst0 :+ 5

6.集合的函数

6.1 foreach遍历

采用 foreach 来遍历集合, 可以让代码看起来更简洁, 更优雅.

/***
 * foreach遍历
 * 省略参数列表，省略输出变量用下划线代替
 */
object ForeachTest {
  def main(args: Array[String]): Unit = {
    val num = List(1,3,5,7,9)
    //第一步
    num.foreach((x:Int) => print(x))
    //第二步
    num.foreach(x => print(x))
    //第三步
    num.foreach(print(_))
  }
}

简化函数定义

方式一：通过类型推断来简化函数定义。
解释：因为使用foreach来迭代列表，而列表中的每个元素类型是确定的，所以我们通过类型推断让Scala程序自动推断出集合中的每个元素参数的类型，即：在我们创建函数时，可以省略参数列表的类型。
方式二：通过下划线来简化函数定义。
解释：当函数参数，只在函数体中出现一次，而函数体没有嵌套使用时，可以使用下划线来简化函数定义.

6.2映射(map)

集合的映射操作是指将一种数据类型转换为另外一种数据类型的过程，它是在进行数据计算的时候，甚至在编写 Spark/Flink 程序时用的最多的操作. 例如：把 List[Int] 转换成 List[String]

代码示例:

创建一个列表，包含元素1,2,3,4
将上述的数字转换成对应个数的 * , 即: 1变为*, 2变为**, 以此类推.

/***
 * map映射
 * 实现数字转字符,省略参数列表，省略输出变量用下划线代替
 */
object MapTest{
  def main(args: Array[String]): Unit = {
    val num = List(1,3,5,7,9)
    //第一步
    val num2 = num.map((x:Int)=> "*" * x)
    //第二步
//    val num2 = num.map("*" * _)
    //第三步
    println(num.map("*" * _))
  }
}

6.3扁平化映射（flatMap）

扁平化映射可以理解为先 map，然后再 flatten

1.map是将列表中的元素转换成一个List
2.flatten再将整个列表进行扁平化
示例:有一个包含了若干个文本行的列表：“hadoop hive spark flink flume”, “kudu hbase sqoop storm”
获取到文本行中的每一个单词，并将每一个单词都放到列表中.

/***
 *1.map是将列表中的元素转换成一个List
2.flatten再将整个列表进行扁平化
 3.flatMap扁平化映射
 */
object FlattenTest{
  def main(args: Array[String]): Unit = {
    val num = List("hadoop scala java","linux python java","hive hbase hadoop")
    //第一步
//    val result = num.map(x => x.split(" ")).flatten
    //第二步
//    val result = num.map(_.split(" ")).flatten
    //第三步
//    println(num.map(_.split(" ")).flatten)
    //第四步
    val result = num.flatMap(_.split(" "))
    println(result)
  }
}

6.4过滤（filter）

过滤指的是：过滤出（刷选出）符合一定条件的元素

/***
 * filter过滤
 * 请过滤出所有的偶数
 */
object FilterTest{
  def main(args: Array[String]): Unit = {
    val num = List(1,3,6,9,2,4,6,8)
    //第一步
//    val num2 = num.filter(x => x % 3== 0)
    //第二步
    val num2 = num.filter(_ % 3== 0)//被三整除的数
    println(num2)
  }
}

6.5排序

/**
 * sort排序
 * sorted	默认排序，元素第一个排序,升序；降序配合反转函数reverse使用
 * sortWith自定义排序
 * sortBy字段排序
 *
 */
object SortTest{
  def main(args: Array[String]): Unit = {
    val num = List("1 java","5 hadoop","4 linux","2 scala")
    println(num.sorted)//升序
    println(num.sorted.reverse)//降序
    val num2 = num.sortWith((x,y) => x>y)//降序
    println(num2)
    val num3 = num.sortBy(x =>x.split(" ")(1))//字段排序
    println(num3)

  }
}

6.6分组（groupBy）

分组指的是将数据按照指定条件进行分组 , 从而方便我们对数据进行统计分析.

/**
 *groupBy配合元组使用
 */
object GroupBy{
  def main(args: Array[String]): Unit = {
    val num = List("张三"->"女","李四"->"男","王五"->"女")
    println(num.groupBy(x => x._2))
    println(num.groupBy(_._2))//简写
    val num2 = num.groupBy(x => x._2)
    println(num2.map(x => x._1 -> x._2.size))//性别人数
  }
}

6.7聚合操作reduce

所谓的聚合操作指的是将一个列表中的数据合并为一个 . 这种操作经常用来统计分析中. 常用的聚合操作主要有两个:

reduce: 用来对集合元素进行聚合计算

/**
 *聚合操作reduce
 */
object reduceTest{
  def main(args: Array[String]): Unit = {
    val num = List(1,3,6,9,2,4,6,8)
    println(num.reduce((x,y) => x+y))
    print(num.reduce(_+_))//求和
  }
}

二、Set集合

Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。

Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。

Scala 集合分为可变的和不可变的集合。

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。

1.默认情况下Scala 使用的是不可变集合，

如使用可变集合，需要引用 scala.collection.mutable.Set 包。没有重复数据，无顺序.

2.创建:

val set = Set(1, 2, 3) //不可变
import scala.collection.mutable.Set
val mutableSet = Set(1, 2, 3) //可变

3.可变集合元素添加、删除

//添加 如果添加的对象已经存在，则不会重复添加，也不会报错
mutableSet.add(4) //方式1
mutableSet += 6  //方式2
mutableSet.+=(5) //方式3

//删除
val set02 = mutable.Set(1,2,4,"abc")
set02 -= 2 // 操作符形式
set02.-=(4) // ok
set02.remove("abc") // 方法的形式，scala的Set可以直接删除值

4.遍历

val set02 = mutable.Set(1, 2, 4, "abc")
for (x <- set02) {println(x)}

三、Map映射

Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。

Map(映射)是一种可迭代的键值对（key/value）结构。

所有的值都可以通过键来获取。

Map 中的键都是唯一的。

Map 也叫哈希表（Hash tables）。

Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。

默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类

在 Scala 中你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()

// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

1.Map 基本操作

Scala Map 有三个基本操作：

方法	描述
keys	返回 Map 所有的键(key)
values	返回 Map 所有的值(value)
isEmpty	在 Map 为空时返回true

object MapDemo4 {
  def main(args: Array[String]): Unit = {
    val map1 =scala.collection.mutable.Map("张三" -> 20,"李四" ->18,"王五" ->21,"77" ->32)
    val map2 =scala.collection.mutable.Map("张三" -> 20,"李四" ->18,"王五" ->21)
    println(map2("李四"))
    for(k <- map2.keys)print(k+" ")
    for(v <- map2.values)print(v+" ")
    map2 += ("赵六" -> 23)
    println(map2)
    println(map2.getOrElse("赵六1","-1"))
    for((k,v) <- map2)println(k+v)
    map2 ++= map1
    print(map2)
  }
}

运行结果：

18
李四 张三 王五 18 20 21 HashMap(李四 -> 18, 赵六 -> 23, 张三 -> 20, 王五 -> 21)
-1
李四18
赵六23
张三20
王五21
HashMap(77 -> 32, 李四 -> 18, 张三 -> 20, 王五 -> 21, 赵六 -> 23)

2.输出 Map 的 keys 和 values

以下通过 foreach 循环输出 Map 中的 keys 和 values：

val map1 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
for ((k, v) <- map1) println(k + " is mapped to " + v)
for (v <- map1.keys) println(v) //打印key值
for (v <- map1.values) println(v) // 打印value值
for(v <- map1) println(v)

四、Tuple元组

元组是不同类型的值的集合

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。

scala数组和元组的区别？
数组的数据类型一致
元组的不同数据类型一致，只能22个元素

创建元组两种方式
* 第一种，根据下标，22位 val/var 元组 = (元素1, 元素2, 元素3....)
* 第二种，->两种情况，为1时，除最后值外都输出，为2时输出最后值，两位
* val/var 元组 = 元素1->元素2

object TupleTest {
  def main(args: Array[String]): Unit = {
    /**
     * 创建元组两种方式
     * 第一种，根据下标
     * 第二种，->两种情况，为1时，除最后值外都输出，为2时输出最后值
     */
    var arr = (1,"王五",9.9)
    println(arr._2)
    var arr2 = 1-> "王五" ->9.9->0.99
    print(arr2._1)

  }

}

1.迭代元组

你可以使用 Tuple.productIterator() 方法来迭代输出元组的所有元素：

object Test {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
     
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }
}

运行结果：

Value = 4
Value = 3
Value = 2
Value = 1

2.元组转为字符串

你可以使用 Tuple.toString() 方法将元组的所有元素组合成一个字符串，实例如下：

object Test {
   def main(args: Array[String]) {
      val t = new Tuple3(1, "hello", Console)
     
      println("连接后的字符串为: " + t.toString() )
   }
}

运行结果：

连接后的字符串为: (1,hello,scala.Console$@4dd8dc3)

3.元素交换

你可以使用 Tuple.swap 方法来交换元组的元素。如下实例：

object Test {
   def main(args: Array[String]) {
      val t = new Tuple2("111", "22")
     
      println("交换后的元组: " + t.swap )
   }
}

运行结果：

五、队列Queue

1.其输入和输出要遵循先入先出的原则，

在scala中, 有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue , 一般来说，我们在开发中通常使用可变集合中的队列

2.定义：

val q1 = new Queue[Int]

3.添加元素：

q1 += 20 
q1 ++= List(2,4,6) 
q1.enqueue(20,60) //添加元素
q1.dequeue() //返回并删除一个元素

4.方法：

println(q1.head) //返回队列的第一个元素，对队列本身没有任何影响
println(q1.last) //返回队列最后一个元素，对队列本身没有任何影响
println(q1.tail) //返回队列的尾部，即：返回除了第一个以外剩余的元素
println(q1.tail.tail) //可以级联使用，这个在递归时使用较多

lambda-小张

关注

1
点赞
踩
3

收藏

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

目录一、List列表1. 列表基本操作2.连接列表3.List的Api二、Set集合三、Map映射1.Map 基本操作2.输出 Map 的 keys 和 values四、Tuple元组1.迭代元组2.元组转为字符串3.元素交换Scala的集合最大的包是collection，分为可变mutable的和不可变的immutable集合可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，永远不会改
复制链接

扫一扫