Scala语言学习二——集合

Scala Collection

Scala提供了一套很好的集合实现，提供了一些集合类型的抽象。

Scala 集合分为可变（mutable）的和不可变的集合(immutable)
。

• 可变集合：长度可变，内容可变
• 不可变集合：长度不可变，内容也不可变

可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。

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

接下来我们将为大家介绍几种常用集合类型的应用：

1. Scala List(列表)

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

2. Scala Set(集合)

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

3. Scala Map(映射)

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

4. Scala 元组

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

以下代码判断，演示了所有以上集合类型的定义实例：

// 定义整型 List
val x = List(1,2,3,4)

// 定义 Set
val x = Set(1,3,5,7)

// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// 创建两个不同类型元素的元组
val x = (10, "Runoob")

Scala List(列表)

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。

在 Scala 中列表要么为空（Nil 表示空列表） 要么是一个 head 元素加上一个 tail 列表。

9 :: List(5, 2) 

:: 操作符是将给定的头和尾创建一个新的列表

比如

List（9,10,6,4,1）
头head元素是9
尾tail列表是10,6,4,1

Nil 表示空列表

不可变列表

创建列表

在 Scala 中列表要么为空（Nil 表示空列表） 要么是一个 head 元素加上一个 tail 列表。

val list=List（9,5,2） //创建一个不可变的集合
val list2= :: List(5, 2) // :: 操作符是将给定的头和尾创建一个新的列表
val list3=100：Nil //表示List(100)
val list4=Nil //表示空列表

列表基本操作

//将 0 插入到 lst1 的前面生成一个新的 List
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0)

//将一个元素添加到 lst1 的后面产生一个新的集合
val lst6 = lst1 :+ 3
val lst0 = List(4,5,6)

//将 2 个 list 合并成一个新的 List
val lst7 = lst1 ++ lst0

//将 lst0 插入到 lst1 前面生成一个新的集合
val lst8 = lst1 ++: lst0

//将 lst0 插入到 lst1 前面生成一个新的集合
val lst9 = lst1.:::(lst0)

// 使用 concat 方法，site1在前，site2在后
fruit = List.concat(site1, site2)
site1在前，site2在后
 
      

list.count    //返回个数

list.filter（x=>x>=3）    //过滤，过滤大于等于3的元素，生成一个新的集合

list.sorted()   //默认升序排序，生成一个新的集合

wps=List（（"a",1），（"c",3））
wps.sortBy(t=>-t._2) //根据什么排序升序，参数为函数

wps.sortWith(（x,y）=>x._2>y._2)     //根据需求排序，有点像compare to，参数是boolean

grouped（）让组内的多少分一组，比如两个分一组
list.grouped（2）//List(List(1,2),List(3,4),List(1,2))
看到55分


}

列表的常用方法

list=List(3,5,1)
fold(初始值)（叠加的函数）
list.fold（0）((x,y)=>x+y)


/*计算过程
*（0+3）//0是初始值
*(3+5)
*(8+1)=9
*结果为9,9+3+5+1
*
*foldLeft
*foldRight
*只是整合的方向不停
*第一个下划线代表初始值，第二个代表集合中操作的元素
*简写 list.fold(0)(_+_)
*
*/




-----------------------------------------------------------
list.reduce((x,y)=>x+y)

也是整合
---------------------------------------
 List.union(list2)

求两个集合的并集

-------------------------- 
交集
list.intersect(list2)
——————————————
差集
list.diff(list2 )

-----------------
list(0,8,6)
list2(3,5,1)
list.zip(list2)  //对应位置组成元组
//得结果
//list((3,0),(5,8),(1,6))

r.map(x=>(x._1+x._2)) //元组相加


----------------------------
list2.mkString("|")
//生成字符串，可指定分割符
0|8|6|3
-----------------------
list.length()
list.size()
//求长度，一样的
----------------------------------
//列表截取 前闭后开
list.slice(1,3)
list.slice(1,list.length-1)

可变列表

// 如 果 想 使 用 可变数组 ， 需 要 导 入 import scala.collection.mutable.ListBuffer 包

import scala.collection.mutable.ListBuffer

object MutListTest extends App{

//构建一个可变列表， 初始有 3 个元素 1,2,3
val lst0 = ListBuffer[Int](1,2,3)

//创建一个空的可变列表
val lst1 = new ListBuffer[Int]

//向 lst1 中追加元素， 注意： 没有生成新的集合
lst1 += 4
lst1.append(5)

//将 lst1 中的元素最近到 lst0 中， 注意： 没有生成新的集合
lst0 ++= lst1

//将 lst0 和 lst1 合并成一个新的 ListBuffer 注意： 生成了一个集合
val lst2= lst0 ++ lst1
//将元素追加到 lst0 的后面生成一个新的集合
val lst3 = lst0 :+ 5
}

Scala Set(集合)

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

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

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

默认引用 scala.collection.immutable.Set，不可变集合实例如下：

可变集合基本操作

import scala.collection.immutable.HashSet   //导入包

val set1 = new HashSet[Int](1,3,4)   //生成一个可变的set

set1.add(5)  //添加元素
set+=(3) //添加元素
set1.remove(1)  //移除元素
set-=(3)  //移除元素
set ++=Set(0,9)    //拼接两个Set




// 查找集合中最大与最小元素
min = num.min 
max=num.max 

不可变集合基本操作

al set =Set(1,2,3) //生成一个不可变的set

//方法类似，只是不可变，需要新生成一个set

Scala Map(映射)

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

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

• Map 中的键都是唯一的。

• Map 也叫哈希表（Hash tables）。

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

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

• 在 Scala 中 你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。以下实例演示了不可变 Map 的应用：

演示：

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

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

定义 Map 时，需要为键值对定义类型。如果需要添加 key-value 对，可以使用 + 号，如下所示：

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

不可变映射操作

定义一个定长的映射
val mp=Map[String,Int]（"a"->1,"b"->2）

可变映射操作

import scala.collection.mutable
val map1 =  mutable.HashMap[String, Int]()


//向 map 中添加数据
map1("spark") = 1
map1 += (("hadoop", 2))
map1.put("storm", 3)

println(map1)

// 取值 get getOrElse()
//从 map 中移除元素
map1 -= "spark"
map1.remove("hadoop")

println(map1)


map1.get("hadoop").get  //取value,如果是null，则异常
map1.get("hadoop",0).getOrElse  //取value,如果没有就传默认值，可设定，这里是0
 map1.MapValue(t=>t+100))   //对map的value进行操作，然后返回值是操作后的map
 //区别于
 map1.map(x=>x._2+100)

Scala 元组

Scala 元组将固定数量的项目组合在一起， 以便它们可以作为一个整体传递。
与数组或列表不同， 元组可以容纳不同类型的对象， 但它们也是不可变的。
元组 可以放任意数据类型的数据

目前 Scala 支持的元组最大长度为 22。

定义元组

以下实例在元组中定义了三个元素，对应的类型分别为[Int, Double, java.lang.String]。

此外我们也可以使用以下方式来定义：

val t = (1, 3.14, "Fred")  
val t = new Tuple3(1, 3.14, "Fred")

访问 tuple 中的元素

我们可以使用 t._1 访问第一个元素， t._2 访问第二个元素，如下所示：

println(t._2) // 访问元组总的第二个元素

对偶元组

// 对偶元组
val tuple2 = (1, 3)
// 交换元组的元素位置, tuple2 没有变化, 生成了新的元组
val swap = tuple2.swap

记词案例scala实现2

解析：
步骤1:map(x=>(x,1) //将元素变成元组（单词，1）
步骤2:groupBy(x=x.1) //让元素根据元组的第一个进行分组
步骤3:mapValue(t=>t.foldLeft(0)(+.2)) 先取出map的value，然后value是元组组成的array，第一个下划线代表初始值，第二个代表元组第二个元素，即计数,然后用t.foldLeft(0)(+._2)将元组第二个元素相加，就是数量相加

arr.flatMap(_.split(" ")).map(x=>(x,1).groupBy(x=x._1).mapValue(t=>t.foldLeft(0)(_+_._2))
//返回值Map(scala->1,holo->1,lin->2)