Scala集合

集合

小结

1、set,map是java中也有的集合

2、seq是java中没有的，并且list归属到了seq中，因为这里的list与java不是一个概念

3、例如 1 to 3,就是indexedSeq下的Vector

4、String也属于indexedSeq

5、经典的数据结构,比如Queue（队列）、Stack(栈) 被归属到了LinerSeq

6、Scala 中Map体系中有SortedMap，说明scala的map支持排序

7、indexedSeq和LinearSeq的区别

• indexedSeq 是通过索引来定位于查找元素的，因此速度快，比如，String就是一个索引集合，通过索引即可定位
• LinearSeq 是线性的，即有头尾的概念，这种数据结构一般是通过遍历查找的，一般是体现

集合体系结构

不可变集合

可变集合

数组

定长数组

第一种定义方式

val arr1 = new Array[Int](10)
//使用小括号获取元素值
arr1(7)

第二种定义方式

//如果变量类型不一致，则泛型为 Any
val arr1 = Array(1,"abc",1.1)

//使用索引方式变量
for(index<-0 until arr1.length){
    println(arr1(index))
}

变长数组

定义

import scala.collection.mutable.ArrayBuffer
    var muArr = ArrayBuffer[Int]()
    //追加一个值到变长数组
    muArr += 10
    muArr += 15
    //追加多个值到变长数组
    muArr.append(10,20,30)
    
    //修改
    muArr(1)=30
    
    //删除,根据下标删除
    muArr.remove(0)
    println(muArr)

Array与ArrayBuffer的相互转换

arr1.toBuffer //定长转变长数组
arr2.toArray  //变长转定长

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

二维数组

 //创建二维数组  三行四列
    val arr2 = Array.ofDim[Int](3,4)
    //遍历
    for (item<-arr2){ //取出二维数组的第一维
      for(it <- item) print(it+"\t")
      println()
    }

    //取出指定元素
    println(arr2(1)(1))

    //修改值
    arr2(1)(1) = 100
    
    for (item<-arr2){ //取出二维数组的第一维
      for(it <- item) print(it+"\t")
      println()
    }

ArrayBuffer转Java的List互转

    //scala转java
    var arr3 = ArrayBuffer[String]("1","2","3")
    import scala.collection.JavaConversions.bufferAsJavaList
    var javaArr = new ProcessBuilder(arr3)
    var arrList = javaArr.command()
    println(arrList)
    
    //java转scala
    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable
    var scalaArr:mutable.Buffer[String] = arrList
    scalaArr.append("java")
    println(scalaArr)

Map

map的说明

    //如下代码，使用 var 定义的map集合，在+=操作时，实际上是返回了一个新的Map从
    新赋值给了原来的map 
    var map = Map(1->"aaa",2->"bbb")
    //1763842505
    println(map.hashCode())
    //-1968654784
    map += (2->"qqq")
    println(map.hashCode())
    map +=(3->"mmm")
    //-1311662402
    //可以看出，每次修改后map的地址值都发生了改变

map取值

方式1
map(key)

key存在返回中，key不存在抛异常

方式2
map.contains(key)判断key是否存在

方式3
map.get("A") //返回Some
要想取值，还需再get
map.get("A").get

方式4
//有传入的key则输出对应的值，没有则返回默认值
map.getOrElse("A","默认值")

map删除

    map2.remove(key)
    map2 -= (key)

map遍历

for((k,v)<-map) printf("key=%s,value=%d",k,v)

for(k<-map.keys) println(k)

for(v<-map.values) println(v)

//类型是Tuple2
for(v<-map) println(v+"key="+v._1)

元组

元组也可以理解为一个容器，可以将不同类型的数据放到一起，简单的说就是将无关的数据封装为一个整体，称为元组,元组本身比较灵活，对数据本身没有太大要求

注意：元组最大只能存22个元素

元组的创建，取值，遍历

    //创建
    val aaa=(1,"dsad",1.2,true)
    //取值    
      println(aaa._2)
    //遍历
    for(i<-aaa.productIterator){
      println(i)
    }

List

默认创建的List是不可变的

val list = List(1,2,3,"hello")
var list2 = Nil //返回一个空集合

//取值
println(list(1))

//追加元素(这种追加只是返回一个新的List并没有破坏不可变性)
//通过 :+ 或者 +:给list追加元素（本身集合没有变化）

var list3 = List(1,2,3,"abc")

//list永远在冒号一侧
var list4 = list3 :+ 4 //在list3后面追加一个4
var list5 = 6 +: list3  //在 list3的最前面 追加了一个 6

println(list3) // 没有任何变化
println(list4)

List的符号使用

1、符号 :: 表示向集合中新建集合添加元素
2、运算时，集合对象一定要放在最右边
3、运算规则，从右向左
4、::: 运算符是将集合中的每个元素加入到空集合中去


// :: 使用说明
val list = List(1,2,3,"abc")
var list2 = 4::5::6::7::list::Nil
println(list2)
//输出结果为List(4, 5, 6, List(1, 2, 3, abc))
//1、List()
//2、List(List(1,2,3,"abc"))
//3、List(6,List(1,2,3,"abc"))
//4、List(5,6,List(1,2,3,"abc"))
//5、List(4,5,6,List(1,2,3,"abc"))



//::: 使用说明(将list扁平化后放入空 list中)
val list3 = 4 :: 5 :: 6 :: list ::: Nil
//输出结果 List(4, 5, 6, 1, 2, 3, abc)

ListBuffer

可变的list集合

import scala.connection.mutable.ListBuffer

var listBuf = ListBuffer[Int](1,2,3)

//访问
println(listBuf(1))

//遍历
for(item<-listBuf){
    println(item)
}

//动态增加元素  listBuf 会发生改变
listBuf += 4 //动态追加 单个元素
listBuf.append(5,6,7)  //动态追击多个元素

//把一个集合追加到另一个集合
var listBuf2 = new ListBuffer[Int](7,8)
listBuf ++= listBuf2

val listBuf3 = listBuf2:+5 //将listBuf2后面追加5并返回一个新ListBuffer


//删除
listBuf2.remove(1) //下标