scala数据结构(一)

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

//定义数组：方式一
val arr = new Array[Int](10)    
//定义数组：方式二
val arr = Array(1,2,"scala") //调用apply方法
arr(1)=8 //赋值，索引1的值为8

//添加，生成一个新的数组
arr.+:(4)
//删除，删除值为1的元素（并且只刪除第一个）
val array: Array[Any] = arr.drop(1)
//改，修改索引1的值为6
arr.update(1,6)
arr(1)=8 

//定义变长数组
val ints = new ArrayBuffer[Int]()
val ints = ArrayBuffer[Int](1, 5, 9)

//添加，同一个数组
ints.append(10)
//删除，删除索引为2之后的2个元素
ints.remove(2,2)
//改，同定长数组
ints(1)=20
ints.update(1,20)

1)arr1.toBuffer  //定长数组转可变数组
2)arr2.toArray  //可变数组转定长数组

//定义 arr 是一个二维数组:有三个元素[一维数组]，每个一维数组存放4个值
val arr = Array.ofDim[Double](3,4)
//赋值
arr(1)(1) = 11.11

// Scala集合转成Java集合
val arr = ArrayBuffer("1", "2", "3")
import scala.collection.JavaConverters._  //隐式转换
val javaList: util.List[String] = arr.asJava
println(javaList)    //[1, 2, 3]

//java的List转成scala的ArrayBuffer
val arrList = new util.ArrayList[String]()
arrList.add("test")
//隐式转换
import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable
val scalaArr: mutable.Buffer[String] = arrList

//1. tuple 的类型是 Tuple3
//2. 根据元素个数不同，对应的类型是 Tuple1----Tuple22
//3. Tuple是一个整体，使用迭代器进行遍历
//4. 访问Tuple的元素的方式是 tuple._1 .... tuple._3
//5. 元组是scala推荐使用，在java没有
val tuple = (1, 2, "scala")

val ints = List(1,2,4,5)
//添加
val ints1 = ints :+ 20    //ints集合后面追加
val ints2 = 10 +: ints    //ints集合前面添加
val ints3 = 1 :: ints      //将1作为元素往ints中添加
val ints3 = ints1 :: ints //将ints1中的元素与ints中元素合并为一个集合，:::两边都是集合
//修改，会生成一个新的集合
val intsUpdate = ints .updated(1,15) 
//删除，截取原集合指定索引以及后面的所有元素生成一个新的集合
val intsDrop = ints.drop(2) //List(4, 5)

val buffer = ListBuffer(6,7,8)
//添加
buffer.append(10)
//修改
buffer.update(1,1)
//删除
buffer.remove(3)
println(buffer.mkString(","))  //6,1,10

//创建
//方式一:底层为元组Tuple2类型，输出顺序与声明顺序一致
val map1 = Map("A" -> 10, "B" -> 20, "C" -> 30)
//方式二:对偶元组
val map2 = Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )

//创建: 输出顺序与声明顺序不一致
val map1 = scala.collection.mutable.Map("A" -> 10, "B" -> 20, "C" -> 30)
//添加
//添加并创建一个新的map
val map2 = map1 + ("FFF"->10)
//添加，追加到原有mao中
map1 += ("FFF"->10)
//删除指定key
map1 -= ("B","C")
//修改指定key的值,如果没有改key就为添加
map1.update("A",888)

//key不存在抛异常NoSuchElementException
map(key) 
//map.get(key)得到Option对象，要么是Some要么是None
map.get(key).get
//key存在返回值，不存在返回默认值
map.getOrElse(key,default)

//创建可变set集合
val mutableSet = mutable.Set(1,2,3)
//添加元素的两种方式
mutableSet.add(6)
mutableSet += 7
//删除元素的两种方式
mutableSet -= 2
mutableSet.remove(10)