Scala的集合

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Scala的集合相关的知识,希望对你有一定的参考价值。

1.集合基础概念

? (1)集合的相关介绍

? ? Scala的集合有三大类:序列(seq)、集合(set)、映射(map)所有的集合都扩展自Iterable 特质,在Scala中集合有可变和不可变两种类型,可变集合可以在适当的地方被更新或者扩展,这意味着可以修改、添加、移除一个集合的元素,而不可变集合类则永远不会改变,但是仍然可以模拟添加、移除、或者更新操作,但是这些操作下都会返回一个新的集合。immutable 类型的集合 初始化后就不能改变了(注意与 val 修饰的变量进行区别),val 和 var:表明定义的变量(引用)是否能被修改而指向其他内容。
? ? 表明的是内存中开辟出来的这块空间里的内容能否被修改,如果针 对 immutable 变量进行修改,其实是开辟了一块新的内存空间,产生了一个新的变量,而 原来的变量依然没有改变

? (2)scala的集合类的结构

? ?所有关于集合的类都在:scala.collection包中。
技术分享图片
? ?不可变集合:scala.collection.immutable中。
技术分享图片
? ?可变集合:scala.collection.mutable中。
技术分享图片
? ?而在默认的情况下Scala使用的是不可变的集合类。如果行使用可变对象必须:scala.collection.mutable.Set

2.集合的相关使用

(1)序列-list

 不可变序列:
 object Test01 {
  def main(args: Array[String]): Unit = {
   //1.创建一个list集合
    val list01=List(1,2,3,4)
    //2.判断集合是否为空
    println(list01.isEmpty) //false
    //3.获取集合中的头元素
    println(list01.head)    //1
    //4.获取集合中除了head的其他元素
    println(list01.tail)    // 2 3 4
    //5.获取list集合中的最后一个元素
    println(list01.last)    //4
    //6.集合元素反转
    println(list01.reverse) //4 3 2 1
    //7.丢弃集合中的前n个元素
    list01 drop 2
    //8.获取集合中的前N个元素
    var list02=list01.take(3)
    //9.将集合进行分裂,返回一个tuple 第一个元素只有2个元素的list,第二个是集合中的剩下的所有元素
    val tuple: (List[Int], List[Int]) = list01.splitAt(2)
    //10.将两个集合压缩成一个
    var list03=List(1,2,3,4)
    val list04=List("1","2","3","4")
    val lss=list03 zip list04
    println(lss.toString()) //[(1,"1"),(2,"2"),(3,"3"),(4,"4")]

    //11.集合,转换为字符串
    println(list01.mkString(","))

    //12.集合转化为数组
    val arr=list01.toArray
  }
}
可变序列:
    object Test01 {
  def main(args: Array[String]): Unit = {
   //1.创建一个list集合
    val list01=ListBuffer(1,2,3,4)
    //向可变序列中追加元素 (不会生成新序列)
    list01+=1
    list01.append(0)
    //两个集合合并,会生出新的序列
    val list02=ListBuffer(1,2,3,4)
    val list03=ListBuffer(1,2,3,4)
    val list04=list02++list03
  }
}```

### (2) set集合

不可变set
object Test01 {
def main(args: Array[String]): Unit = {
//创建一个不可变的set
var set01 =new mutable.HashSet[Int]()
val set02=set01+5 //生成一个新的set
val set03=set01++set02 //两个集合之间的合并
}
}

可变的set:
object Test01 {
def main(args: Array[String]): Unit = {
//1.创建一个可变的set
val set01=new mutable.HashSet[Int]()
//2.添加元素时,不会生成新的set
set01+=1
set01.add(1)
set01.add(2)
//3.删除一个元素
set01-=1
set01.remove(2)

//4.set的常用场景
val set02=Set(1,2,3,4)
val set03=Set(3,4,5,6)
//4.1 交集
val ints: Set[Int] = set02.intersect(set03)
//4.2 并集
val unin: Set[Int] = set02.union(set03)
//4.3差集
val diff: Set[Int]=set02.diff(set03)

}
}


### (3) map 映射
? ?     在 Scala 中,有两种 Map,一个是 immutable 包下的 Map,该 Map 中的内容不可变; 另一个是 mutable 包下的 Map,该 Map 中的内容可变

不可变map
object Test01 {
def main(args: Array[String]): Unit = {
//1.创建map
val base_info=Map("name"->"zs","age"->18,"address"->"beijign")
val extr0info=Map(("hobby","basketball"),("tall",180),("work","computer"))

//2.获取合修改map中的值
println(base_info.get("name")) //获取map中相应元素的值,根据key找value
println(base_info.getOrElse("age",18)) //表示根据key找value,如果没有使用默认值
base_info("age")=25 //注意这句代码是错误的,因为创建的不可变map,不能修改其中的值。

//3.遍历map
for(kv<-base_info){
  println(kv._1,kv._2)
}
//使用map自带的foreach函数遍历
base_info.foreach(kv=> println(kv._1,kv._2))

}
}

不可变map修改值异常:
![](http://i2.51cto.com/images/blog/201812/29/97eeade2cc6186a2fd826ab20fef264b.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)

可变map操作:
object Test01 {
def main(args: Array[String]): Unit = {
//1.创建map
val base_info=collection.mutable.
HashMap("name"->"zs","age"->18,"address"->"beijign")

//添加元素
base_info.put("hobby","basketball")
//添加map
val extra_info=collection.mutable.
  HashMap("name"->"zs","age"->18,"address"->"beijign")
val new_map=base_info++extra_info

//获取元素的值
val name: Option[Any] = base_info.get("name")
//判断是否有这个元素
base_info.contains("name")  //根据key判断是否有这个元素

}
}

(4)Option, None, Some 类型介绍
?? None、Some 是 Option 的子类,它主要解决值为 null 的问题,在 java 语言中, 对于定义好的 HashMap,如果 get 方法中传入的键不存在,方法会返回 null,在编写代码的 时候对于 null 的这种情况通常需要特殊处理,然而在实际中经常会忘记,因此它很容易引起 NullPointerException 异常。在 Scala 语言中通过 Option、None、Some 这三个类来避免这样 的问题,这样做有几个好处,首先是代码可读性更强,当看到 Option 时,我们自然而然就 知道它的值是可选的,然后变量是 Option,比如 Option[String]的时候,直接使用 String 的话, 编译直接通不过。
例:

object Test01 {
def main(args: Array[String]): Unit = {
//1.创建map
val base_info = collection.mutable.
HashMap("name" -> "zs", "age" -> 18, "address" -> "beijign")
//传递不存在的key
println(base_info("hobby"))
}
}

报出错误:
![](http://i2.51cto.com/images/blog/201812/29/28808585e5d883f4af2648bb8006a6da.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)

object Test01 {
def main(args: Array[String]): Unit = {
//1.创建map
val base_info = collection.mutable.
HashMap("name" -> "zs", "age" -> 18, "address" -> "beijign")
//传递不存在的key
println(base_info.get("hobby")) //返回none并不是报错
}
}


**总结**:Option有两个子类别,Some和None。当程序回传Some的时候,代表这个函式成功地给了你一个String,而你可以透过get()函数拿到那个String,如果程序返回的是None,则代表没有字符串可以给你。在Scala里Option[T]实际上是一个容器,就像数组或是List一样,你可以把他看成是一个可能有零到一个元素的List。当你的Option里面有东西的时候,这个List的长度是1(也就是 Some),而当你的Option里没有东西的时候,它的长度是0(也就是 None)。

### (5)元组-Tuple
元组的创建:

object Test01 {
def main(args: Array[String]): Unit = {
//创建tuple
val tuple01=(1,2,3)
val (name,age,id)=("zs",18,1001) //这种方式是给tuple中的每一个元素起名字

//val (name,age,id)=("zs",18,1001)方式的实际应用
def getMaxandMin(arr:Array[Int]) ={
  (arr.max,arr.min)
}
val (max,min)=getMaxandMin(Array(1,2,3,4)) //可以一次性获取最大值,最小值

}
}

元组的转化:

object Test01 {
def main(args: Array[String]): Unit = {
//创建一个全部是元组的数组
val arr=Array((1,"zs"),(2,"ls"),(3,"ww"))
val map = arr.toMap
map.foreach(e=>println(s"${e._1}:${e._2}"))
}
}


### (6)集合的综合使用:
编写wordcount程序:
方法一:

object Test01 {
def main(args: Array[String]): Unit = {
//定义一个数组
val arr=Array("zzy,zs,ww,zl","zy,jj,ww,cl","zzy,jj,ww","jj,cl,ww")
//1.第一步,将数组中的每一个元素按,切分
//((zzy,zs,ww,zl),(zy,jj,ww,cl),(zzy,jj,ww),(jj,cl,ww))
val words: Array[Array[String]] = arr.map(line=>line.split("s+"))
//2.将数组元素为元组的,数组,压平成一个全是字符串的数组
//zzy zs ww zl zy jj ww cl zzy jj ww jj cl ww
val word: Array[String] = words.flatten

//3.对数组元素进行分类输出
//(zzy,1) (zs,1) (ww,1) (zl,1) ...
val tuples: Array[(String, Int)] = word.map(word=>(word,1))

//4.将元素进行分组
//map(ww,(1,1,1,1)),(zzy,(1,1))
val stringToTuples: Map[String, Array[(String, Int)]] = tuples.groupBy(x=>x._1)

//5.对每个分组的元素进行聚合
val wordcount: Map[String, Int] = stringToTuples.map(x=>(x._1,x._2.length))

}
}```
方法二:

object Test01 {
  def main(args: Array[String]): Unit = {
    val arr=Array("zzy,zs,ww,zl","zy,jj,ww,cl","zzy,jj,ww","jj,cl,ww")
    val words: Array[String] = arr.flatMap(line=>line.split("\s+"))
    val word: Array[(String, Int)] = words.map(word=>(word,1))
    val stringToTuples: Map[String, Array[(String, Int)]] = word.groupBy((x=>x._1))
    stringToTuples.map(word=>(word._1,word._2.length))
  }
}

以上是关于Scala的集合的主要内容,如果未能解决你的问题,请参考以下文章

电子书丨《Scala集合技术手册》

代码片段 - Golang 实现集合操作

Scala:创建通用集合的问题

在 Scala 中迭代 Java 集合

laravel特殊功能代码片段集合

Scala 中 10 个超赞的集合操作函数