Scala筆記整理（二）：Scala數(shù)據(jù)結(jié)構(gòu)—數(shù)組、map與tuple-創(chuàng)新互聯(lián)

[TOC]

成都創(chuàng)新互聯(lián)公司自成立以來，一直致力于為企業(yè)提供從網(wǎng)站策劃、網(wǎng)站設(shè)計(jì)、成都做網(wǎng)站、成都網(wǎng)站設(shè)計(jì)、成都外貿(mào)網(wǎng)站建設(shè)、電子商務(wù)、網(wǎng)站推廣、網(wǎng)站優(yōu)化到為企業(yè)提供個性化軟件開發(fā)等基于互聯(lián)網(wǎng)的全面整合營銷服務(wù)。公司擁有豐富的網(wǎng)站建設(shè)和互聯(lián)網(wǎng)應(yīng)用系統(tǒng)開發(fā)管理經(jīng)驗(yàn)、成熟的應(yīng)用系統(tǒng)解決方案、優(yōu)秀的網(wǎng)站開發(fā)工程師團(tuán)隊(duì)及專業(yè)的網(wǎng)站設(shè)計(jì)師團(tuán)隊(duì)。

數(shù)組

定長數(shù)組

如果你需要一個長度不變的數(shù)組，可以用Scala中的Array。例如：

val numsArray = new Array[Int] (30) //長度為30的整數(shù)數(shù)組，所有元素初始化為0
val stringArrays = new Array [String] (30) //長度為30的字符串?dāng)?shù)組，所有元素初始化為null
val sHello = Array("Hello", "World") //長度為2的Array[String]類型是推斷出來的，已提供初始值就不需要new
sHello(0) = "Hello Tom",使用()而不是[]來訪問元素

在JVM中，Scala的Array以Java數(shù)組方式實(shí)現(xiàn)。示例中的數(shù)組在JVM中的類型為java.lang.String[]。Int、Double或其他與Java中基本類型對應(yīng)的數(shù)組都是基本類型數(shù)組。

舉例來說，Array(2，3，5，6,7，10, 11)在JVM中就是一個int[]。

定長數(shù)組Array-賦值

方法1

val stringArrays = new Array[String] (5) 
stringArrays(0) = “tom”

方法2

val array = Array(1, 2, 3, 4, 5)

方法3

// Array.fill(length)(value)
val array = Array.fill(5)(3.5)

如果fill第二個參數(shù)只寫一個值的話，那么該數(shù)組的所有元素都是該值，但是如果第二個參數(shù)是一個iterator或者random，那么數(shù)組就會被賦值為它們的值。

val array = Array.fill(2)(math.random)

變長數(shù)組ArrayBuffer

1、對于那種長度按需要變化的數(shù)組，Java有ArrayList，C++有vector。Scala中的等效數(shù)據(jù)結(jié)構(gòu)為ArrayBuffer

2、ArrayBuffer是一種mutable的數(shù)據(jù)容器，相對于Array來說，大的區(qū)別就是可以自由增刪元素。當(dāng)ArrayBuffer構(gòu)建完畢后，還可以轉(zhuǎn)換為immutable的Array容器。

import scala.collection.mutable.ArrayBuffer
val buffer = ArrayBuffer[lnt]() // 或者new ArrayBuffer [int]，一個空的數(shù)組緩沖，準(zhǔn)備存放整數(shù)

buffer += 1 // ArrayBuffer (1)，用+=在尾端添加元素

buffer.append(300)

buffer += (1，2，3，5) // ArrayBuffer(1,1,2,3,5)，在尾端添加多個元素，以括號包起來

buffer ++= Array(8, 13, 21) // ArrayBuffer(1, 1, 2, 3, 5, 8,13, 21) //用++=操作符追加任何集合

buffer.insert(2, 150) //在第2元素（索引）后插入150：

buffer.insert(3, 147,21) //在第2元素后插入147,21：

buffer.trimEnd(5) // ArrayBuffer(1, 1, 2)，移除最后5個元素，在數(shù)組緩沖的尾端添加或移除元素是一個高效的操作

buffer.remove(index, n) //移除第index元素后的n個元素

一個完整的例子如下：

import scala.collection.mutable.ArrayBuffer
object _07ArrayBufferDemo {
    def main(args:Array[String]):Unit = {
        val ab = new ArrayBuffer[Int]()

        // 增
        ab += 1
        println(ab)
        ab.append(2)
        println(ab)
        ab += (3, 4, 5)
        println(ab)
        ab ++= Array(6, 7)
        println(ab)
        // insert
        ab.insert(3, -1, -2)    // 可以在某一個位置插入多個元素
        println(ab)

        // 刪
        ab.trimEnd(1)   // 刪除數(shù)組末尾的1個元素
        println(ab)
        ab.remove(3, 1) // 從索引位置3開始刪除，刪除2個元素
        println(ab)

        // 改
        ab(3) = -3
        println(ab)

        // 查
        println("==============================")
        for(i <- ab) {
            println(i)
        }
    }
}

遍歷數(shù)組

val array = Array(1, 2, 3, 4, 5)

1、全遍歷常用遍歷（//如果不需要使用下標(biāo)，用這種方式最簡單了）

for(i <- array) print(i +" ")

2、條件遍歷

for(i <- arrayif i !=2 ) print(i +“ ”) //打印出除2之外的所有整數(shù)的值

3、For推導(dǎo)式

在前面，你看到了如何像Java或C++那樣操作數(shù)組。不過在Scala中，你可以走得更遠(yuǎn)。從一個數(shù)組或數(shù)組緩沖出發(fā)，以某種方式對它進(jìn)行轉(zhuǎn)換是很簡單的。這些轉(zhuǎn)換動作不會修改原始數(shù)組，而是產(chǎn)生一個全新的數(shù)組。像這樣使用for推導(dǎo)式：

val arr = ArrayBuffer(1, 3, 2, -1, -2)
for(i <- 0 until arr.length) yield arr(i) * 2 //將得到Vector(2, 6, 4, -2, -4)
for(i <- array) yield print(i * 2)  // ArrayBuffer[Unit] = ArrayBuffer((), (), (), (), ())

另外一種等價方法（借助于函數(shù)式編程的思想）,某些有著函數(shù)式編程經(jīng)驗(yàn)的程序員傾向于使用filter和map而不是守衛(wèi)和yield，這不過是一種風(fēng)格罷了與for循環(huán)所做的事完全相同。你可以根據(jù)喜好任意選擇：

array.filter( _ > 0).map{ 2 * _}.foreach(println(_)) //生成array中的正數(shù)的兩倍的新集合
array.filter {_ > 0}.map {2 * _}.foreach(println //另一種寫法

常用算法（Scala內(nèi)置函數(shù)）

1、求和與排序

println(Array(1,7,2,9).sum)

2、求大值

println(ArrayBuffer("Mary","had","a","little","lamb").max)

3、排序

升序

val b = ArrayBuffer(1,7,2, 9)
val bSorted = b.sorted //1,2,7,9
b.sortWith(_ < ).foreach(println())

降序

b.sortWith(_ > ).foreach(println())

4、顯示數(shù)組內(nèi)容

println(b.mkString("And")) //分隔符
println(b.mkString("<",",",">"))//<1,7,2,9> //指定前綴、分隔符、后綴

多維數(shù)組

1、定長多維數(shù)組（和Java一樣，多維數(shù)組是通過數(shù)組的數(shù)組來實(shí)現(xiàn)的）

val array = new Array[Array[Int]](5) 
scala> val array = new Array[Array[Int]](5)
array: Array[Array[Int]] = Array(null, null, null, null, null)

2、Scala中的多維數(shù)組同Java中一樣，多維數(shù)組都是數(shù)組的數(shù)組。（推薦使用這種方式）

通過 Array.ofDi[類型](維度1, 維度2, 維度3,….)來聲明多維數(shù)組，如聲明二維數(shù)組；

或者也可以這么定義用ofDim[T](rows,column, height,…)函數(shù)定義，但最多可以定義五維數(shù)組。

scala> val array = Array.ofDim[Double](2,3)
array: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0))

scala> for(a <- array) println(a.toList)
List(0.0, 0.0, 0.0)
List(0.0, 0.0, 0.0)

3、變長多維數(shù)組

val arr1 = new ArrayBuffer[ArrayBuffer[Int]]()

定長數(shù)組和變長數(shù)組的轉(zhuǎn)換

1、定長數(shù)組a轉(zhuǎn)換成變長數(shù)組array：

array = a.toBuffer

2、變長數(shù)組array轉(zhuǎn)換成定長數(shù)組a：

a = array.toArray

與Java互操作（了解）

由于Scala數(shù)組是用java數(shù)組實(shí)現(xiàn)的，你可以在Java和Scala之間來回傳遞?？梢砸雜cala.collection.JavaConversions里的隱式轉(zhuǎn)換方法，這樣在調(diào)用Java方法時，這些對象會被自動包裝成Java列表。

舉例來說，java.lang.ProcessBuilder類有一個以List<String>為參數(shù)的構(gòu)造器。以下是在Scala中調(diào)用它的寫法：

Scala到Java之間的轉(zhuǎn)換工作

def conversionArray: Unit ={
    import scala.collection.JavaConversions.bufferAsJavaList
    import scala.collection.mutable.ArrayBuffer
    val command = ArrayBuffer("ls", "-al", "/home/cay")
    val pb = new ProcessBuilder(command) // Scala到Java的轉(zhuǎn)換
    println(pb.command())

Java到Scala之間的轉(zhuǎn)換工作

def conversionArray: Unit ={
    import scala.collection.JavaConversions.bufferAsJavaList
    import scala.collection.mutable._
    val command = ArrayBuffer("ls", "-al", "/home/cay")
    val pb = new ProcessBuilder(command) // Scala到Java的轉(zhuǎn)換
    println(pb.command())

    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable.Buffer
    val cmd: Buffer[String] = pb.command() // Java到Scala的轉(zhuǎn)換
    println(cmd.head +"\t tail=> " + cmd.tail)
  }

Map

Map創(chuàng)建

1、不可變映射

我們可以這樣構(gòu)造一個映射:

val personAges = Map("Alice"-> 20, "Job"->28, "Garry"->18)

上述代碼構(gòu)造出一個不可變的Map[String，Int]，其值不能被改變。

也可以用此方法創(chuàng)建Map

val personAges = Map(("Alice"-> 20), ("Job"->28),("Garry"->18))

注：->用來創(chuàng)建元組， "sa" -> 1即(" sa ", 1)

2、可變映射

如果你想要一個可變映射，則用

val personAges = scala.collection.mutable.Map("Alice"->20, "Job"->28, "Garry"->18)

如果想從—個空的映射開始，你需要選定一個映射實(shí)現(xiàn)并給出類型參數(shù)：

val personAges1 =new scala.collection.mutable.HashMap [String, Int]

在Scala中，映射是對偶的集合。對偶簡單地說就是兩個值構(gòu)成的組，這兩個值并不一定是同一個類型的，比如("Alice"，10)

獲取Map中的值

方式1

println("Alice=>  " + personAges.get("Alice111"))

類似于Java中的personAges.get("Alice111")，如果映射并不包含請求中使用的鍵，則會拋出異常。要檢查映射中是否有某個指定的鍵，可以用contains方法。

方式2：contains方法

val personAlice = if (personAges.contains ("Alice")) { personAges("Alice") }else 0
println("personAlice===> " + personAlice)

方式3

println("Alice1.else=>  " + personAges.getOrElse("Alice",0))     // 如果映射包含鍵“Alice"，返回對應(yīng)的值；否則，返回0

最后，映射.get(鍵)這樣的調(diào)用返回一個Option對象，要么是Some（鍵對應(yīng)的值），要么是None，Option對象有g(shù)et函數(shù)，直接調(diào)用即可獲取原來Map中key所對應(yīng)的value

更新Map中的值

1、更新可變映射

在可變映射中，你可以更新某個映射的值，或者添加一個新的映射關(guān)系，做法是在=號的左側(cè)使用()：

personAges("Job") = 31 // 更新鍵"Job"對應(yīng)的值
personAges("Garry") = 27 // 增加新的鍵／值對偶到personAges

或者，你也可以用+=操作來添加多個關(guān)系：

personAges += ("Bob"-> 10, "Fred"->7)

要移除某個鍵和對應(yīng)的值，使用-=操作符：

personAges -="Alice"

2、更新不可變映射

雖然不能更新一個不可變的映射，但你可以做一些同樣有用的操作，即獲取一個包含所需要的更新的新映射

val personAges = Map("Alice" -> 20, "Job" -> 28, "Garry" -> 18)
val newPersonAges = personAges + ("Job" -> 10,"Fred" -> 7) // 更新過的新映射
println("newPersonAges=> " + newPersonAges)

同時也可以聲明var變量

var personA = Map("Alice"-> 20, "Job"->28, "Garry"->18)
personA = personA + ("Bob"->10, "Fred"->7)
println("personA=> " +personA)

同時移除不可變映射的值

personA = personA -"Alice"  // 其實(shí)也相當(dāng)于是重新創(chuàng)建了一個新的Map對象
println("remove.personA => "+ personA)

遍歷Map

val personAges = Map ("Alice"-> 20, "Job"->28, "Garry"->18)

for ((k,v) <- personAges) print("k=> " + k +"\t v=> " + v +" ") println()   // 同時獲取key和value

for((k,_)<- personAges) print("k => " + k +" ") println()   // 只獲取key

for(k <- personAges.keySet) print("kkkk=> " + k +" ") println() // 只獲取key

for((_,v) <- personAges) print("v=> " + v +" ") println()   // 只獲取value

for ( v <- personAges.values) print("vvvv=> " + v)  // 只獲取value

scala> person.foreach(me => println(me._1)) // 只獲取key，通過元組的方式
jieling
xiaoqiutian
xpleaf

scala> person.foreach(me => println(me._2)) // 只獲取value，通過元組的方式
22
17
23

要反轉(zhuǎn)一個映射，即交換鍵和值的位置，可以用：

for ( (k,v) <- personAges) yield print(v,k)

scala> for((k,v) <- person) yield print(v, k)
(22,jieling)(17,xiaoqiutian)(23,xpleaf)res177: scala.collection.mutable.Iterable[Unit] = ArrayBuffer((), (), ())

scala> for((k,v) <- person) yield(v, k) // 應(yīng)該是這樣才對，因?yàn)樯厦娴姆绞街禐榭盏?res178: scala.collection.mutable.Map[Int,String] = Map(23 -> xpleaf, 17 -> xiaoqiutian, 22 -> jieling)

Map排序

val personAges = scala.collection.immutable.SortedMap("Alice"->10,"Fred"->7,"Bob"->3,"Cindy"->8)    // 會按照key的字典順序進(jìn)行排序
println("personAges==> " + personAges)  // personAges==> Map(Alice -> 10, Bob -> 3, Cindy -> 8, Fred -> 7)

val months = scala.collection.mutable.LinkedHashMap("January" -> 1,"February" -> 2,"March" -> 3)    // 創(chuàng)建一個順序的Map
months += ("Fourth" -> 4)
println("months=> " + months)   // months=> Map(January -> 1, February -> 2, March -> 3, Fourth -> 4)

tuple

元組定義

映射是鍵／值對偶的集合。對偶是元組( tuple)的最簡單形態(tài)，元組是不同類型的值的聚集。元組的值是通過將單個的值包含在圓括號中構(gòu)成的。例如：

(1, 3.14, "Fred")

是一個元組，類型為：

Tuple3 [Int, Double, java.lang.String]

下面是元組簡單的定義方式：

val t = (1,3.14, "John")
println(t._1 +"\t " + t._2 +"\t " + t._3)

需要注意的是：和數(shù)組或字符串中的位置不同，元組的各組元從1開始，而不是0。你可以把t._2寫為t _2，即用空格而不是句點(diǎn)，但不能寫成t_2

當(dāng)然也可以通過下面的方式進(jìn)行定義：

scala> val tuple = new Tuple4[String, Int, String, Double]("xpleaf", 1, "guangdong", 17000)
tuple: (String, Int, String, Double) = (xpleaf,1,guangdong,17000.0)

獲取元組

val t = (1, 3.14, "John", "Garry")
println(t._1 +"\t " + t._2 +"\t " + t._3 + "\t" + t._4)
val (first,second,third,fourth) = t // 這種賦值方式與Python是一樣的，通過元組賦值給多個值
println(first + "\t" + second + "\t" + third + "\t" + fourth)
println("New York".partition ( _.isUpper))  // (NY,ew ork)

遍歷元素：

t.productIterator.foreach(x => print(x +" "))

另外有需要云服務(wù)器可以了解下創(chuàng)新互聯(lián)scvps.cn，海內(nèi)外云服務(wù)器15元起步，三天無理由+7*72小時售后在線，公司持有idc許可證，提供“云服務(wù)器、裸金屬服務(wù)器、高防服務(wù)器、香港服務(wù)器、美國服務(wù)器、虛擬主機(jī)、免備案服務(wù)器”等云主機(jī)租用服務(wù)以及企業(yè)上云的綜合解決方案，具有“安全穩(wěn)定、簡單易用、服務(wù)可用性高、性價比高”等特點(diǎn)與優(yōu)勢，專為企業(yè)上云打造定制，能夠滿足用戶豐富、多元化的應(yīng)用場景需求。

本文題目：Scala筆記整理（二）：Scala數(shù)據(jù)結(jié)構(gòu)—數(shù)組、map與tuple-創(chuàng)新互聯(lián)
網(wǎng)站地址：http://muchs.cn/article2/djioic.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供自適應(yīng)網(wǎng)站、品牌網(wǎng)站制作、網(wǎng)站維護(hù)、網(wǎng)站收錄、App開發(fā)、網(wǎng)站導(dǎo)航

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源：創(chuàng)新互聯(lián)

猜你還喜歡下面的內(nèi)容

Scala筆記整理（二）：Scala數(shù)據(jù)結(jié)構(gòu)—數(shù)組、map與tuple-創(chuàng)新互聯(lián)