Scala集合的增删改查操作

你的名字 2022-10-05 05:46 248阅读 0赞

**目录**

1、集合介绍

2、不可变数组

2.1、创建数组

2.2、根据索引访问元素

2.3、根据索引修改元素值

2.4、遍历数组

2.5、添加元素

3、可变数组

3.1、创建数组

3.2、打印数组

3.3、根据索引访问元素

3.4、添加元素

3.5、删除元素

4、不可变列表

4.1、创建列表

4.2、打印列表

4.3、根据索引访问元素

4.4、遍历列表

4.5、增加元素

4.6、合并列表

5、可变列表

5.1、创建列表

5.2、打印列表

5.3、根据索引访问元素

5.4、添加元素

5.6、合并列表

5.7、修改元素值

5.8、删除元素

6、不可变Set

6.1、创建Set

6.2、打印Set

6.3、添加元素

6.4、合并Set

6.5、删除元素

7、可变Set

7.1、创建Set

7.2、添加元素

7.3、打印Set

7.4、删除元素

7.5、合并Set

8、不可变Map

8.1、创建Map

8.2、打印Map

8.3、遍历Map

8.4、访问元素

9、可变Map

9.1、创建Map

9.2、添加元素

9.3、删除元素

9.4、更新元素

9.5、合并Map

10、元组

10.1、创建元组

10.2、访问元素

10.3、遍历元组

10.4、元组嵌套

--------------------

# 1、集合介绍 #

Scala的集合有三大类：序列 Seq、集Set、映射 Map，所有的集合都扩展自Iterable特质。  
对于几乎所有的集合类Scala都同时提供了可变和不可变的版本，分别位于以下两个包：

*  不可变集合：scala.collection.immutable
 *  可变集合：scala.collection.mutable

建议：在操作集合的时候，不可变用符号，可变用方法。  
集合的不可变指的是：集合对象本身的内存地址不变，集合的长度不变，但集合中的元素可以修改。

Array与String为了与Java兼容，并没有与scala中的Seq、Set和Map产生关联，而是通过隐式转换，将Array转成与Seq有关联的WrappedArray，String也是同样道理。

seq分IndexedSeq和LinearSeq，IndexedSeq通过索引来查找和定位，速度快，LinearSeq是线性的，有头和尾的概念，一般通过遍历去查找。

可变数组与不可变数组相互之间的转化用toArray方法和toBuffer方法。

# 2、不可变数组 #

## 2.1、创建数组 ##

val arr = Array[Int](10,20,30,40,50)

## 2.2、根据索引访问元素 ##

println(arr(1))

为什么可以直接用对象后面接上括号的方式访问呢？这是因为scala编译器在背后做了一些把戏。arr(1)等同于arr.apply(1)。

## 2.3、根据索引修改元素值 ##

// 等同于arr.update(0,25)
    arr(0)=15

## 2.4、遍历数组 ##

// 方式1
    for(i <- 0 until arr.length){
      println(arr(i))
    }
    
    // 方式2
    for(i <- arr.indices){
      println(arr(i))
    }
    
    // 方式3
    for (e <- arr){
      println(e)
    }
    
    // 方式4
    println(arr.mkString(","))
    
    // 方式5
    arr.foreach(println)

## 2.5、添加元素 ##

:+最好用于不可变数组，因为它会产生新数组，而不是在原数组上进行修改。  
在尾部添加元素

arr :+ 60

在头部添加元素（以冒号结尾的运算符，调用者即arr应写在右边）

90 +: arr

# 3、可变数组 #

## 3.1、创建数组 ##

// 创建一个初始化大小为10的空数组。相当于java中的ArrayList,可以指定初始化大小
    val arr = new ArrayBuffer[Int](10)
    // 创建一个空数组
    val arr = ArrayBuffer[Int]()
    // 创建一个有5个元素的数组
    val arr = ArrayBuffer[Int](10,30,50,20,80)

## 3.2、打印数组 ##

println(arr)

## 3.3、根据索引访问元素 ##

println(arr(0))

## 3.4、添加元素 ##

在尾部添加元素

arr += 10

在头部添加元素

70 +=: arr

可变集合推荐使用方法，而不是符号。下面通过方法来添加元素。

// 追加元素
    arr.append(15)
    // 头部添加元素
    arr.prepend(35)
    // 在指定索引处插入元素
    arr.insert(3,25)
    // 追加多个元素
    arr.appendAll(arr1)
    // 在头部添加多个元素
    arr.prependAll(arr1)
    // 在指定索引处插入多个元素
    arr.insertAll(2,arr1)

## 3.5、删除元素 ##

按索引删除元素

arr2.remove(0)

按元素值删除元素

arr2 -= 10

# 4、不可变列表 #

## 4.1、创建列表 ##

val list = List(1,2,3)
    val list = 1 :: 2 :: Nil

## 4.2、打印列表 ##

println(list)

## 4.3、根据索引访问元素 ##

println(list(0))

## 4.4、遍历列表 ##

list.foreach(println)

## 4.5、增加元素 ##

在头部添加元素

list.+:(10)
    // :: 更多用于创建列表
    list.::(10)

在尾部添加元素

list.:+(10)

## 4.6、合并列表 ##

list1 ::: list2
    list1 ++ list2

# 5、可变列表 #

## 5.1、创建列表 ##

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

## 5.2、打印列表 ##

println(list)

## 5.3、根据索引访问元素 ##

println(list(0))

## 5.4、添加元素 ##

// 追加元素
    list.append(1)
    // 在头部添加元素
    list.prepend(1)
    // 在指定索引处插入元素
    list.insert(1,10,20)
    // 在尾部添加元素 
    list += 10 += 20
    // 在头部添加元素 
    10 +=: 96 +=: list

## 5.6、合并列表 ##

\++不修改list1和list2，只能产生新的list3

val list3 = list1 ++ list2

修改list1

list1 ++= list2

修改list2

list1 ++=: list2

## 5.7、修改元素值 ##

// 等同于list.update(0,10)
    list(0)=10

## 5.8、删除元素 ##

根据索引删除元素

list.remove(0)

根据元素值删除元素

list -= 25

# 6、不可变Set #

## 6.1、创建Set ##

val set = Set(1,2,3)

## 6.2、打印Set ##

println(set)

## 6.3、添加元素 ##

val newSet = set.+(20) 
    val newSet = set + 20

由于Set中存放的元素是无序的，因此添加元素时没有头尾之分。

## 6.4、合并Set ##

val newSet = set1 ++ set2

## 6.5、删除元素 ##

val newSet = set - 10

# 7、可变Set #

## 7.1、创建Set ##

val set = mutable.Set(1,2,3)

## 7.2、添加元素 ##

set += 10 
    set.add(10)

## 7.3、打印Set ##

println(set)

## 7.4、删除元素 ##

set -= 10 set.remove(10)

## 7.5、合并Set ##

set1 ++= set2

# 8、不可变Map #

## 8.1、创建Map ##

val map = Map("zhangsan"->10,"list"->20)

## 8.2、打印Map ##

println(map)

## 8.3、遍历Map ##

// 方式1
    map.foreach((entry:(String,Int))=>{
      println(entry)
    })
    
    // 方式2
    map.foreach(println)
    
    // 方式3
    for(k <- map.keys){
      println(s"key=$k value=${map(k)}")
    }

对于第一种遍历方式，entry其实是个元组，其类型为(String,Int)

## 8.4、访问元素 ##

// 方式1
    println(map("zhangsan"))
    
    // 方式2
    println(map.get("zhangsan").get)
    
    // 方式3
    println((map.getOrElse("zhangsan",0)))

#    9、可变Map #

## 9.1、创建Map ##

val map = mutable.Map("zhangsan"->10,"list"->20)

## 9.2、添加元素 ##

// 方式1
    map.put("wangwu",30)
    
    // 方式2：如果只有一个对括号，那么编译器会认为为该方法传了两个参数
    map += (("zhaoliu",40))

## 9.3、删除元素 ##

// 方式1
    map.remove("lisi")
    // 方式2
    map -= "zhangsan"

## 9.4、更新元素 ##

map.update("wangwu",50)

## 9.5、合并Map ##

map1 ++= map2

# 10、元组 #

将一些无关的元素放在一起，就组成一个元组，元组很像Any类型的不可变列表，最多支持有22个元素。

## 10.1、创建元组 ##

val tuple:(String,Int,Boolean,Char) = ("hello",10,true,'c')

## 10.2、访问元素 ##

// 方式1
    println(tuple._3)
    
    // 方式2：相当于tuple._2
    println(tuple.productElement(1))

## 10.3、遍历元组 ##

for(e <- tuple.productIterator){
      println(e)
    }

## 10.4、元组嵌套 ##

val tuple1 = ("hello",10,("hello",10),'c')

# 11、案例 #

## 11.1、WordCount ##

古代都城.txt。记录了我国各朝代的都城的所在地。需要统计各所在地作为古都的次数，类似于wordcount。

山西夏县
    河南商丘
    陕西西安
    河南洛阳
    陕西咸阳
    陕西西安
    河南洛阳
    河南洛阳
    四川成都
    江苏南京
    河南洛阳
    江苏南京
    江苏南京
    江苏南京
    江苏南京
    江苏南京
    山西大同
    河南洛阳
    河北临漳
    河北临漳
    陕西西安
    陕西西安
    陕西西安
    陕西西安
    河南开封
    河南洛阳
    河南开封
    河南开封
    河南开封
    河南开封
    浙江杭州
    内蒙古
    宁夏银川
    黑龙江
    北京
    河南开封
    北京
    北京
    北京
    江苏南京

scala代码如下。

var list = new ListBuffer[(String,Int)]()
    
    Source.fromFile("F:/test/首都.txt").getLines().toList.map((_, 1)).groupBy(t => t._1).foreach((entry:(String,List[(String, Int)]))=>{
      list.append(entry._2.reduce((e1, e2) => (e1._1, e1._2 + e2._2)))
    })
    // 按从大到小排序
    list = list.sortWith((a, b) => a._2 > b._2)
    println(list)

运行结果如下。

ListBuffer((江苏南京,7), (河南洛阳,6), (陕西西安,6), (河南开封,6), (北京,4), (河北临漳,2), (河南商丘,1), (黑龙江,1), (四川成都,1), (陕西咸阳,1), (宁夏银川,1), (浙江杭州,1), (内蒙古,1), (山西夏县,1), (山西大同,1))