目录

一，概述

二，set的声明

1,不可变set集合

1)向不可变集合中添加元素    + 【需要新的set集合接收】

2）对两个set集合进行合并   ++   【需要新的set集合接收】

2，不可变的HashSet集合

2，可变HashSet集合

1）可变HashSet集合常用函数

①使用+=函数向集合中添加元素

②使用-=函数从集合中删除元素

③使用add函数向集合中添加元素

③使用remove函数从集合中删除元素

④使用 ++=函数将两个同类序列进行拼接 

⑤使用  --=函数将两个同类序列进行拼接

三，set集合的通用函数

1，查看集合中的元素个数    size

 2，获取set集合中的第一个元素   head

 3，获取set集合中除第一个之外的其他元素    tail

---

一，概述

set集合有两个显著的特点：①无序；②去重【元素不重复】

set集合也分为可变和不可变两种，并且set集合还有一种特殊的集合HashSet。

在Java中set集合其实就是个接口，它本身不能直接new创建出来一个set集合对象，而是得使用其下的子类，来实例化一个集合对象。如：HashSet,SortedSet等，这篇文章中我们就只了解Scala中的Set和HashSet集合。

二，set的声明

1,不可变set集合

格式：val/var  变量名 =Set（x1,x2,....)

scala> val set1=Set(1,2,3)
set1: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

对于不可变的set来说，我们对它的任何操作都不会生效。只能使用一个新的set集合进行接收。

如向set集合中添加元素的+函数，两个set集合进行拼接的函数++等都不会对原集合产生影响。

1)向不可变集合中添加元素    + 【需要新的set集合接收】

scala> set1
res9: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> set1 + 5
res10: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 5)

scala> set1
res11: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

 能够添加一个元素，也就可以添加多个元素，如下，我们向set1集合中添加7，8，9三个元素：

scala> set1
res11: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> set1 + (7,8,9)
res12: scala.collection.immutable.Set[Int] = Set(1, 9, 2, 7, 3, 8)

scala> set1
res13: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

2）对两个set集合进行合并   ++   【需要新的set集合接收】

使用++函数并不会对原来的set集合产生任何影响，如果想要使用合并后的set集合结果的话可以使用一个变量就行存储。

scala> val set2 =Set(10,11,12)
set2: scala.collection.immutable.Set[Int] = Set(10, 11, 12)

scala> set1
res14: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> set2
res15: scala.collection.immutable.Set[Int] = Set(10, 11, 12)

scala> set1 ++ set2
res16: scala.collection.immutable.Set[Int] = Set(10, 1, 2, 12, 3, 11)

scala> set1
res17: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

2，不可变的HashSet集合

在学习Java的时候相信大家还有点印象，就是set集合其实是一个接口，我们不直接使用Set类new实例化一个集合对象，而是使用它的实现类来创建对象，HashSet集合就是Set集合接口下的其中一个实现类。它的使用和Set集合一样，但是在声明的时候，我们需要导入相关的包：

import scala.collection.immutable.HashSet

scala> import scala.collection.immutable.HashSet   // 导入创建不可变hashset集合所需要的包
import scala.collection.immutable.HashSet

scala> val  set_hashset=HashSet(1,2,3)
set_hashset: scala.collection.immutable.HashSet[Int] = Set(1, 2, 3)   // 创建不可变的hashset集合

 之后我们像Set集合那样向HashSet集合中添加元素或者是对两个hashset集合进行拼接，效果都会和set集合一样： 

scala> set_hashset
res3: scala.collection.immutable.HashSet[Int] = Set(1, 2, 3)

scala> set_hashset + 10 // 向hashset集合中添加一个元素10
res4: scala.collection.immutable.HashSet[Int] = Set(10, 1, 2, 3)

scala> set_hashset //
res5: scala.collection.immutable.HashSet[Int] = Set(1, 2, 3)

唯一不同的就是HashSet可以位于两种不同的包下，一个是immutable（不易变）包下为不可变的hashset集合，另外一个是在mutable（易变）包下为可变的hashset集合。我们需要的就是这个位于易变包mutable下的HashSet集合。接下来我们去进一步了解可变的HashSet集合。

2，可变HashSet集合

需要注意的是，如果我们之前已经导入了一个位于不易变包下的不可变HashSet，再去导入易变包下的可变HashSet集合，并想要创建一个可变的HashSet集合，那么这个时候就会报错【当我在cmd命令行中运行这些代码的时候没有报错】：

scala> import scala.collection.immutable.HashSet
import scala.collection.immutable.HashSet

scala> import scala.collection.mutable.HashSet
import scala.collection.mutable.HashSet

scala> val set_hashset=HashSet(1,2,3)  // 默认使用可变的HashSet来创建集合
set_hashset: scala.collection.mutable.HashSet[Int] = Set(1, 2, 3)

scala> val set_hashset1=new HashSet[Int] // 动态创建HashSet集合，程序并不知道我们使用的是可变还是不可变的HashSet
set_hashset1: scala.collection.mutable.HashSet[Int] = Set()

scala>

这个时候我们就需要使用到idea：

/**
 * @author:码到成龚
 * my motoo:"听闻少年二字，应与平庸相斥。"
 */
import  scala.collection.immutable.HashSet  // 导入不可变的hashset
import  scala.collection.mutable.HashSet    // 导入可变的hashset
object TestSet1 {
    // 测试HashSet集合
    def main(args: Array[String]): Unit = {
      val set_hashset=HashSet(1,2,3)  // 静态创建一个hashset集合
      val set_hashset1=new HashSet[Int] //  动态创建一个hashset集合
    }
}

 如上，我们可以发现，在idea上如果同时导入了mutable包和immutable包时，去使用new实例化hashset集合，我们的idea编译器就会直接报错，这种在运行前就报错称为编译时异常。

 因为程序并不知道我们使用的HashSet用得是mutable包下的，还是immutable包下的。所以我们在导入的时候还得需要对导入的HashSet进行起别名操作：

/**
 * @author:码到成龚
 * my motoo:"听闻少年二字，应与平庸相斥。"
 */
import  scala.collection.immutable.{HashSet  => HashSetIm}  // 导入不可变的hashset,并起别名
import  scala.collection.mutable.HashSet    // 导入可变的hashset
object TestSet1 {
    // 测试HashSet集合
    def main(args: Array[String]): Unit = {
      val set_hashset=HashSet(1,2,3)  // 静态创建一个hashset集合
      val set_hashset1=new HashSet[Int] //  动态创建一个hashset集合
    }
}

 如上，我们再去创建hashset集合时就不会有报错。

1）可变HashSet集合常用函数

①使用+=函数向集合中添加元素

可变hashset集合使用+=函数能够直接改变该集合的元素的组成：在hashset集合中的元素位置为hashset集合的长度都会改变，如下：

scala> set_hashset   // 动态创建的hashset集合
res0: scala.collection.mutable.HashSet[Int] = Set(1, 2, 3)

scala> set_hashset1     //  静态创建的hashset集合
res1: scala.collection.mutable.HashSet[Int] = Set()

scala> set_hashset+=(7,8,9)    // 向hashset集合中添加元素
res2: set_hashset.type = Set(9, 1, 2, 3, 7, 8)

scala> set_hashset1+=(7,8,9)   
res3: set_hashset1.type = Set(9, 7, 8)

scala> set_hashset         //  查看添加元素之后的hashset集合中元素是否有增多
res4: scala.collection.mutable.HashSet[Int] = Set(9, 1, 2, 3, 7, 8)

scala> set_hashset1
res5: scala.collection.mutable.HashSet[Int] = Set(9, 7, 8)

②使用-=函数从集合中删除元素

-=函数和+=函数类似：

scala> set_hashset1    // 修改前的hashset集合
res5: scala.collection.mutable.HashSet[Int] = Set(9, 7, 8)

scala> set_hashset1 -=(8,9)  // 从hashset集合中删除两个元素8和9
res6: set_hashset1.type = Set(7)

scala> set_hashset1    // 修改之后的hashset集合
res7: scala.collection.mutable.HashSet[Int] = Set(7)

③使用add函数向集合中添加元素

add函数不像可变数组，可变列表那样的append函数可以一次性加入多个元素，也没有insert函数可以使用，但是就set集合本身来说它的特点：不可重复，在我们编写代码的过程中有很大的作用。add函数不管添加成功与否，返回的结果只有true或false，表示添加成功或者是失败：

scala> set_hashset1     
res10: scala.collection.mutable.HashSet[Int] = Set(7, 4)

scala> set_hashset1.add(10)  // add函数一次性只能够添加一个元素
res11: Boolean = true        //  add函数只会返回两种值，true或者是false，添加成功为true，反之false

scala> set_hashset1
res12: scala.collection.mutable.HashSet[Int] = Set(10, 7, 4)

③使用remove函数从集合中删除元素

因为set集合是没有索引的，所以我们在使用remove函数对集合中的元素进行删除处理的时候不能向remove函数中传入索引，而是指定的单个元素值：

scala> set_hashset1 
res12: scala.collection.mutable.HashSet[Int] = Set(10, 7, 4)

scala> set_hashset1.remove(10)   //  该函数只能够删除一个元素（指定的元素值）
res13: Boolean = true            //  remove函数和add函数一样只能返回两种结果

scala> set_hashset1
res14: scala.collection.mutable.HashSet[Int] = Set(7, 4)

④使用 ++=函数将两个同类序列进行拼接 

++=和+=函数的作用一样，都是向集合中添加元素，但是++=函数可以用于同类序列之间的拼接，而+=函数是无法实现的：

scala> val set_set=Set(66,77,88)   //  创建一个不可变set集合
set_set: scala.collection.immutable.Set[Int] = Set(66, 77, 88)

scala> set_hashset1     // 查看可变hashset集合中的元素
res16: scala.collection.mutable.HashSet[Int] = Set(7, 4)

scala> set_hashset1 ++= set_set    // 将两个集合进行拼接
res17: set_hashset1.type = Set(66, 88, 7, 4, 77)

scala> set_hashset1    // 查看拼接后的集合
res18: scala.collection.mutable.HashSet[Int] = Set(66, 88, 7, 4, 77)

⑤使用  --=函数将两个同类序列进行拼接

--=和++=函数类似：

scala> set_hashset1    // 修改之前的hashset集合
res19: scala.collection.mutable.HashSet[Int] = Set(66, 88, 7, 4, 77)

scala> set_hashset1  --= set_set  // set_hashset1集合中减掉set_set集合中的元素
res20: set_hashset1.type = Set(7, 4)

scala> set_hashset1   // 修改之后的hashset集合
res21: scala.collection.mutable.HashSet[Int] = Set(7, 4)

scala> set_set // set_set集合中的元素
res22: scala.collection.immutable.Set[Int] = Set(66, 77, 88)

三，set集合的通用函数

1，查看集合中的元素个数    size

scala> set1.size
res2: Int = 3

scala> set1
res3: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

 2，获取set集合中的第一个元素   head

scala> set1
res4: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> set1.head
res5: Int = 1

 3，获取set集合中除第一个之外的其他元素    tail

scala> set1
res6: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> set1.tail
res7: scala.collection.immutable.Set[Int] = Set(2, 3)