斯卡拉 |数组

数组是scala中一种特殊的集合。它是一个固定大小的数据结构，用于存储相同数据类型的元素。数组第一个元素的索引为零，最后一个元素是元素总数减一。它是可变值的集合。它对应于JavaJava（就功能而言）。

一些要点：

• Scala 数组可以是通用的。这意味着我们可以有一个 Array[T]，其中 T 是类型参数或抽象类型。
• Scala 数组与 Scala 序列兼容——我们可以在需要 Seq[T] 的地方传递一个 Array[T]。
• Scala 数组还支持所有序列操作。

下图显示了如何将值按顺序存储在数组中：

Scala 支持一维数组和多维数组。单维数组是只有一行和 n 列的数组，而二维数组实际上是维数 (n * m) 的矩阵。

一维数组

在这个数组中只包含一行用于存储值。该数组的所有值从 0 到数组大小连续存储。
句法：

var arrayname = new Array[datatype](size)

在这里，datatype 指定分配的数据类型，size 指定数组中元素的数量，var 是链接到数组的数组变量的名称。
例子：

// Scala program to creating an array 
// of the string as week days, store  
// day values in the weekdays, 
// and prints each value. 
object GFG
{
    // Main method
    def main(args: Array[String]) 
    {
        // allocating memory of 1D Array of string. 
        var days = Array("Sunday", "Monday", "Tuesday", 
                    "Wednesday", "Thursday", "Friday",
                    "Saturday" )
      
        println("Array elements are : ")
        for ( m1 <-days )
        {
            println(m1 )
        }
          
    }
}

输出：

Array elements are : 
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

在这里，我们正在创建一个数组来存储一周中的天数并打印所有天数。

数组的基本操作

1. 访问数组元素：
   例子：

   // Scala program to accessing an array 
   // of the string as name.
   object GFG
   {
       // Main method
       def main(args: Array[String]) 
       {
           // allocating memory of 1D Array of string. 
           var name = Array("gfg", "geeks", "GeeksQuize", 
                       "geeksforgeeks" )
         
           println("second element of an array is: ")
             
           // Accessing an array element
           println(name(1) )
       }
   }
   

   输出：

   second element of an array is: 
   geeks

2. 更新数组中的元素：
   例子：

   // Scala program to updating an array 
   // of the string as name.
   object GFG
   {
       // Main method
       def main(args: Array[String]) 
       {
           // allocating memory of 1D Array of string. 
           var name = Array("gfg", "geeks", "GeeksQuize", 
                       "geeksforgeeks" )
                         
           // Updating anelement in an array             
           name(1)="employee"
           println("After updation array elements are: ")
             
           for ( m1 <-name )
           {
               println(m1 )
           }
       }
   }
   

   输出：

   After updation array elements are: 
   gfg
   employee
   GeeksQuize
   geeksforgeeks

3. 在数组中添加元素：
   例子：

   // Scala program to adding elements in an array 
   // of the string as name.
   object GFG
   {
       // Main method
       def main(args: Array[String]) 
       {
           var name = new Array[String](4)
             
           // Adding element in an array 
           name(0)="gfg"
           name(1)="geeks"
           name(2)="GeeksQuize"
           name(3)="geeksforgeeks"
           println("After adding array elements : ")
             
           for ( m1 <-name )
           {
               println(m1 )
           }
         
       }
   }
   

   输出：

   After adding array elements : 
   gfg
   geeks
   GeeksQuize
   geeksforgeeks

4. 连接数组：
   我们可以使用 concat() 方法连接两个数组。在 concat() 方法中，我们可以传递多个数组作为参数。
   例子：

   // Scala program to concatenate two array 
   // by using concat() method
   import Array._
     
   // Creating object
   object GFG
   {
         
       // Main method
   def main(args: Array[String])
   {
       var arr1 = Array(1, 2, 3, 4)
       var arr2 = Array(5, 6, 7, 8)
     
       var arr3 = concat( arr1, arr2)
         
       // Print all the array elements
       for ( x <- arr3 ) 
       {
           println( x )
       }
   }
   }
   

   输出：

   1
   2
   3
   4
   5
   6
   7
   8

   这里，arr1 是一个包含四个元素的数组，而 arr2 是另一个包含四个元素的数组，现在我们使用 concat() 方法将这两个数组连接到 arr3 中。

多维数组

多维数组包含多行来存储值。 Scala 有一个方法Array.ofDim在 Scala 中创建多维数组。在矩阵和表格等结构中，可以使用多维数组。
句法：

var array_name = Array.ofDim[ArrayType](N, M)
 or  
var array_name = Array(Array(elements), Array(elements)

这是一个二维数组。这里 N 不是。行数，M 为否。列。

例子：

// Scala program to creating a 
// multidimension array of the 
// string as names, store  
// values in the names, 
// and prints each value. 
object GFG
{
    // Main method
    def main(args:Array[String]) 
    {
        val rows = 2
        val cols = 3
          
        // Declaring Multidimension array
        val names = Array.ofDim[String](rows, cols)
          
        // Allocating values
        names(0)(0) = "gfg"
        names(0)(1) = "Geeks"
        names(0)(2) = "GeeksQuize"
        names(1)(0) = "GeeksForGeeks"
        names(1)(1) = "Employee"
        names(1)(2) = "Author"
        for
        {
            i <- 0 until rows
            j <- 0 until cols
        }
          
        // Printing values
        println(s"($i)($j) = ${names(i)(j)}")
    }
}

输出：

(0)(0) = gfg
(0)(1) = Geeks
(0)(2) = GeeksQuize
(1)(0) = GeeksForGeeks
(1)(1) = Employee
(1)(2) = Author

在 Scala 中将元素追加和前置到数组

在将结果分配给新变量时，使用这些运算符（方法）将元素附加和前置到数组中：

Method	Function	Example
:+	append 1 item	old_array :+ e
++	append N item	old_array ++ new_array
+:	prepend 1 item	e +: old_array
++:	prepend N items	new_array ++: old_array

展示如何使用上述方法将元素附加和前置到数组的示例：

object GFG
{
     
  // Main method
  def main(args: Array[String])
  {
      
    // Declaring an array
    val a = Array(45, 52, 61) 
    println("Array a ")
    for ( x <- a ) 
    {
      println( x )
    }
  
    // Appending 1 item
    val b = a :+ 27 
    println("Array b ")
    for ( x <- b ) 
    {
      println( x )
    }
  
    // Appending 2 item
    val c = b ++ Array(1, 2)
    println("Array c ")
    for ( x <- c ) 
    {
       println( x )
    }
  
    // Prepending 1 item
    val d = 3 +: c 
    println("Array d ")
    for ( x <- d ) 
    {
      println( x )
    }
  
    // Prepending 2 item
    println("Array e ")
    val e = Array(10, 25) ++: d
    for ( x <- e ) 
    {
      println( x )
    }
  }
}

输出 ：

Array a 
45
52
61
Array b 
45
52
61
27
Array c 
45
52
61
27
1
2
Array d 
3
45
52
61
27
1
2
Array e 
10
25
3
45
52
61
27
1
2