Scala - Diziler

Scala bir veri yapısı sağlar, array, aynı türden öğelerin sabit boyutlu sıralı bir koleksiyonunu depolayan. Bir dizi, bir veri koleksiyonunu depolamak için kullanılır, ancak bir diziyi aynı türden değişkenlerin bir koleksiyonu olarak düşünmek genellikle daha kullanışlıdır.

Sayı0, sayı1, ... ve sayı99 gibi tek tek değişkenleri bildirmek yerine, sayılar gibi bir dizi değişkeni bildirir ve temsil etmek için sayılar [0], sayılar [1] ve ..., sayılar [99] kullanırsınız bireysel değişkenler. Bu öğretici, dizi değişkenlerinin nasıl bildirileceğini, dizilerin nasıl oluşturulacağını ve dizine alınmış değişkenler kullanılarak dizilerin nasıl işleneceğini açıklamaktadır. Bir dizinin ilk öğesinin dizini sıfır sayısıdır ve son öğenin dizini, öğelerin toplam sayısı eksi birdir.

Dizi Değişkenlerini Bildirme

Bir programda bir dizi kullanmak için, diziye başvurmak üzere bir değişken bildirmeniz ve değişkenin başvurabileceği dizi türünü belirtmeniz gerekir.

Aşağıda, bir dizi değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

or

var z = new Array[String](3)

Burada z, en fazla üç öğe tutabilen bir Dizeler dizisi olarak bildirilir. Değerler tek tek öğelere atanabilir veya tek tek öğelere erişim elde edilebilir, aşağıdaki gibi komutlar kullanılarak yapılabilir -

Komut

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

Buradaki son örnek, genel olarak dizinin tam sayı veren herhangi bir ifade olabileceğini göstermektedir. Bir diziyi tanımlamanın bir yolu daha var -

var z = Array("Zara", "Nuha", "Ayan")

Aşağıdaki resim bir diziyi temsil eder myList. Buraya,myList on çift değer tutar ve endeksler 0'dan 9'a kadardır.

Dizileri İşleme

Dizi öğelerini işlerken, genellikle döngü kontrol yapılarını kullanırız çünkü bir dizideki tüm öğeler aynı türdedir ve dizinin boyutu bilinir.

Aşağıda dizilerin nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

object Demo {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }

      // Summing all elements
      var total = 0.0;
      
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);

      // Finding the largest element
      var max = myList(0);
      
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      
      println("Max is " + max);
   }
}

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala, çeşitli dizi işlemlerini doğrudan desteklemez ve herhangi bir boyuttaki dizileri işlemek için çeşitli yöntemler sağlar. Farklı yöntemleri kullanmak istiyorsanız, içe aktarmanız gerekir.Array._ paketi.

Çok Boyutlu Diziler

Çok boyutlu dizileri tanımlamanız ve kullanmanız gereken pek çok durum vardır (yani, elemanları diziler olan diziler). Örneğin, matrisler ve tablolar, iki boyutlu diziler olarak gerçekleştirilebilecek yapı örnekleridir.

Aşağıda, iki boyutlu bir dizi tanımlama örneği verilmiştir -

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

Bu, her biri üç öğeye sahip bir tamsayı dizisi olan üç öğeye sahip bir dizidir.

Çok boyutlu bir diziyi işlemek için aşağıdaki örnek programı deneyin -

Misal

import Array._

object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

0 1 2
0 1 2
0 1 2

Dizileri Birleştir

İki diziyi birleştirmek için concat () yöntemini kullanan aşağıdaki örneği deneyin. Concat () yöntemine argüman olarak birden fazla dizi geçirebilirsiniz.

Misal

import Array._

object Demo {
   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)
      
      // Print all the array elements
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Aralık ile Dizi Oluşturun

Belirli bir aralıkta artan tamsayı dizisini içeren bir dizi oluşturmak için range () yönteminin kullanılması. Diziyi oluşturmak için son bağımsız değişkeni adım olarak kullanabilirsiniz; son argümanı kullanmazsanız, adım 1 olarak kabul edilir.

Bir aralık dizisi oluşturmanın bir örneğini ele alalım (10, 20, 2): Bu, 10 ile 20 arasındaki öğeler ve aralık farkı 2 ile bir dizi oluşturmak anlamına gelir. Dizideki öğeler 10, 12, 14, 16 ve 18'dir. .

Başka bir örnek: aralık (10, 20). Burada aralık farkı verilmez, bu nedenle varsayılan olarak 1 eleman olduğunu varsayar. Aralık farkı 1 ile 10 ile 20 arasındaki öğelerle bir dizi oluşturur. Dizideki öğeler 10, 11, 12, 13,… ve 19'dur.

Aşağıdaki örnek program, aralıklarla bir dizinin nasıl oluşturulacağını gösterir.

Misal

import Array._

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

      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Scala Dizi Yöntemleri

Dizi ile oynarken kullanabileceğiniz önemli yöntemler aşağıdadır. Yukarıda gösterildiği gibi, içeri aktarmanız gerekecekArray._belirtilen yöntemlerden herhangi birini kullanmadan önce paketleyin. Mevcut yöntemlerin tam listesi için lütfen Scala'nın resmi belgelerine bakın.

Sr.No	Açıklamalı Yöntemler
1	def apply( x: T, xs: T* ): Array[T] T'nin Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean olabileceği bir T nesneleri dizisi oluşturur.
2	def concat[T]( xss: Array[T]* ): Array[T] Tüm dizileri tek bir dizide birleştirir.
3	def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit Bir diziyi diğerine kopyalayın. Java'nın System.arraycopy (src, srcPos, dest, destPos, length) ile eşdeğerdir.
4	def empty[T]: Array[T] 0 uzunluğunda bir dizi verir
5	def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] Bir işlevin yinelenen uygulamalarını bir başlangıç ​​değerine döndürür.
6	def fill[T]( n: Int )(elem: => T): Array[T] Bazı eleman hesaplamalarının sonuçlarını birkaç kez içeren bir dizi döndürür.
7	def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] Bazı öğe hesaplamalarının sonuçlarını birkaç kez içeren iki boyutlu bir dizi döndürür.
8	def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T] Bir işlevin yinelenen uygulamalarını bir başlangıç ​​değerine döndürür.
9	def ofDim[T]( n1: Int ): Array[T] Verilen boyutlara sahip dizi oluşturur.
10	def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 2 boyutlu bir dizi oluşturur
11	def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 3 boyutlu bir dizi oluşturur
12	def range( start: Int, end: Int, step: Int ): Array[Int] Bazı tam sayı aralığında eşit aralıklı değerler içeren bir dizi döndürür.
13	def range( start: Int, end: Int ): Array[Int] Bir aralıkta artan tamsayılar dizisi içeren bir dizi döndürür.
14	def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 0'dan başlayan bir tamsayı değerleri aralığında belirli bir işlevin değerlerini içeren bir dizi döndürür.
15	def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 0'dan başlayan tamsayı değerleri aralıklarında belirli bir işlevin değerlerini içeren iki boyutlu bir dizi döndürür.