Scala進階之路-高級數據類型之數組的使用

　　　　　　　　　　　　　Scala進階之路-高級數據類型之數組的使用

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑

版權聲明：原創作品，謝絕轉載！否則將追究法律責任。

 

 

 

一.數組的初始化方式

1>.長度不可變數組Array

　　注意：顧名思義，長度不可變數組指的是數組的長度不可變，但是數組的內容是可以變換的！

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object MyArray {

    def main(args: Array[String]): Unit = {
        /**
          * 定義一個固定長度的數組,長度可變,內容可變（因為變量我們是用var關鍵字修飾）。
          * [String] :表示的是數組的泛型，即該數組只能接收String類型的數據喲
          * (3) : 這個數字3表示的是arr數組的長度
          */
        var arr :Array[String] = new Array[String](3)
        /**
          * 當然，上面的那種方式是寫了arr變量的數據類型為一個數組，我們不懈也是可以的，因為Scala解釋器會默認幫我們隱式轉換的喲
          */
        var arr2 = new Array[String](3)

        /**
          * 定義定長數組, 長度不可變, 內容可變（因為變量是由val關鍵字修飾）
          */
        val arr3 = Array (1,2,3)    //我們可以直接初始化數組的內容，這個時候就不需要new關鍵字啦！

        /**
          * 接下來我們分別修改我們定義的3個數組中的內容，具體操作如下
          */
        arr(0) = "yinzhengjie"
        arr2(1) = "尹正傑"
        arr3(2) = 100

        //我們直接調用數組的toBuffer方法，因為該方法重寫了toString方法。
        println(arr.toBuffer.toString())
        println(arr2.toBuffer.toString())
        println(arr3.toBuffer.toString())
    }
}



/*
以上代碼執行結果如下 :
ArrayBuffer(yinzhengjie, null, null)
ArrayBuffer(null, 尹正傑, null)
ArrayBuffer(1, 2, 100)
 */

 2>.長度可變數組（ArrayBuffer）

　　顧名思義，長度可變數組指的是數組的長度是可以變化的，其內容也是可以變化的喲！

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

/**
  *         有可變（mutable包下存放）和不可變（immutable包下存放）兩種類型，immutable 類型的集合初始化后就不能改變了,默認情況下使用的是
  * 不可變數組，如果我們想要使用它可變類型數組類型ArrayBuffer，那么就需要導入這個包啦！
  */
import scala.collection.mutable.ArrayBuffer


object ArrayBuffDemo {

    def main(args: Array[String]): Unit = {
        //定義一個可變的數組
        val arr = ArrayBuffer[String]("yinzhengjie","尹正傑","Scala")
        //我們遍歷定義的數組
        arr.foreach(i => print(i + "\t"))
        println("\n==========我是分割線===========")
        //我們往可變的數組內容中添加數據
        arr+=("Shell","Python","Java","Golang")
        //我們再次遍歷定義的數組
        arr.foreach(i => print(i + "\t"))
    }
}

/*
以上代碼執行結果如下:
yinzhengjie    尹正傑    Scala
==========我是分割線===========
yinzhengjie    尹正傑    Scala    Shell    Python    Java    Golang
 */

 

二.數組的常用方法

1>.映射方法（map）

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object MyArray {

    def main(args: Array[String]): Unit = {
        /**
          * 注意，如果直接給數組初始化的話，可以不用寫new,直接使用數組的apply方法進行賦值操作，當然你可以省略".apply"這個方法。
          */
        val arr = Array.apply[String]("yinzhengjie","尹正傑","Scala","Python","Golang")

        /**
          * 定義映射關系f1，功能是將傳入的String類型的參數加上后綴;而arr數組經過map映射操作之后會返回一個新的數組。
          */
        var f1 = (x:String) => x + "_2018"
        val arr2 = arr.map(f1)

        /**
          * 當然，上面的這種寫法也可以簡寫，如下:
          */
        val arr3 = arr.map((x:String) => x + "_2018")   //我們可以把上面的f1映射名稱去掉，直接傳入一個匿名函數
        val arr4 = arr.map(x => x + "_2018")            //這里的x的變量Scala會自動識別其數據類型
        var arr5 = arr.map(_ + "_2018")                 //注意這個下划線("_")其實是表示的是arr數組中的每一個元素喲

        println(arr.toBuffer.toString())
        println(arr2.toBuffer.toString())
        println(arr3.toBuffer.toString())
        println(arr4.toBuffer.toString())
        println(arr5.toBuffer.toString())
    }
}



/*
以上代碼執行結果如下 :
ArrayBuffer(yinzhengjie, 尹正傑, Scala, Python, Golang)
ArrayBuffer(yinzhengjie_2018, 尹正傑_2018, Scala_2018, Python_2018, Golang_2018)
ArrayBuffer(yinzhengjie_2018, 尹正傑_2018, Scala_2018, Python_2018, Golang_2018)
ArrayBuffer(yinzhengjie_2018, 尹正傑_2018, Scala_2018, Python_2018, Golang_2018)
ArrayBuffer(yinzhengjie_2018, 尹正傑_2018, Scala_2018, Python_2018, Golang_2018)
 */

2>.扁平化操作（flatten與flatMap）

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object MyArray {

    def main(args: Array[String]): Unit = {
        /**
          * 定義一個數組，里面存放兩個字符串
          */
        val arr = Array.apply[String]("yinzhengjie,尹正傑","Python,Shell,Golang,Java,Scala")
        /**
          *     我們使用映射方法map將里面的每個元素用逗號(",")進行切割,最終會將arr里面的兩個字符串變成了2個數組，
          * 而這兩個數組中存放的是每個字符串按照“,”切割后的數組。
          */
        val arr2 = arr.map(_.split(","))

        /**
          * 接下來我們調用扁平化操作，使用flatten方法將兩個arr2里面的兩個數組去掉，直接把arr2里面嵌套的數組的每一個元素取出來。
          */
        val arr3 = arr2.flatten


        /**
          * 如果你覺得由arr轉換到arr3步驟過於繁瑣，你可以這樣寫，“arr3 = arr.map(_.split(",")).flatten”，當然你也可以使用flatMap方法喲！
          */
        val arr4 = arr.flatMap(_.split(","))

        /**
          * 我們可以查看arr,arr2以及arr3的數組的內容以及長度。
          */
        println(arr.toBuffer.toString(),arr.length)
        println(arr2(0).toBuffer.toString(),arr2(1).toBuffer.toString(),arr2.length)
        println(arr3.toBuffer.toString(),arr3.length)
        println(arr4.toBuffer.toString(),arr4.length)
    }
}


/*
以上代碼執行結果如下 :
(ArrayBuffer(yinzhengjie,尹正傑, Python,Shell,Golang,Java,Scala),2)
(ArrayBuffer(yinzhengjie, 尹正傑),ArrayBuffer(Python, Shell, Golang, Java, Scala),2)
(ArrayBuffer(yinzhengjie, 尹正傑, Python, Shell, Golang, Java, Scala),7)
(ArrayBuffer(yinzhengjie, 尹正傑, Python, Shell, Golang, Java, Scala),7)
 */

3>.遍歷方法（foreach）

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object MyArray {

    def main(args: Array[String]): Unit = {
        /**
          * 定義一個數組，里面存放兩個字符串
          */
        val arr = Array.apply[String]("yinzhengjie,尹正傑","Python,Shell,Golang,Java,Scala")

        /**
          * 使用flatMap將arr數組中的數據扁平化
          */
        val arr2 = arr.flatMap(_.split(","))

        /**
          * 這個時候我們就可以用foreach方法遍歷arr2數組中里面的每一個元素，foreach方法需要傳遞一個返回空值的方法。首先我們會想到打印的方法
          */
        arr2.foreach(x => print(x + "\t"))
        arr2.foreach(println)


    }
}




/*
以上代碼執行結果如下 :
yinzhengjie    尹正傑    Python    Shell    Golang    Java    Scala    yinzhengjie
尹正傑
Python
Shell
Golang
Java
Scala
 */

4>.單詞統計案例（wold count）

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object MyArray {

    def main(args: Array[String]): Unit = {
        /**
          * 定義一個數組，里面存放兩個字符串
          */
        val arr = Array.apply[String]("yinzhengjie,尹正傑,yinzhengjie","Python,Shell,Golang,Java,Scala,yinzhengjie")


        /**
          * flatMap:
          *     進行扁平化操作，通過flatMap(_.split(","))可以將2個字符串按照空格切割成單詞
          * groupBy:
          *     自然是排序操作了，即按照每個傳進來的參數進行分組，即將相同的單詞包裝成一個數組
          * mapValues:
          *     傳遞的參數是一個數組，我們將傳入的數組的長度取出
          */
        val arr2 = arr.flatMap(_.split(",")).groupBy(x => x).mapValues(x => x.length)
        arr2.foreach(x => print(x + "\t"))
        println("\n=======我是分割線=======")
        /**
          * 排序功能：
          *     又有map默認是無序的，因此我們可以將其轉換成數組，然后在進行排序操作
          * toList:
          *     將arr3這個map類型轉換成一個list類型
          * sortBy:
          *     排序操作，注意，x._1，其中x表示的是arr3轉換成的list對象，而“_1”表示的是每一個元素的第一個參數，因此排序是按照字母來排序的喲，如果你想按照長度來排序的話把1改成2就好
          */
        val arr3 = arr2.toList.sortBy(x=>x._1)
        arr3.foreach(x => print(x + "\t"))
    }
}




/*
以上代碼執行結果如下 :
(Shell,1)    (Scala,1)    (yinzhengjie,3)    (Python,1)    (尹正傑,1)    (Golang,1)    (Java,1)
=======我是分割線=======
(Golang,1)    (Java,1)    (Python,1)    (Scala,1)    (Shell,1)    (yinzhengjie,3)    (尹正傑,1)    
 */

 　　如果想要按照數字進行倒序排列的話，我們可以看下面的一段代碼也是world count單詞統計：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/
package cn.org.yinzhengjie.function

object WordCount {
    def main(args: Array[String]): Unit = {
        val words: Array[String] = Array("hello yinzhengjie hello yinzhengjie Python", "hello Python hello yinzhengjie Scala Golang")
        // words 數組中的每個元素按照空格(" ")進行切分。
        val wordSplit: Array[Array[String]] = words.map((x: String) => x.split(" "))
        // 將數組中的Array扁平化
        val fltWords: Array[String] = wordSplit.flatten
        // 分組操作 : hello -> Array(hello, hello, hello, hello)
        val mapWords: Map[String, Array[String]] = fltWords.groupBy((wd: String) => wd)
        //生成map對象，得到類型這樣的數據 : (hello, 4), (yinzhengjie,1).....
        val wrdResult: Map[String, Int] = mapWords.map(wdKV => (wdKV._1, wdKV._2.length))
        // Map不支持排序，需要將map轉換成List， 調用sortBy方法按照單詞數量降序排序(默認是升序，我們在前面加一個負號就可以實現倒序排列)
        val sortResult: List[(String, Int)] = wrdResult.toList.sortBy(t => - t._2)
        //遍歷每一個元素
        sortResult.foreach(i => println(i))
    }
}



/*
以上代碼實現結果如下 :
(hello,4)
(yinzhengjie,3)
(Python,2)
(Scala,1)
(Golang,1)
 */