Scala | Create Array with Range

Array is a special kind of collection in Scala. It is a fixed size data structure that stores elements of the same data type. By using range() method to generate an array containing a sequence of increasing integers in a given range. We can use final argument as jump to create the sequence. if we do not use final argument, then jump would be assumed as 1. Below are some examples of array with range: 

Example: 

// Scala program to create array with range 
import Array._

// Creating object
object GFG
{
    // Main method
    def main(args: Array[String]) 
    {
        var array1 = range(1, 15)
        var array2 = range(1, 15, 3)
    

        // Print all the elements of array1
        for ( i <- array1 ) 
        {
            print( " " + i )
        }
        
        println()
        
        // Print all the elements of array2
        for ( i <- array2 ) 
        {
            print( " " + i )
        }
    }
}

In above example, an array of range (1, 15). In this range difference is not given so by default difference of range will be 1 element. Elements in the array are 1, 4, 7, 10 and 13. Here, we are creating an array of range (1, 15, 3). Which means an array with elements between 1 and 15 and range difference is 3. Elements in the array are 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, and 14. For some of the collections, such as List and Array, we can also create a Range and convert it to the desired sequence: The REPL shows the array that can be created directly from a Range is toArray. We can also use a Range to create a sequence of characters as below: 

Example: 

// Scala program to create array with range 
import Array._

// Creating object
object GFG
{
    // Main method
    def main(args: Array[String]) 
    {
        val array1 = ('A' to 'F').toArray
        val array2 = ('a' to 'f').by(2).toArray
    
    
        // Print all the elements of array1
        for ( i <- array1 ) 
        {
            print( " " + i )
        }
        
        println()
        
        // Print all the elements of array2
        for ( i <- array2 ) 
        {
            print( " " + i )
        }
    }
}

In above example, an array of range ('A' to 'F').toArray. In this, range difference is not given so by default difference of range will be 1 character. characters in the array are A, B, C, D, E and F. Here, we are creating an array of range ('a' to 'f').by(2).toArray. Which means an array with characters between a and f and range difference is 2. Characters in the array are a, c, and e.

In Scala, you can create an array with a range using the Array.range() method. This method takes three arguments: start, end, and step. It generates a sequence of values from start to end (exclusive) with a specified step value and returns an array containing those values.

Here's an example code that creates an array of integers from 1 to 10 with a step of 2 using Array.range() method:

object RangeArrayExample {
  def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array.range(1, 10, 2)
    println("Printing array elements:")
    for (i <- arr) {
      println(i)
    }
  }
}

Printing array elements:
1
3
5
7
9

In this example, we first create an array arr using Array.range() method with start value of 1, end value of 10 (exclusive), and step value of 2. Then, we use a for loop to print each element of the array. As a result, the output is an array of integers from 1 to 10 with a step of 2.

Advantages of creating an array with a range using Array.range() method in Scala:

1. It provides a concise and readable way to create arrays with a range of values.
2. The step argument allows you to create arrays with a specified interval between elements.
3. It returns an array with a fixed size, which is useful when you need to work with arrays of a specific length.

Disadvantages of creating an array with a range using Array.range() method in Scala:

1. It only works with numerical data types, such as Int, Double, Float, etc.
2. It generates a new array object every time it is called, which can be inefficient for large arrays. In such cases, it may be more efficient to create an empty array and then populate it with values using other methods.