scala數據結構(一)

1、概述

1，特色

1)Scala同時支持不可變集合和可變集合 
2)兩個主要的包：
    不可變集合：scala.collection.immutable
    可變集合：  scala.collection.mutable
3)Scala默認採用不可變集合，對於幾乎全部的集合類，Scala都同時提供了可變(mutable)和不可變(immutable)的版本
4)Scala的集合有三大類：序列Seq、集Set、映射Map，全部的集合都擴展自Iterable特質，在Scala中集合有可變（mutable）和不可變（immutable）兩種類型。 

2，不可變集合繼承一覽圖

           

 3，可變集合繼承一覽圖

           

 

2、數組

1，可變和不可變:

　　Array ===> ArrayBuffer

2，定義不可變數據數組方式

//定義數組：方式一
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 

3，定義變長數組

//定義變長數組
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)

4，定長數組與變長數組轉換

1)arr1.toBuffer  //定長數組轉可變數組
2)arr2.toArray  //可變數組轉定長數組

5，多維數組

//定義 arr 是一個二維數組:有三個元素[一維數組]，每一個一維數組存放4個值
val arr = Array.ofDim[Double](3,4)
//賦值
arr(1)(1) = 11.11

6，Scala數組與Java的List互轉

// 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

 

3、元組

1，簡介

　　元組也是能夠理解爲一個容器，能夠存放各類相同或不一樣類型的數據。

　　說的簡單點，就是將多個無關的數據封裝爲一個總體，稱爲元組, 最大的特色靈活,對數據沒有過多的約束。 //需求-> 高效率 

2，建立

//1. tuple 的類型是 Tuple3
//2. 根據元素個數不一樣，對應的類型是 Tuple1----Tuple22
//3. Tuple是一個總體，使用迭代器進行遍歷
//4. 訪問Tuple的元素的方式是 tuple._1 .... tuple._3
//5. 元組是scala推薦使用，在java沒有
val tuple = (1, 2, "scala")

 

4、集合

1，定義:

　　Scala的List能夠直接存放數據，就是一個object，默認狀況下Scala的List是不可變的，List屬於序列Seq。 

　　不可變、可變: List ===> ListBuffer

2，建立:

　　val ints:List[Int] = List(1,2,3) //建立

　　List默認採用不可變方式在immutable包下不用引包，List中能夠聽任何類型數據List[Any]，空集合能夠直接使用Nil對象

3，List經常使用操做

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)

4，ListBuffer經常使用操做

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

 

5、Map

1，定義

　　Scala中的Map 和Java相似，也是一個散列表，它存儲的內容也是鍵值對(key-value)映射，Scala中不可變的Map是有序的，可變的Map是無序的。

　　不可變、可變: scala.collection.immutable.Map ===>  scala.collection.mutable.Map

2，不可變immutable.Map

//建立
//方式一:底層爲元組Tuple2類型，輸出順序與聲明順序一致
val map1 = Map("A" -> 10, "B" -> 20, "C" -> 30)
//方式二:對偶元組
val map2 = Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )

3，可變mutable.Map

//建立: 輸出順序與聲明順序不一致
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)

4，Map取值

//key不存在拋異常NoSuchElementException
map(key) 
//map.get(key)獲得Option對象，要麼是Some要麼是None
map.get(key).get
//key存在返回值，不存在返回默認值
map.getOrElse(key,default)

 

6、Set

1，可變不可變

　　immutable.Set  ===> mutable.Set

2，可變set集合操做

 

//建立可變set集合
val mutableSet = mutable.Set(1,2,3)
//添加元素的兩種方式
mutableSet.add(6)
mutableSet += 7
//刪除元素的兩種方式
mutableSet -= 2
mutableSet.remove(10)