Scala教程(四)数组进阶实战

最新推荐文章于 2021-03-11 19:42:28 发布

原创最新推荐文章于 2021-03-11 19:42:28 发布 · 2.2k 阅读

2 ·

CC 4.0 BY-SA版权

本文为博主原创文章，未经博主允许不得转载。

Scala教程专栏收录该内容

20 篇文章

订阅专栏

本文深入讲解了Scala中的数组Array，包括定义、声明与赋值、遍历操作。接着探讨了动态数组ArrayBuffer的使用，如添加、删除元素及转换为数组。此外，还介绍了yield关键字在数组操作中的应用，如数组求合、获取最大长度元素和排序，最后阐述了多维数组的定义和数据嵌套技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Scala教程(四)数组进阶实战

1 数组Array

1.1 定义数组

所谓数组，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，然后用编号区分他们的变量的集合，这个名字称为数组名，编号称为下标。

  // 声明Int类型、String类型数组
  val number = new Array[Int](10);                //> number  : Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  val stringArray = new Array[String](10);        //> stringArray  : Array[String] = Array(null, null, null, null, null, 
                                                  //| null,null, null, null, null)

1.2 声明并赋值

  // 声明并赋值
  val strArray = Array("Hello","world")           //> strArray  : Array[String] = Array(Hello, world)
  strArray(0) = "One"
  strArray                                        //> res0: Array[String] = Array(One, world)

1.3 遍历数组

  // for循环便利元素
  for(i <-0 until(stringArray.length)){
  		println(i+":"+stringArray(i))     //> 0:null
                                                  //| 1:null
                                                  //| 2:null
                                                  //| 3:null
                                                  //| 4:null
                                                  //| 5:null
                                                  //| 6:null
                                                  //| 7:null
                                                  //| 8:null
                                                  //| 9:null
   }

2 动态数组ArrayBuffer

2.1 定义动态数组

  // 动态数组
  var buffer = new ArrayBuffer[Int]()             //> buffer  : scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

2.2 末端追加元素

  // 用+=在尾端添加元素
  buffer +=1                                      //> res1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1)

2.3 末端追加多个元素

  // 在尾端添加多个元素
  buffer +=(1,2,3,5)                              //> res2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1,
                                                  //> 2, 3, 5)

2.4 末端追加集合

  // 可以用 ++=操作符追加任何集合
  buffer ++=Array(8,13,21)                        //> res3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2, 
                                                  //|  3, 5,8, 13, 21)

2.5 添加元素

  // 在第2个元素后添加元素6
  buffer.insert(2, 6)
  buffer                                          //> res5: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 
                                                  //  | 6, 2)
  
  
  // 在第2个元素后添加多个元素
  buffer.insert(2, 7,8,9)
  buffer                                          //> res6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 
                                                  //|  7, 8, 9, 6, 2)

2.6 删除元素

	// 删除位置是第2个元素
  buffer.remove(2)                                //> res7: Int = 7
  buffer                                          //> res8: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 8,
                                                  //|  9, 6,2)
  // 从第3个元素开始移除3个元素
  buffer.remove(2, 3)
  buffer                                          //> res9: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2)

2.7 将动态数据转为数组

  // 将数组缓冲转换为Array
  buffer.toArray                                  //> res10: Array[Int] = Array(1, 1, 2)

3 yield关键字及排序

3.1 yield关键字

yield关键字 for循环中的 yield会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。Scala中 for循环是有返回值的。如果被循环的是 Map，返回的就是 Map，被循环的是 List，返回的就是 List，以此类推。

   // 声明元素
   val nums = Array(2,3,5,7,11)                   //> nums  : Array[Int] = Array(2, 3, 5, 7, 11)
   // nums中的元素都*2，并返回新的集合
   var result = for(elem <-nums) yield 2 * elem   //> result  : Array[Int] = Array(4, 6, 10, 14, 22)
   
   // 生成nums集合中值对2取余为0的数，乘2，返回新的集合
   for(elem <-nums if elem %2  == 0) yield elem *2//> res11: Array[Int] = Array(4)
   nums.filter(_ % 2 == 0).map { 2*_}             //> res12: Array[Int] = Array(4)

3.2 Array求合

Array(1,7,2,9).sum                             //> res13: Int = 19

3.3 获取数组中最大长度元素

// 字符串获取长度最大的值
ArrayBuffer("Mary","had","a","little","lamb").max

3.4 排序

   // 排序
   val order = ArrayBuffer(1,7,2,9)               //> order  : scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 
                                                  //| 7, 2, 9)
   val res = order.sorted                         //> res  : scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2,
<pre name="code" class="java">                    //| 7, 9)

3.5 quickSort排序

	// 排序
  val sortArr= Array(1,7,2,9)                     //> sortArr  : Array[Int] = Array(1, 7, 2, 9)
  Sorting.quickSort(sortArr)
  
  // 使用and 连接元素
  sortArr.mkString(" and ")                       //> res15: String = 1 and 2 and 7 and 9
  // 前后以<>填充，中间以，分隔
  sortArr.mkString("<",",",">")                   //> res16: String = <1,2,7,9>

4 多维数组

4.1 定义多维数组

  // 多维数组\三行四列数组
  val multiArr = Array.ofDim[Double](3,4);        //> multiArr  : Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 0.0), Array(0
                                                  //| .0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0))
  multiArr(2)(1)=45
	multiArr                                  //> res17: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0
                                                  //| .0, 0.0, 0.0), Array(0.0, 45.0, 0.0, 0.0))

4.2 数据嵌套

  var triangle = new Array[Array[Int]](10)        //> triangle  : Array[Array[Int]] = Array(null, null, null, null, null,
                                                   //| null,null, null, null, null)
  for(i <-0 until triangle.length)
  	triangle(i) = new Array[Int](i+1)
  	triangle                                  //> res18: Array[Array[Int]] = 
                                                    //| Array(
                                                    //| Array(0),
                                                    //| Array(0, 0) ,
                                                    //| Array(0, 0, 0), 
                                                    //| Array(0, 0, 0, 0), 
                                                    //| Array(0, 0, 0, 0, 0),
                                                    //| Array(0, 0, 0, 0, 0, 0), 
                                                    //| Array(0, 0, 0, 0, 0, 0, 0), 
                                                    //| Array(0, 0, 0, 0, 0, 0, 0, 0), 
                                                    //| Array(0, 0, 0, 0, 0, 0, 0, 0, 0),
                                                    //| Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0))

--以上为数组进阶实战的内容，谢谢大家对我的关注。

——厚积薄发(yuanxw)