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:y1053419035@qq.com
 */
 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:y1053419035@qq.com
 */
 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:y1053419035@qq.com
 */
 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:y1053419035@qq.com
 */
 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:y1053419035@qq.com
 */
 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:y1053419035@qq.com
 */
 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:y1053419035@qq.com
 */
 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)
  */