Scala中的集合類型

時間 2019-11-13

標籤 scala 集合類型欄目 Scala 简体版

原文原文鏈接

Scala中的集合類型

Scala提供了一套很好的集合實現，提供了一些集合類型的抽象。Scala集合分爲不可變（immutable）的集合和可變（mutable）的集合。es6

scala的集合類型（collection）涵蓋了以下類型：數組

數組（Array）、鏈表（List）、Set、Map、Tuple。數據結構

一、數組Array

對於數組的使用，若想調用數組提供的方法，咱們須要使用 import Array._引入包。app

1．數組的聲明

1.數組Array分爲定長和變長兩種數組。後期經常使用的類型是定長（Array）。函數

2.Scala的泛型的聲明使用[]來定義的，不一樣於Java的<>。oop

3.Scala經過下標操做Array，使用()來操做，不一樣於Java的[index]。ui

定長數組：scala.collection.immutable.Array，一旦聲明以後長度不可變。es5

變長數組：scala.collection.mutable.ArrayBuffer，動態數組。spa

範例：.net

//建立一個定長數組，一旦聲明，長度不可變
  val a1=Array(1,2,3,4)
  //建立一個變長數組
  val a2=ArrayBuffer(1,2,3)
  //建立數組，並指定範圍
  val a3=Array[Int](1,2,3)
  //經過下標操做數組
  a1(1)
  //> res0: Int = 2
  //建立一個長度爲3的定長數組
  //注意，須要指定泛型類型。
  val a4=new Array[Int](3)

2．賦值和取值

1>賦值

賦值方式一：用for循環爲數組var1賦值。

賦值方式二：爲變長數組賦值，注意：變長數組提供了append方法用於賦值，而且隱式的改變數組長度。

示例：

//賦值
  for(i<-0 to a4.length-1)a4(i)=i
  a4
  //> res1: Array[Int] = Array(0, 1, 2)
  val v5=new ArrayBuffer[Int](3)
  //變長數組能夠經過append賦值
  for(i<-0 to 10)v5.append(i)

2>取值

取值方式一：根據數組下標取值。

取值方式二：利用for循環取值。

取值方式三：用高階函數 foreach。

示例：

//經過下標操做數組
  a1(1);a1(2);a1(0)
  //利用for循環獲取值
  for (i <- a1) println(i)
  a1.foreach{x=>println(x)}

3．函數

1>concat

用於將多個數組的結果合併在一塊兒，import Array._。

合併時，數組的類型要一致，要麼全是定長的，要麼全是變長的，定長和變長之間不能進行合併。

示例：

val v6 = Array(1, 2, 3)
  val v7 = Array(4, 5, 6)
  //合併多個定長數組
  val v8 = Array.concat(v6, v7)
  //合併多個變長數組
  val v9 = ArrayBuffer.concat(v5, a2)

2>range

建立區間數組，含頭不含尾。

示例：

//建立區間數組
  val v10 = Array.range(0, 5)
  //建立區間數組，並指定步長爲2
  val v11 = Array.range(0, 5, 2)
  val v12 = ArrayBuffer.range(0, 5)

3>iterate

返回一個包含一個函數的重複應用到初始值的數組。

示例：

//iterate將匿名函數應用到初始值，並返回指定長度的數組
  val v13 = Array.iterate(1, 5)(x => x + 1)
  val v131 = Array.iterate(1, 5)(_ * 2)

4>tabulate

返回指定長度數組，每一個數組元素爲指定函數的返回值，默認從0開始。

示例：

//tabulate是將匿名函數應用到數組下標的函數，並返回指定長度的數組。
  val v14 = Array.tabulate(5)(_ + 1)
  val v141 = Array.tabulate(5)(_ * 2)

5>sum

求和，對數組中的元素進行求和。

示例：

val v6 = Array(1, 2, 3)
//求和
v6.sum

6>min

最小值。

示例：

val v6 = Array(1, 2, 3)
  //最小值
  v6.min

7>max

最大值。

示例：

val v6 = Array(1, 2, 3)
  //最大值
  v6.max

8>quickSort

排序，將數組元素排序。

調用格式：

scala.util.Sorting.quickSort(Array)

示例：

val v20=Array(1,4,3,2,6)
	scala.util.Sorting.quickSort(v20)
	v20

9>drop

刪除。

示例：

//去除頭部n個元素,並返回去除後的數組
  v6.drop(1)
  //去除尾部n個元素,並返回去除後的數組
  v6.dropRight(1)

10>take

取出頭n個元素，並返回取出的元素數組。

示例：

//取出頭n個元素，並返回取出的元素數組。
  v6.take(1)
  //取出末尾n個元素，並返回取出的元素數組。
  v6.takeRight(1)

11>foreach

循環遍歷。

示例：

v6.foreach { x => println(x) }
  v6.foreach { println(_) }

12>map

改變集合類型中，元素的形式或數據，返回一個新的集合。此方法不會改變集合中元素的個數，只是改變了數值和形式。

示例：

val v15 = v6.map { x => x + 1 }
  v6.map { _ * 1.0 }
  v6.map { x => x.toDouble }

  val v17 = Array("hello world", "hello hadoop")
  v17.map { _.split(" ") }

二、List鏈表

1．聲明列表

底層用鏈表實現的數據結構。

定長列表：scala.collection.immutable.List，一旦聲明以後長度不可變。

變長列表：scala.collection.mutable.ListBuffer，變長列表。

示例：

//聲明一個定長List
  val l1=List(1,2,3,4)
  //聲明一個變長List
  val l2=ListBuffer(1,2,3)
  val l3=List[Int](1,2,3)
  val l4=1::2::3::Nil
  //聲明一個定長空List
  val l5=List[Nothing]()

2．取值

下標獲取。

示例：

//經過下標取值
l9(0)
//> res9: Int = 4

3．函數

1>head

返回頭元素。

示例：

//返回頭元素
l1.head
//> res0: Int = 1

2>tail

去除頭元素，並返回剩餘元素的List，等價於drop(1)。

示例：

l1.tail
//> res1: List[Int] = List(2, 3, 4)
l1.drop(1)
//> res2: List[Int] = List(2, 3, 4)

3>isEmpty

判斷是否爲空。

示例：

l1.isEmpty
//> res3: Boolean = false
l5.isEmpty
//> res4: Boolean = true

4>合併

①:::

拼接List,List類型須要一致。

示例：

l1:::l3
//> res5: List[Int] = List(1, 2, 3, 4, 1, 2, 3)

②concat

示例：

List.concat(l1,l3)
//> res6: List[Int] = List(1, 2, 3, 4, 1, 2, 3)

5>fill

以指定數據填充，並返回新的List。

示例：

val l6=List.fill(5)("a")
//> l6  : List[String] = List(a, a, a, a, a)

6>tabulate

建立n大小的數組，數組元素的下標按照傳入的規則改變以後爲當前下標的元素。

示例：

val l7=List.tabulate(5)(_*2)
//> l7  : List[Int] = List(0, 2, 4, 6, 8)

7>reverse

反轉，並返回一個新的List

val l8=l1.reverse
//> l8  : List[Int] = List(4, 3, 2, 1)

8>添加

①+:

從左側添加元素，並返回新的List。

示例：

val l9=List(4,5,6)
//> l9  : List[Int] = List(4, 5, 6)
//從左側添加元素，並返回新的List
3+:l9
//> res7: List[Int] = List(3, 4, 5, 6)

②:+

從右側添加元素，並返回新的List。

示例：

l9:+7
//> res8: List[Int] = List(4, 5, 6, 7)

9>contains

查看是否包含某個元素。

示例：

l9.contains(4)
//> res10: Boolean = true

10>copyToArray

拷貝元素到Array中。

示例：

var a1=new Array[Int](3)
//> a1  : Array[Int] = Array(0, 0, 0)
l9.copyToArray(a1, 0, l9.length)
a1
//> res11: Array[Int] = Array(4, 5, 6)

11>類型轉換

①toArray

轉爲數組類型。

示例：

l9.toArray
//> res12: Array[Int] = Array(4, 5, 6)

②toList

轉變爲鏈表。

示例：

a1.toList
//> res13: List[Int] = List(4, 5, 6)

12>distinct

去重，並返回一個新的List。

示例：

val l10=List(1,1,1,2,2,2,3,4,4,4)
l10.distinct
//> res14: List[Int] = List(1, 2, 3, 4)

13>exists

經過匿名函數判斷元素是否存在。

示例：

l10.exists { x => x%2==0 }
//> res15: Boolean = true
l10.exists {	_%2==0 }
//> res16: Boolean = true
val l11=List(1,2,3,4,5,6)
//> l11  : List[Int] = List(1, 2, 3, 4, 5, 6)
l11.exists { x => x%2==0&&x>4 }
//> res17: Boolean = true

14>filter

過濾。

示例：

l11.filter { x => x>3 }
//> res18: List[Int] = List(4, 5, 6)
l11.filter { _>3 }
//> res19: List[Int] = List(4, 5, 6)
l11.filter { x => x>3&&x%2==0 }
//> res20: List[Int] = List(4, 6)

15>indexOf

查找指定元素第一次出現的位置，並返回位置。

示例：

l10.indexOf(1, 0)
//> res21: Int = 0
l10.indexOf(2, 3)
//> res22: Int = 3
val l12=List(1,2,3,1,2,3)
//> l12  : List[Int] = List(1, 2, 3, 1, 2, 3)
l12.indexOf(1, 1)
//> res23: Int = 3

16>intersect

獲取交集，並返回值的List。

示例：

val l13=List(1,2,3)
val l14=List(3,4,5)
l13.intersect(l14)
//> res24: List[Int] = List(3)
//經過類型轉換去使用API
val a2=Array(1,2,3)
val a3=Array(2,3,4)
a2.toList.intersect(a3.toList).toArray
//> res25: Array[Int] = Array(2, 3)

17>last

獲取最後一個元素。

示例：

l13.head
//> res26: Int = 1
l13.last
//> res27: Int = 3

18>length

數組長度。

示例：

l13.length
//> res28: Int = 3

19>map

l13.map { x => x*2 }
//> res29: List[Int] = List(2, 4, 6)
l13.map { _*2 }
//> res30: List[Int] = List(2, 4, 6)

20>mkString

將集合中元素以指定分隔符返回，造成字符串。

示例：

l13.mkString
//> res31: String = 123
l13.mkString(",")
//> res32: String = 1,2,3

21>排序

①sorted

升序排序，並返回一個List。

示例：

val l15=List(2,1,4,7,6)
l15.sorted
//> res33: List[Int] = List(1, 2, 4, 6, 7)
//降序
l15.sorted.reverse
//> res34: List[Int] = List(7, 6, 4, 2, 1)

②sortWith

//降序
l15.sortWith{(a,b)=>a>b}
//> res35: List[Int] = List(7, 6, 4, 2, 1)
l15.sortWith{_>_}
//> res36: List[Int] = List(7, 6, 4, 2, 1)
//升序
l15.sortWith{(a,b)=>a<b}
//> res37: List[Int] = List(1, 2, 4, 6, 7)

③sortBy

//重點掌握此排序
l15.sortBy{x=>x}
//> res38: List[Int] = List(1, 2, 4, 6, 7)
l15.sortBy{+_}
//> res39: List[Int] = List(1, 2, 4, 6, 7)
l15.sortBy{x=> -x}
//> res40: List[Int] = List(7, 6, 4, 2, 1)
  l15.sortBy{-_}
//> res41: List[Int] = List(7, 6, 4, 2, 1)

22>reduceLeft

l15.reduceLeft(_+_)

三、Set

Scala Set(集合)是沒有重複的對象集合，全部的元素都是惟一的。Scala 集合分爲可變的和不可變的集合。

默認狀況下，Scala 使用的是不可變集合，若是你想使用可變集合，須要引用 scala.collection.mutable.Set 包。默認引用 scala.collection.immutable.Set。

1．聲明Set

//聲明定長Set
val s1=Set(1,2,3)
//聲明變長Set
val s2=scala.collection.mutable.Set(2,3,4)
val s3=Set(1,1,1,2,2,2)
//> s3  : scala.collection.immutable.Set[Int] = Set(1, 2)

2．函數

1>獲取交集

//取交集
  val s4=Set(1,2,3)
  val s5=Set(3,4,5)
  s4.&(s5)
//> res0: scala.collection.immutable.Set[Int] = Set(3)
  s4&s5
//> res1: scala.collection.immutable.Set[Int] = Set(3)

2>獲取差集

①&~

//取差集
s4 &~ s5
//> res2: scala.collection.immutable.Set[Int] = Set(1, 2)
s5 &~ s4
//> res4: scala.collection.immutable.Set[Int] = Set(4, 5)

②diff

s4.diff(s5)
//> res3: scala.collection.immutable.Set[Int] = Set(1, 2)
  s5.diff(s4)
//> res5: scala.collection.immutable.Set[Int] = Set(4, 5)

3>++

合併。

//合併
 	s4 ++ s5
//> res6: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

4>count

返回知足匿名函數的元素個數。

s4.count { x => x>1 }
//> res7: Int = 2
  s4.count(_>1)
//> res8: Int = 2

5>splitAt

切割成兩個set，其中一個set知足指定個數。返回的數據類型是Tuple（元祖）。

val s6=Set(1,2,3,4,5,6,7)
//> s6  : scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)
  s6.splitAt(4)

四、Map映射

Map(映射)是一種可迭代的鍵值對（key/value）結構。全部的值均可以經過鍵來獲取。

Map 中的鍵都是惟一的。Map 也叫哈希表（Hash tables）。

Map有兩種類型，可變與不可變，區別在於可變對象能夠修改它，而不可變對象不能夠。

默認狀況下Scala使用不可變Map。若是你須要使用可變集合，你須要顯式的引入 import scala.collection.mutable.Map 類

在Scala中你能夠同時使用可變與不可變 Map，不可變的直接使用 Map，可變的使用 mutable.Map。

1．聲明Map

//聲明定長map
  val m1=Map("k1"->1,"k2"->2,"k3"->3)
  //聲明變長map
  val m2=scala.collection.mutable.Map("k1"->1,"k2"->2,"k3"->3)

2．函數

1>+=

+=添加元素，只能用於變長map。

m2+=("k4"->4)
//> res0: Demo06.m2.type = Map(k2 -> 2, k4 -> 4, k1 -> 1, k3 -> 3)

2>keys

獲取全部key 。

val m3=Map("rose"->23,"tom"->25,"jim"->30)
  //獲取全部key
  m3.keys
//> res1: Iterable[String] = Set(rose, tom, jim)

  //獲取全部的key並返回一個迭代器
  m3.keys.foreach(x=>println(x))

3>values

獲取全部的value。

m3.values
  //> res2: Iterable[Int] = MapLike(23, 25, 30)
  //獲取全部的value，並返回一個迭代器
  m3.values.foreach(println(_))

4>++

合併。

val m4=Map[String,Int]("k1"->1,"k2"->2)
  val m5=Map[String,Int]("k3"->3,"k4"->4)
  m4 ++ m5
//> res3: scala.collection.immutable.Map[String,Int] = Map(k1 -> 1, k2 -> 2, k3 -> 3, k4 -> 4)

5>contains

是否包含指定key。

m4.contains("k1")
//> res4: Boolean = true

6>get

獲取指定key的值,返回some類型

m4.get("k1")
//> res5: Option[Int] = Some(1)
  //操做some類型，須要經過getOrElse來取值
  //若是查找一個不存在的key，會返回指定的默認值，以免報錯
  m4.get("k3").getOrElse(0)
//> res6: Int = 0

7>apply

apply直接經過key取值，若是key不存在，則報錯。

m4.apply("k1")
//> res7: Int = 1

8>clear

清空map。只有變長map有此方法。

  m2.clear()

9>filter

過濾。

val m6=Map(1->"tom",2->"rose",3->"jim",4->"jary")
  m6.filter(x=>x._1>2)
//> res8: scala.collection.immutable.Map[Int,String] = Map(3 -> jim, 4 -> jary)
  m6.filter{case(k,v)=>k>2}
//> res9: scala.collection.immutable.Map[Int,String] = Map(3 -> jim, 4 -> jary)

10>size

返回元素個數

  m6.size

五、Tuple元組

與列表同樣，元組也是不可變的，但與列表不一樣的是元組能夠包含不一樣類型的元素。元組的值是經過將單個的值包含在圓括號中構成的。

1．聲明Tuple

用()來聲明元組。元組是最靈活的一種數據結構。

//聲明元組
  val t1=(1,2,3,4,5)
  val t2=(1,"hello",List(1,2,3),Array(2,3))
  val t3=((1,2),("rose",23),(3,4))
  val l1=List(1,2,(4,5))

2．取值

元組的取值用._index （index的取值從1開始）

示例：

//元組取值，是從1開始的。
  t1._1
//> res0: Int = 1
  t1._3
//> res1: Int = 3
  t3._2._1
//> res2: String = rose

應用：

val a1=Array("hello","world","hello","hadoop")
  //要求，將a1裏的元素改成：Array(("hello",1),("world",1)……)
  val a2=a1.map { x => (x,1) }
  //> a2  : Array[(String, Int)] = Array((hello,1), (world,1), (hello,1), (hadoop, 1))
  //要求：操做a2還原回去
  a2.map(x=>x._1)

上一篇：Scala的函數

下一篇：Scala的面向對象