SCALA-集合与函数式编程（一）

一、集合特点

//Scala同时支持可变集合和不可变集合。

不可变集合

• 结构紧凑节省空间。
• 不用考虑扩容和同步等问题，所以代码更精简性能更好。
• 缺点就是无法改变

可变集合

• 唯一优点就是可改变

不可变集合层次

可变集合层次

二、数组

//Array其实并不是一种对象型的容器，Scala编译器会直接把new Array[Int](10)变成java的new int[10]

2.1定长数组及其相关方法

val ints = new Array[Int](10) for (i<- ints ) {//遍历 println(s"i = ${i}") } println(s"ints.max = ${ints.max}") //最大值 println(s"ints.min = ${ints.min}") //最小值 println(s"ints.sum = ${ints.sum}") //求和 //把内容整合成用分隔符分割的字符串 val str = ints.mkString(",") println(s"str = ${str}")

2.2多维数组

val intses = Array.ofDim[Int](5,5) intses(0)(0)=10 intses(1)(1)=20 ······ for (col <- intses ;num <-col) { //遍历 println(s"num = ${num}") }

三、元组

//元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。

//就是将多个无关的数据封装为一个整体。元组中最大只能有22个元素，Tuple4表示元组中有4个元素

//功能定位： 简单快捷的少量元素集合

//元组是不可变集合，所以线程安全

3.1元组的创建及其基本操作

val tuple1=(1,2,"three","四","wu") for (t <- tuple1.productIterator ) { //遍历 println(s"t = ${t}") } println(s"tuple1 = ${tuple1._1}") //获取单值 println(s"tuple3 = ${tuple1._3}")

注意：元素的访问有下划线，并且访问下标从1开始，而不是0

3.2使用场景：多返回值

def process(i:Int) ={   //.......   if(i==0)  ("sucess",10000)  else  ("fail",20000)  } val tuple = process(2) println(tuple)

四、列表

//默认为不可变集合

4.1列表的创建及其基本操作

val list = List(1,2,3) println(s"list = ${list}") println(list(1)) //取下标的值 println(s"list.head = ${list.head}") //取第一个元素 println(s"list.tail = ${list.tail}") //取head后面的所有值，返回值是一个list集合 val list2 = list:+99// :+表示在列表的最后加元素 val list3 = 100+:list//+:表示在列表的前面加元素 val list4="A"::"B"::"C"::list//合并 val list5 = list2++list3

注意：向列表中增加元素，因为scala中默认时不可变集合，所以增加元素后，集合本身不变，但是会产生新的列表集合

五、缓冲

5.1ArrayBuffer

//类似于Java中的ArrayList,内部也是由数组结构组成的。

 //与scala的List相比，最大的不同是ArrayBuffer是可变的，但同时也是线程不安全的。

• ArrayBuffer的基本操作

val arrayBuffer = ArrayBuffer("a","b","1")//声明&初始化 println(s"arrayBuffer = ${arrayBuffer}")//取值 arrayBuffer+="2"//加值 arrayBuffer-="1"//减值 for (a <- arrayBuffer ) {//遍历 println(s"a = ${a}") }

• 与java的list进行互转

//buffer转list import scala.collection.JavaConversions.bufferAsJavaList var list:java.util.List[String]  =arrayBuffer; println(list)

//list转buffer var list2:java.util.List[String]=new util.ArrayList[String]; import scala.collection.JavaConversions.asScalaBuffer val arrayBuffer2: mutable.Buffer[String]=list2;

5.2ListBuffer

//从功能角度同 与ArrayBuffer几乎没有差异，区别只在于由于内部结构不同，处理不同的业务性能不一样。

	ArrayBuffer	ListBuffer
内部结构	数组	链表
优点	按下标取值更快 toArray速度更快	插入值更快 toList速度更快
缺点	追加元素会涉及扩容	按下表取值较慢

六、映射

6.1不可变映射（有序）

val map1 = Map("Al" -> 10, "Ja" -> 20, "Ko" -> 30)//构造 println(s"Alice = ${map1("Al")}")//取值方法一 val option = map1.get("Al")//取值方法二 println(s"option = ${option}") val value = option.get //Some类型可以通过.get方法获得真正的值 //这种方式返回的是一种Option[T]类型的值，这种类型一般表示不确定的返回值，比如我们用一个key查询Map，那么结果可能存在也可能不存在，如果存在返回的是Some[T]，如果不存在返回的是None。

注意：4个或4个值以内的：分别由Map1,Map2,Map3,Map4组成。

Map1 内部就是1组 key1,value1

Map2  内部是key1,value1,key2,value2。

以此类推，查询数据时就直接挨个比较就可以了。这是一种在值很少时的进行的优化。

当超过4个值以上，会使用类似java7中的Hashmap的结构 即数组加链表的结构

6.2可变映射（无序）

val map2 = scala.collection.mutable.Map ("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)//可变映射 val map3 = new scala.collection.mutable.HashMap [String, Int]//空映射 map2.put("Rose",1)//加值 //更新，三种方式 map2.put("rose",97) map2("rose")=97 map2 += ("Bob" -> 99) val map4 = map2 + ("AAA" -> 10, "BBB" -> 20) //删除值 map2.remove("rose") //只能删除单键 map2-=("rose","zhang3")//可以删除多键 //遍历，四种方式 for ((k, v) <- map2 ) {//获得key,value   println(k+":"+v) } for (k <- map2.keys ) {//获得key   println(k) } for (v <- map2.values ) {//获得value   println(v) } for (e<- map2 ) {//获得元组对象   println(e._1+":"+e._2) }

七、集

//Set是不重复元素的结合。不保留顺序，默认是以哈希集实现。

//如果想要按照已排序的顺序来访问集中的元素，可以使用SortedSet（已排序数据集），已排序的数据集是用红黑树实现的。

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

7.1Set创建及常用操作

val set = Set(1, 2, 3)//不可变Set import scala.collection.mutable.Set//可变Set val set1 = Set(1,2,3,4) //添加 set1.add(5) set1+=6 val set2 = set1.+(7) //删除 set1-=1 set2.remove(2) //遍历 for (s <- set1 ) { println(s"s = ${s}") }

7.2Set进阶操作

判断集合是否存在某元素 mutableSet.contains(1) 两个集合的交集： & 并集 ++ 差集 &~

八、队列

//队列数据存取符合先进先出策略

8.1队列的创建及其常用操作

import scala.collection.mutable//创建 val q1 = new mutable.Queue[Int] q1+=1//追加元素 q1++=List(2,3,4)//追加List q1.dequeue()//按照入队顺序删除元素 q1.dequeue()//塞入元素 q1.head//返回队列第一个元素 q1.last//返回队列最后一个元素 q1.tail//返回队列除了第一个以外其他元素