Tatasusunan skala

Tatasusunan yang disediakan dalam bahasa Scala digunakan untuk menyimpan elemen bersaiz tetap daripada jenis yang sama ialah salah satu struktur data yang penting untuk setiap bahasa pengeditan.

Mengisytiharkan pembolehubah tatasusunan bukanlah mengisytiharkan nombor0, nombor1,..., nombor99 sebagai pembolehubah berasingan, tetapi mengisytiharkan pembolehubah seperti nombor, dan kemudian menggunakan nombor[0], nombor[1], ..., nombor[99] untuk mewakili pembolehubah individu. Elemen tertentu dalam tatasusunan diakses oleh indeks.

Elemen pertama tatasusunan mempunyai indeks 0, dan elemen terakhir mempunyai indeks jumlah bilangan elemen tolak 1.

Isytihar tatasusunan

Berikut ialah format sintaks pengisytiharan tatasusunan Scala:

var z:Array[String] = new Array[String](3)

或

var z = new Array[String](3)

Dalam sintaks di atas, z mengisytiharkan tatasusunan jenis rentetan dan panjang tatasusunan ialah 3, boleh menyimpan 3 elemen. Kita boleh menetapkan nilai untuk setiap elemen dan mengakses setiap elemen mengikut indeks seperti berikut:

z(0) = "php"; z(1) = "Baidu"; z(4/2) = "Google"

Indeks elemen terakhir menggunakan ungkapan 4/2 sebagai indeks, Sama seperti z(2) = "Google".

Kami juga boleh mentakrifkan tatasusunan dengan cara berikut:

var z = Array("php", "Baidu", "Google")

Rajah berikut menunjukkan tatasusunan myList dengan panjang 10, dengan nilai indeks dari 0 hingga 9:

Memproses Tatasusunan

Jenis elemen tatasusunan dan saiz tatasusunan ditentukan, jadi apabila memproses elemen tatasusunan, kita biasanya menggunakan asas untuk gelung.

Contoh berikut menunjukkan penciptaan, permulaan dan pemprosesan tatasusunan lain:

object Test {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // 输出所有数组元素
      for ( x <- myList ) {
         println( x )
      }

      // 计算数组所有元素的总会
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("总和为 " + total);

      // 查找数组中的最大元素
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("最大值为 " + max);
    
   }
}

Laksanakan kod di atas, hasil output ialah:

$ scalac Test.scala
$ scala Test
1.9
2.9
3.4
3.5
总和为 11.7
最大值为 3.5

Berbilang dimensi tatasusunan

Tatasusunan berbilang dimensi Nilai dalam satu tatasusunan boleh menjadi tatasusunan lain, dan nilai dalam tatasusunan lain juga boleh tatasusunan. Matriks dan jadual ialah tatasusunan dua dimensi biasa kami.

Di atas ialah contoh yang mentakrifkan tatasusunan dua dimensi:

var myMatrix = ofDim[Int](3,3)

Dalam contoh, tatasusunan mengandungi tiga elemen tatasusunan dan setiap elemen tatasusunan mengandungi tiga nilai.

Seterusnya mari kita lihat contoh lengkap pemprosesan tatasusunan dua dimensi:

import Array._

object Test {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      
      // 创建矩阵
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // 打印二维阵列
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
    
   }
}

Contoh berjalan»

Laksanakan kod di atas, hasil output ialah:

$ scalac Test.scala
$ scala Test
0 1 2
0 1 2
0 1 2

Gabung tatasusunan

Dalam contoh berikut, kami menggunakan kaedah concat() untuk menggabungkan dua tatasusunan Kaedah concat() menerima berbilang parameter tatasusunan:

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = Array(1.9, 2.9, 3.4, 3.5)
      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)
      
      // 输出所有数组元素
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Laksanakan kod di atas, hasil output ialah:

$ scalac Test.scala
$ scala Test
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Buat tatasusunan julat

Dalam contoh berikut, kami menggunakan kaedah julat() untuk menjana tatasusunan dalam julat. Parameter terakhir kaedah julat() ialah saiz langkah, yang lalai kepada 1:

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)

      // 输出所有数组元素
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

melaksanakan kod di atas, dan hasil output ialah:

$ scalac Test.scala
$ scala Test
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Kaedah tatasusunan Scala

Jadual menunjukkan kaedah penting untuk memproses tatasusunan dalam bahasa Scala Sebelum menggunakannya, kita perlu menggunakan pakej import Array._.

scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)

scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)