Scala基础知识入门——集合的创建、处理细节

Scala基础知识入门——集合

一、scala集合基本介绍

1. Scala同时支持不可变集合和可变集合
2. 两个主要的包：
   不可变集合：scala.collection.immutable
   可变集合： scala.collection.mutable
3. Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变(mutable)和不可变(immutable)的版本
4. Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型。

二、定长数组

1. 定义：① val arr1 = new ArrayInt ；② val arr1 = Array(1, 2)
2. 添加元素：① arr1（0）=1 ；② 通过遍历添加；

三、变长数组

1. 定义：val arr2 = ArrayBufferInt
   赋值：arr2.append(7) arr2(0) = 7
2. 注意：每append一次，arr在底层会重新分配空间，进行扩容，arr2的内存地址会发生变化，也就成为新的ArrayBuffer
3. 定长与变长互转

    arr1.toBuffer  //定长数组转可变数组
    arr2.toArray  //可变数组转定长数组
    说明：
    arr2.toArray 返回结果才是一个定长数组， arr2本身没有变化
    arr1.toBuffer返回结果才是一个可变数组， arr1本身没有变化

4. Scala数组与Java List互转

val arr = ArrayBuffer("1", "2", "3") //Scala集合
import scala.collection.JavaConversions.bufferAsJavaList
val javaArr = new ProcessBuilder(arr) //Java集合
val arrList = javaArr.command() //Scala集合

5. Scala数组与Java数组的互转

import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable
// java.util.List ==> Buffer
val scalaArr: mutable.Buffer[String] = arrList
scalaArr.append("jack")

四、多维数组

1. 定义：val arr = Array.ofDim[Double](3,4)

//说明：
arr 是一个二维数组
有三个元素[一维数组]
每个一维数组存放4个值
//赋值
arr(1)(1) = 11.11

五、元祖Tuple

1. 元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。就是将多个无关的数据封装为一个整体，称为元组注意：元组中最大只能有22个元素。
2. 创建：
   ① val tuple1 = (1, 2, 3, “hello”, 4) ；
   ② var tup1 = (2->“two”,2->“two”);
   ③ var tup4 = 6 ->“six”->“六” // 打印 ((6,six),六)
3. 访问：

val t1 = (1, "a", "b", true, 2)
println(t1._1) //方法一：访问元组的第一个元素 ，从1开始
println(t1.productElement(0)) // 方法二:访问元组的第一个元素，从0开始
for(item <- t1.productIterator){}//方法三：遍历

六、列表List(不可变)

1. 定义：
   ① val list01 = List(1, 2, 3) //创建时，直接分配元素；
   ② val list02 = Nil //空集合
2. 访问

val value1 = list1(1)   // 1是索引，表示取出第2个元素

3. 添加元素（产生新的集合）

符号	应用
:+	运算符表示在列表的最后增加数据val list02 = list01 :+ 4
+:	运算符表示在列表的最前增加数据val list2 = 4 +: list1
::	表示向集合中添加元素
:::	将集合中的元素加入到集合中去

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不是集合无法添加元素

七、列表ListBuffer（可变）

1. ListBuffer是可变的list集合，可以添加，删除元素,ListBuffer属于序列
2. 定义：

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

3. 添加元素

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

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

八、队列Queue

1. 其输入和输出要遵循先入先出的原则，在scala中, 有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue , 一般来说，我们在开发中通常使用可变集合中的队列。
2. 定义：

val q1 = new Queue[Int]

4. 添加元素：

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

5. 方法：

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

九、Map

1. Scala中的Map 和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，Scala中不可变的Map是有序的，可变的Map是无序的。Scala中，有可变Map (scala.collection.mutable.Map) 和 不可变Map(scala.collection.immutable.Map).
2. 创建：

a) Map中的元素底层是Tuple2类型，创建时默认情况下（即没有引入其它包的情况下）,Map是不可变Mapa) Map中的元素底层是Tuple2类型，创建时默认情况下（即没有引入其它包的情况下）,Map是不可变Map

al map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")

b) 指定可变Map的包

val map2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)

c) HaMap可以通过new创建，其他不可以

val map3 = new scala.collection.mutable.HashMap[String, Int]

d) 通过对偶元组创建，和第一种方法等价

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )

3. 取值：

a) 使用map（key）取值，如果key存在，则返回对应的值，如果key不存在，则抛出异常

[java.util.NoSuchElementException]，在Java中,如果key不存在则返回null
val value1 = map2("Alice")

b) 使用contains方法检查是否存在key，返回Boolean

map4.contains("B")

c) 使用map.get(key).get取值

var map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.get("A")) //如果key存在返回Some对象，不存在返回None
println(map4.get("A").get) //通过Some取值，key存在，返回对应值，否则抛出异常 
java.util.NoSuchElementException: None.get

d) 使用map4.getOrElse()取值

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.getOrElse("A","默认"))
//如果key存在，返回key对应的值。
//如果key不存在，返回默认值。

e) 如何选择取值方式建议

• 如果我们确定key是存在的，应该使用map(“key”) ,速度快.==
• 如果我们不确定key是否存在， 而且在不存在时，有业务逻辑处理就是用map.contains() 配合 map(“key”)
• 如果只是简单的希望返回一个值，就使用getOrElse()

4. 修改、添加、删除

a) 修改

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4(“A”) = 20 //修改或增加，map 是可变的，才能修改，否则报错

b) 添加

//添加单个元素
val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4 += ( "D" -> 4 )

//添加多个元素
val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
val map5 = map4 + ("E"->1, "F"->3) //创建新的Map集合
map4 += ("EE"->1, "FF"->3)  //原有集合添加

c) 删除

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4 -= ("A", "B") //一次可删除多个键值对，key存在则删除，不存在也不报错

5. 遍历

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)

输出结果：
A is mapped to 1
C is mapped to 3
B is mapped to 北京
A
C
B
1
3
北京
(A,1)
(C,3)
(B,北京)

十、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映射

将集合中的每一个元素通过指定功能（函数）映射（转换）成新的结果集合这里其实就是所谓的将函数作为参数传递给另外一个函数,这是函数式编程的特点。

举例：将英文编程大写字母
val names = List("Alice","Bob","Nick")
//val names2 = names.map((s:String)=>s.toUpperCase) 
val names2 = names.map(_.toUpperCase) //简写
打印：List(ALICE, BOB, NICK)

flatmap映射

flatmap：flat即扁平化，效果就是将集合中的每个元素的子元素映射到某个函数并返回新的集合。

举例：
val names  = List("Alice","Bob","Nick")
val names2 = names.flatMap(_.toUpperCase())
println(names2)
打印：List(A, L, I, C, E, B, O, B, N, I, C, K)

十二、集合元素过滤-filter

filter：将符合要求的数据(筛选)放置到新的集合中

举例：筛选首字母为“A”
val names  = List("Alice","Bob","Nick")
val names2 = names.filter(_.startsWith("A"))
println(names2)
打印：List(Alice)

十三、集合元素归约

调用reduce（）、reduceLeft（）、reduceRight（）方法，reduce和 reduceLeft都是从左边开始，每两个元素调用一次函数，并将返回值与下一个元素组成一个实参组合进而调用函数。reduceRight从右边开始计算，需要特别注意计算顺序。

举例
val list = List(1,2,3,4,5)
val n = list.reduceLeft((n1:Int,n2:Int)=>n1-n2)
println(n) // 打印 -13 

val n2 = list.reduceRight((_-_)) //_-_ 为简写
println(n2) //打印 3
//计算过程 4-5 ，3-（-1），2-4，1-（-2）

十四、集合元素折叠

（z:B）为初始值，作为左侧第一个数参与运算
val list = List(1,2,3,4,5)
val sum = list.fold(0)(_+_)
println(sum) //打印 15
//测试二 右侧
val list = List(1,2,3,4,5)
def aa(n1:Int,n2:Int):Int ={
print(n1+"-----"+n2+"  ")
n1-n2
}
val n = list.foldRight(1)(aa)
println(n)
//打印
5-----1  4-----4  3-----0  2-----3  1------1
2

十五、集合元素扫描

对元素的处理方式和fold相同，不同在于scan将每次调用函数产生的中间结果保存在一个集合中，而fold只返回最后结果。

举例
val n = (1 to 3).scanLeft(3)(_*_)
println(n)
//打印 Vector(3, 3, 6, 18)