scala資料結構(一)

MXC肖某某發表於2020-07-02
資料結構

一、概述

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，不可變集合繼承一覽圖

           scala資料結構(一)

 3，可變集合繼承一覽圖

           scala資料結構(一)

 

二、陣列

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

 

三、元組

1，簡介

　　元組也是可以理解為一個容器，可以存放各種相同或不同型別的資料。

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

2，建立

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

 

四、集合

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

 

五、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)

 

六、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)

 

相關文章