{"id":220,"date":"2022-01-21T14:56:04","date_gmt":"2022-01-21T14:56:04","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/scala\/?p=220"},"modified":"2022-04-18T14:54:11","modified_gmt":"2022-04-18T14:54:11","slug":"scala-working-with-arrays","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/scala\/scala-working-with-arrays\/","title":{"rendered":"Scala – Working with Arrays"},"content":{"rendered":"

In this lesson, you will learn how to us arrays in Scala. Array in Scala works similar to arrays in Java, so let’s go ahead to get started!<\/p>\n

We’l cover the following sub-topics<\/p>\n

    \n
  1. Declaring an Array<\/a><\/li>\n
  2. Array Processing<\/a><\/li>\n
  3. Multidimensional Arrays<\/a><\/li>\n
  4. Array Concatenation<\/a><\/li>\n
  5. Array With Range Function<\/a><\/li>\n
  6. Some Useful Array Methods<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Declaring an Array<\/strong><\/h4>\n

    As you know, before you can use any variable, you must declare it. Arrays are not exceptions. You can declare an array variable in Scala using the syntax below:<\/p>\n

    \/\/ Method 1<\/span>\r\nvar<\/span> arr:<\/span>Array<\/span>[<\/span>String<\/span>]<\/span> =<\/span> new<\/span> Array<\/span>[<\/span>String<\/span>](<\/span>3<\/span>)<\/span>\r\n\r\n\/\/ Method 2<\/span>\r\nvar<\/span> arr =<\/span> new<\/span> Array<\/span>[<\/span>String<\/span>](<\/span>3<\/span>)<\/span>\r\n<\/pre>\n
    In these examples, we declare an array names arr, that can hold up to 3 String values.<\/p>\n
    To access the elements of an array, you can use the index which is zero-based. Examples are given below:<\/p>\n
    arr(<\/span>0<\/span>)<\/span> =<\/span> \"Kindson\"<\/span>;<\/span> \r\narr(<\/span>1<\/span>)<\/span> =<\/span> \"Jadon\"<\/span>;<\/span> \r\narr(<\/span>2<\/span>)<\/span> =<\/span> \"Solace\"<\/span>\r\n\r\n\/\/Another method<\/span>\r\nvar<\/span> arr =<\/span> Array<\/span>(<\/span>\"Kindson\"<\/span>,<\/span> \"Jadon\"<\/span>,<\/span> \"Solace\"<\/span>)<\/span>\r\n<\/pre>\n
    So you can use either of the two methods<\/p>\n
     <\/p>\n
    2. Array Processing<\/strong><\/h4>\n
    Normally we can process multiple array elements using a loop. In the example below we perform the following operations:<\/p>\n
      \n
    • Print all elements of the array<\/li>\n
    • Sum all elements of the array<\/li>\n
    • Find the maximum element in the array<\/li>\n<\/ul>\n
      \/\/ Program to Demonstrate Array Processing<\/span>\r\nobject<\/span> ArrayProcessing<\/span> {<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span>:<\/span> Unit<\/span> =<\/span> {<\/span>\r\n\r\n    val<\/span> arr =<\/span> Array<\/span>(<\/span>34<\/span>,<\/span> 66<\/span>,<\/span> 78<\/span>,<\/span> 3<\/span>,<\/span> 95<\/span>)<\/span>\r\n\r\n    \/\/Print all element of the array<\/span>\r\n    for<\/span> (<\/span>ele <-<\/span> arr)<\/span> {<\/span>\r\n      println(<\/span>ele)<\/span>\r\n    }<\/span>\r\n\r\n    \/\/Sum all element of the array<\/span>\r\n    var<\/span> sum:<\/span> Int<\/span> =<\/span> 0<\/span>\r\n    for<\/span> (<\/span>ele <-<\/span> arr)<\/span> {<\/span>\r\n      sum =<\/span> sum +<\/span> ele\r\n    }<\/span>\r\n    println(<\/span>s\"The sume is $sum\"<\/span>)<\/span>\r\n\r\n    \/\/Find the maximum element<\/span>\r\n    var<\/span> max =<\/span> arr(<\/span>0<\/span>)<\/span>\r\n    for<\/span> (<\/span>i <-<\/span> 1<\/span> to (<\/span>arr.<\/span>length -<\/span> 1<\/span>))<\/span> {<\/span>\r\n      if<\/span> (<\/span>arr(<\/span>i)<\/span> ><\/span> max)<\/span> {<\/span>\r\n        max =<\/span> arr(<\/span>i)<\/span>\r\n      }<\/span>\r\n    }<\/span>\r\n    println(<\/span>s\"The maximum number in the array is $max\"<\/span>)<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
      The program above gives the following output<\/p>\n
      34\r\n66\r\n78\r\n3\r\n95\r\nThe sume is 276\r\nThe maximum number in the array is 95\r\n<\/pre>\n
       <\/p>\n
      3. Multidimensional Arrays<\/strong><\/h4>\n
      You can think of multidimensional array as an array of arrays. So we have the elements of the array to be arrays as well. That helps create a grid of table view of elements.<\/p>\n
      The following syntax declares a 2-dimensional array called myGrid.<\/p>\n
      var<\/span> myGrid =<\/span> ofDim[<\/span>Int<\/span>](<\/span>4<\/span>,<\/span>4<\/span>)<\/span>\r\n<\/pre>\n
      The code above creates an array\u00a0 of 4 elements each being an array of 4 elements<\/p>\n
      The program below creates a 2-dimensional array using a nested loop and then prints out the elements using another nested loop<\/p>\n
      \/\/ Program to Demonstrate Multidimensional Array Processing<\/span>\r\nobject<\/span> MultidimensionalArray<\/span> {<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span>:<\/span> Unit<\/span> =<\/span> {<\/span>\r\n\r\n    var<\/span> myGrid =<\/span> ofDim[<\/span>Int<\/span>](<\/span>4<\/span>,<\/span>4<\/span>)<\/span>\r\n\r\n    \/\/Assign items to grid<\/span>\r\n    for<\/span> (<\/span>i <-<\/span> 0<\/span> to (<\/span>myGrid.<\/span>length -<\/span>1<\/span>))<\/span> {<\/span>\r\n      for<\/span> (<\/span>j <-<\/span> 0<\/span> to 3<\/span>)<\/span> {<\/span>\r\n        myGrid(<\/span>i)(<\/span>j)<\/span> =<\/span> j\r\n      }<\/span>\r\n    }<\/span>\r\n\r\n    \/\/Print out grid elements<\/span>\r\n    for<\/span> (<\/span>i <-<\/span> 0<\/span> to (<\/span>myGrid.<\/span>length -<\/span>1<\/span>))<\/span> {<\/span>\r\n      for<\/span> (<\/span>j <-<\/span> 0<\/span> to 3<\/span>)<\/span> {<\/span>\r\n        print(<\/span>\"  \"<\/span> +<\/span> myGrid(<\/span>i)(<\/span>j))<\/span>\r\n      }<\/span>\r\n      println()<\/span>\r\n    }<\/span>\r\n\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
       <\/p>\n
      4. Array Concatenation<\/strong><\/h4>\n
      You can also concatenate two arrays using the concat() method. The concat() method for arrays take the two arrays to be concatenated. The syntax is:<\/p>\n
      var<\/span> arr3:<\/span>Array<\/span>[<\/span>String<\/span>]<\/span> =<\/span> concat(<\/span>arr1,<\/span> arr2)<\/span>\r\n<\/pre>\n
       <\/p>\n
      The program below illustrates\u00a0 concatenation of two arrays. Then printing out the elements of the concatenated array<\/p>\n
      \/\/ Program to Demonstrate Multidimensional Array Processing<\/span>\r\nobject<\/span> MultidimensionalArray<\/span> {<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span>:<\/span> Unit<\/span> =<\/span> {<\/span>\r\n\r\n    var<\/span> arr1:<\/span>Array<\/span>[<\/span>String<\/span>]<\/span> =<\/span> Array<\/span>(<\/span>\"Jadon\"<\/span>,<\/span> \"McMills\"<\/span>,<\/span> \"Treasure\"<\/span>,<\/span> \"Esther\"<\/span>)<\/span>\r\n    var<\/span> arr2:<\/span>Array<\/span>[<\/span>String<\/span>]<\/span> =<\/span> Array<\/span>(<\/span>\"Solace\"<\/span>,<\/span> \"Onyx\"<\/span>,<\/span> \"Trust\"<\/span>,<\/span> \"Praise\"<\/span>)<\/span>\r\n    var<\/span> arr3:<\/span>Array<\/span>[<\/span>String<\/span>]<\/span> =<\/span> concat(<\/span>arr1,<\/span> arr2)<\/span>\r\n\r\n    \/\/print the concatenated array<\/span>\r\n    for<\/span> (<\/span>ele <-<\/span> arr3)<\/span> {<\/span>\r\n      println(<\/span>ele)<\/span>\r\n    }<\/span>\r\n\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
       <\/p>\n
      5. Array With the Range Function<\/strong><\/h4>\n
      You can use the range() function to generate a sequence of values between a given range. The range() function takes two arguments – start and end. It also takes an optional third argument, step which indicate then difference between subsequent values in the array.<\/p>\n
      \/\/ Program to Demonstrate Array with Range<\/span>\r\nobject<\/span> ArrayWithRange<\/span> {<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span>:<\/span> Unit<\/span> =<\/span> {<\/span>\r\n\r\n    var<\/span> jumpTen:<\/span>Array<\/span>[<\/span>Int<\/span>]<\/span> =<\/span> range(<\/span>10<\/span>,<\/span> 100<\/span>,<\/span> 10<\/span>)<\/span>\r\n    var<\/span> jumpOne:<\/span>Array<\/span>[<\/span>Int<\/span>]<\/span> =<\/span> range(<\/span>1<\/span>,<\/span> 10<\/span>)<\/span>\r\n\r\n    \/\/print the  first array<\/span>\r\n    println(<\/span>\"Now Printing element of JumpTen...\"<\/span>)<\/span>\r\n    for<\/span> (<\/span>ele <-<\/span> jumpTen)<\/span> {<\/span>\r\n      println(<\/span>ele)<\/span>\r\n    }<\/span>\r\n\r\n    \/\/print the  second array<\/span>\r\n    println(<\/span>\"Now Printing element of JumpOne...\"<\/span>)<\/span>\r\n    for<\/span> (<\/span>ele <-<\/span> jumpOne)<\/span> {<\/span>\r\n      println(<\/span>ele)<\/span>\r\n    }<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
      I recommend you run the program yourself and see the output. Leave a comment below if you have challenges.<\/p>\n
       <\/p>\n
      6. Useful Array Methods<\/strong><\/h4>\n
      The table below provides a list of some useful array methods.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
      SN<\/th>\nMethods and Description<\/th>\n<\/tr>\n
      1<\/td>\ndef apply( x: T, xs: T* ): Array[T] – <\/b>Creates an array of T objects, where T can be any data type<\/td>\n<\/tr>\n
      2<\/td>\ndef concat[T]( xss: Array[T]* ): Array[T] – <\/b>Concatenates all arrays into one single array.<\/td>\n<\/tr>\n
      3<\/td>\ndef copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit –\u00a0<\/b>Copy one array to another. Equivalent to System.arraycopy(src, srcPos, dest, destPos, length) in Java<\/td>\n<\/tr>\n
      4<\/td>\ndef empty[T]: Array[T] –\u00a0<\/b>Returns an array of length 0<\/td>\n<\/tr>\n
      5<\/td>\ndef iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] –\u00a0<\/b>Returns an array containing repeated applications of a function to a start value.<\/td>\n<\/tr>\n
      6<\/td>\ndef fill[T]( n: Int )(elem: => T): Array[T] –\u00a0<\/b>Returns an array that contains the results of some element computation a number of times.<\/td>\n<\/tr>\n
      7<\/td>\ndef fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] – <\/b>Returns a two-dimensional array that contains the results of some element computation a number of times.<\/td>\n<\/tr>\n
      8<\/td>\ndef iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T] – <\/b>Returns an array containing repeated applications of a function to a start value.<\/td>\n<\/tr>\n
      9<\/td>\ndef ofDim[T]( n1: Int ): Array[T] –\u00a0<\/b>Creates array with specified dimensions.<\/td>\n<\/tr>\n
      10<\/td>\ndef ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] –\u00a0<\/b>Creates a 2-dimensional array<\/td>\n<\/tr>\n
      11<\/td>\ndef ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] –\u00a0<\/b>Creates a 3-dimensional array<\/td>\n<\/tr>\n
      12<\/td>\ndef range( start: Int, end: Int, step: Int ): Array[Int] –\u00a0<\/b>Returns an array that contains equally spaced values in some integer interval.<\/td>\n<\/tr>\n
      13<\/td>\ndef range( start: Int, end: Int ): Array[Int] – <\/b>Returns an array containing a sequence of increasing integers in a range.<\/td>\n<\/tr>\n
      14<\/td>\ndef tabulate[T]( n: Int )(f: (Int)=> T): Array[T] – <\/b>Returns an array that contains values of a given function over a range of integer values starting from 0.<\/td>\n<\/tr>\n
      15<\/td>\ndef tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] – <\/b>Returns a two-dimensional array that contains values of a given function over ranges of integer values starting from 0.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
       <\/p>\n","protected":false},"excerpt":{"rendered":"
      In this lesson, you will learn how to us arrays in Scala. Array in Scala works similar to arrays in Java, so let’s go ahead … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[36],"class_list":["post-220","post","type-post","status-publish","format-standard","hentry","category-scala-programming","tag-arrays"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/220","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/comments?post=220"}],"version-history":[{"count":3,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/220\/revisions"}],"predecessor-version":[{"id":253,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/220\/revisions\/253"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/media?parent=220"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/categories?post=220"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/tags?post=220"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}