scala array assignment

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial

Scala | Arrays

Array is a special kind of collection in scala. it is a fixed size data structure that stores elements of the same data type. The index of the first element of an array is zero and the last element is the total number of elements minus one. It is a collection of mutable values. It corresponds to arrays(in terms of syntax) in java but at the same time it’s different(in terms of functionalities) from java.

Some Important Points:

• Scala arrays can be generic. which mean we can have an Array[T], where T is a type parameter or abstract type.
• Scala arrays are compatible with Scala sequences – we can pass an Array[T] where a Seq[T] is required.
• Scala arrays also support all sequence operations.

Scala supports both one as well as multi-dimension arrays. A single dimension array is one having only one row and n columns whereas two dimension array is actually a matrix of dimension (n * m).

In this array contains only one row for storing the values. All values of this array are stored contiguously starting from 0 to the array size. Syntax:

Here, datatype specifies the type of data being allocated, size specifies the number of elements in the array, and var is the name of array variable that is linked to the array. Example:

Here, we are creating an array to store the days of the week and printing all days.

The Multidimensional arrays contains more than one row to store the values. Scala has a method Array.ofDim to create Multidimensional arrays in Scala . In structures like matrices and tables multi-dimensional arrays can be used. Syntax:

This is a Two-Dimension array. Here N is no. of rows and M is no. of Columns.

Use these operators (methods) to append and prepend elements to an array while assigning the result to a new variable:

Examples to show how to use the above methods to append and prepend elements to an Array:

Please Login to comment...

Similar reads.

• California Lawmakers Pass Bill to Limit AI Replicas
• Best 10 IPTV Service Providers in Germany
• Python 3.13 Releases | Enhanced REPL for Developers
• IPTV Anbieter in Deutschland - Top IPTV Anbieter Abonnements
• Content Improvement League 2024: From Good To A Great Article

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Info: JavaScript is currently disabled, code tabs will still work, but preferences will not be remembered.

Array is a special kind of collection in Scala. On the one hand, Scala arrays correspond one-to-one to Java arrays. That is, a Scala array Array[Int] is represented as a Java int[] , an Array[Double] is represented as a Java double[] and a Array[String] is represented as a Java String[] . But at the same time, Scala arrays offer much more than their Java analogues. First, Scala arrays can be generic . That is, you can have an Array[T] , where T is a type parameter or abstract type. Second, Scala arrays are compatible with Scala sequences - you can pass an Array[T] where a Seq[T] is required. Finally, Scala arrays also support all sequence operations. Here’s an example of this in action:

• Scala 2 and 3

Given that Scala arrays are represented just like Java arrays, how can these additional features be supported in Scala? The Scala array implementation makes systematic use of implicit conversions. In Scala, an array does not pretend to be a sequence. It can’t really be that because the data type representation of a native array is not a subtype of Seq . Instead there is an implicit “wrapping” conversion between arrays and instances of class scala.collection.mutable.ArraySeq , which is a subclass of Seq . Here you see it in action:

The interaction above demonstrates that arrays are compatible with sequences, because there’s an implicit conversion from arrays to ArraySeq s. To go the other way, from an ArraySeq to an Array , you can use the toArray method defined in Iterable . The last REPL line above shows that wrapping and then unwrapping with toArray produces a copy of the original array.

There is yet another implicit conversion that gets applied to arrays. This conversion simply “adds” all sequence methods to arrays but does not turn the array itself into a sequence. “Adding” means that the array is wrapped in another object of type ArrayOps which supports all sequence methods. Typically, this ArrayOps object is short-lived; it will usually be inaccessible after the call to the sequence method and its storage can be recycled. Modern VMs often avoid creating this object entirely.

The difference between the two implicit conversions on arrays is shown in the next REPL dialogue:

You see that calling reverse on seq , which is an ArraySeq , will give again a ArraySeq . That’s logical, because arrayseqs are Seqs , and calling reverse on any Seq will give again a Seq . On the other hand, calling reverse on the ops value of class ArrayOps will give an Array , not a Seq .

The ArrayOps example above was quite artificial, intended only to show the difference to ArraySeq . Normally, you’d never define a value of class ArrayOps . You’d just call a Seq method on an array:

The ArrayOps object gets inserted automatically by the implicit conversion. So the line above is equivalent to

where intArrayOps is the implicit conversion that was inserted previously. This raises the question of how the compiler picked intArrayOps over the other implicit conversion to ArraySeq in the line above. After all, both conversions map an array to a type that supports a reverse method, which is what the input specified. The answer to that question is that the two implicit conversions are prioritized. The ArrayOps conversion has a higher priority than the ArraySeq conversion. The first is defined in the Predef object whereas the second is defined in a class scala.LowPriorityImplicits , which is inherited by Predef . Implicits in subclasses and subobjects take precedence over implicits in base classes. So if both conversions are applicable, the one in Predef is chosen. A very similar scheme works for strings.

So now you know how arrays can be compatible with sequences and how they can support all sequence operations. What about genericity? In Java, you cannot write a T[] where T is a type parameter. How then is Scala’s Array[T] represented? In fact a generic array like Array[T] could be at run-time any of Java’s eight primitive array types byte[] , short[] , char[] , int[] , long[] , float[] , double[] , boolean[] , or it could be an array of objects. The only common run-time type encompassing all of these types is AnyRef (or, equivalently java.lang.Object ), so that’s the type to which the Scala compiler maps Array[T] . At run-time, when an element of an array of type Array[T] is accessed or updated there is a sequence of type tests that determine the actual array type, followed by the correct array operation on the Java array. These type tests slow down array operations somewhat. You can expect accesses to generic arrays to be three to four times slower than accesses to primitive or object arrays. This means that if you need maximal performance, you should prefer concrete to generic arrays. Representing the generic array type is not enough, however, there must also be a way to create generic arrays. This is an even harder problem, which requires a little of help from you. To illustrate the issue, consider the following attempt to write a generic method that creates an array.

The evenElems method returns a new array that consist of all elements of the argument vector xs which are at even positions in the vector. The first line of the body of evenElems creates the result array, which has the same element type as the argument. So depending on the actual type parameter for T , this could be an Array[Int] , or an Array[Boolean] , or an array of some other primitive types in Java, or an array of some reference type. But these types have all different runtime representations, so how is the Scala runtime going to pick the correct one? In fact, it can’t do that based on the information it is given, because the actual type that corresponds to the type parameter T is erased at runtime. That’s why you will get the following error message if you compile the code above:

What’s required here is that you help the compiler out by providing some runtime hint what the actual type parameter of evenElems is. This runtime hint takes the form of a class manifest of type scala.reflect.ClassTag . A class manifest is a type descriptor object which describes what the top-level class of a type is. Alternatively to class manifests there are also full manifests of type scala.reflect.Manifest , which describe all aspects of a type. But for array creation, only class manifests are needed.

The Scala compiler will construct class manifests automatically if you instruct it to do so. “Instructing” means that you demand a class manifest as an implicit parameter, like this:

Using an alternative and shorter syntax, you can also demand that the type comes with a class manifest by using a context bound. This means following the type with a colon and the class name ClassTag , like this:

The two revised versions of evenElems mean exactly the same. What happens in either case is that when the Array[T] is constructed, the compiler will look for a class manifest for the type parameter T, that is, it will look for an implicit value of type ClassTag[T] . If such a value is found, the manifest is used to construct the right kind of array. Otherwise, you’ll see an error message like the one above.

Here is some REPL interaction that uses the evenElems method.

In both cases, the Scala compiler automatically constructed a class manifest for the element type (first, Int , then String ) and passed it to the implicit parameter of the evenElems method. The compiler can do that for all concrete types, but not if the argument is itself another type parameter without its class manifest. For instance, the following fails:

What happened here is that the evenElems demands a class manifest for the type parameter U , but none was found. The solution in this case is, of course, to demand another implicit class manifest for U . So the following works:

This example also shows that the context bound in the definition of U is just a shorthand for an implicit parameter named here evidence$1 of type ClassTag[U] .

In summary, generic array creation demands class manifests. So whenever creating an array of a type parameter T , you also need to provide an implicit class manifest for T . The easiest way to do this is to declare the type parameter with a ClassTag context bound, as in [T: ClassTag] .

Contributors to this page:

• Introduction
• Mutable and Immutable Collections
• Trait Iterable
• The sequence traits Seq, IndexedSeq, and LinearSeq
• Concrete Immutable Collection Classes
• Concrete Mutable Collection Classes
• Performance Characteristics
• Creating Collections From Scratch
• Conversions Between Java and Scala Collections
• Conversion Between Option and the Collections

Scala Array class: methods, examples, and syntax

Table of contents, scala array class introduction, important note about the array examples, common array uses, create a new array with initial elements, create a new array by populating it, multidimensional arrays, how to add (append and prepend) elements to an array, filtering methods (how to “remove” elements from an array), how to “update” array elements, transformer methods, informational and mathematical methods, grouping methods, looping over an array with for and foreach, a few things you can do with an array of options, scala array summary.

This page contains dozens of examples that show how to use the methods on the Scala Array class.

The Scala Array class is a mutable, indexed, sequential collection. Unlike the Scala ArrayBuffer class , the Array class is only mutable in the sense that its existing elements can be modified; it can’t be resized like ArrayBuffer.

If you’re coming to Scala from Java:

• You can think of the Scala Array as being a wrapper around the Java array primitive type.
• I rarely use Array ; it’s okay to use it when you write OOP code, but if you’re writing multi-threaded or FP code, you won’t want to use it because it’s elements can be mutated. You should generally prefer the Scala Vector and ArrayBuffer classes rather than using Array .

In many of the examples that follow — specifically when I demonstrate many of the methods available on the Array class, like map , filter , etc. — you need to assign the result of the operation shown to a new variable, like this:

In an effort to keep the examples smaller and easier to read, I generally don’t do that in the following examples. I generally show the result of the expression on the right side of the comments.

I don’t normally use a Scala Array , but one benefit of it is that you can update elements in place, as shown in these examples:

Create an Array :

When an array holds mixed data types

When the values in the sequence have mixed/multiple types you may want to specify the type of the sequence:

A custom example:

How to create an empty Array :

Remember the constructor syntax is just syntactic sugar for apply :

You can create a new Array that’s populated with initial elements using a Range :

You can also use the fill and tabulate methods:

Multidimensional arrays in Scala:

In the REPL:

Notice that a string array defaults to null values.

Add elements to the array:

The result in the REPL:

Access the elements using parentheses, similar to a one-dimensional array:

Iterate over the array with a for-loop:

A three-dimensional array:

How to use an array of arrays

Can also create an array of arrays:

You can’t resize a Scala Array , but you can use these operators (methods) to append and prepend elements to an array while assigning the result to a new variable:

Append and prepend examples

These examples show how to use those methods to append and prepend elements to an Array :

About the : character in the method names

Note that during these operations the : character is always next to the old (original) sequence. I use that as a way to remember these methods.

The correct technical way to think about this is that a Scala method name that ends with the : character is right-associative, meaning that the method comes from the variable on the right side of the expression. Therefore, with +: and ++: , these methods comes from the Array that’s on the right of the method name.

An Array is an immutable sequence, so you don’t remove elements from it. Instead, you describe how to remove elements as you assign the results to a new collection. These methods let you “remove” elements during this process:

As noted, head and last can throw exceptions:

Because Array is immutable, you can’t update elements in place, but depending on your definition of “update,” there are a variety of methods that let you update an Array as you assign the result to a new variable:

Scala Array.range quirk

A quirk about trying to create an array of characters with the Array.range method:

First, some sample data:

The examples:

More information on fold and reduce

• Recursion is great, but ... (fold and reduce)

More information:

• How to split sequences into subsets in Scala

In summary, I hope these Array examples are helpful. If I made a mistake, or you know another way to do something with an Array I haven’t shown, leave a note in the Comments section.

Help keep this website running!

• Scala Seq class: Method examples (map, filter, fold, reduce)
• Scala Vector class: 170+ method examples (map, filter, fold, reduce)
• Scala IndexedSeq class: Method examples (filter, map, fold, reduce, etc.)
• Scala List class: 100+ method examples (map, filter, fold, reduce)
• Scala ArrayBuffer class: methods, syntax, and examples

Working with Arrays in Scala

Creating Arrays in Scala

Creating an array in Scala is straightforward. The syntax is similar to Java, but with a Scala twist. Here is an example:

This creates an array of integer types with a size of 5. The size is fixed and cannot be changed once the array is created.

Initializing Arrays in Scala

After creating an array, we can initialize it with values. Here's how:

This creates and initializes an array with the integers 1 through 5.

Accessing Array Elements

Accessing elements in an array is done using the element's index. Array indices in Scala, as in most programming languages, start at 0.

The above code retrieves the first element from the array.

Modifying Array Elements

Modifying an element in an array is as simple as accessing it. Here's how:

This changes the first element of the array to 10.

Traversing Arrays

Traversing through an array in Scala can be done using loops or higher-order functions. Here's how:

The above code prints all the elements in the array.

Understanding arrays in Scala is fundamental for any software developer. They are a powerful tool for data manipulation and can be used in various applications. Whether you're looking to hire Scala developers or learn Scala for your projects, a solid grasp of arrays is essential.

If you're interested in enhancing this article or becoming a contributing author, we'd love to hear from you.

Please contact Sasha at [email protected] to discuss the opportunity further or to inquire about adding a direct link to your resource. We welcome your collaboration and contributions!

Accessing Array Elements refers to the process of retrieving or modifying the values stored in an array using their respective indices. In most programming languages, array indices start at 0, meaning the first element is accessed using index 0, the second using index 1, and so on. Accessing an array element is typically achieved through the syntax arrayName[index] .

Arrays in Scala

Arrays in Scala are mutable, indexed collections of values. They are a type of data structure that allows storing multiple items of the same type. Arrays provide a way to store and manipulate a collection of elements efficiently. An array's size is fixed when it's created and cannot be changed.

To create an array in Scala, you instantiate the Array class with the desired type and size. The type could be any valid Scala type like Int, String, etc., while the size is an integer representing the number of elements that the array can hold.

In Scala, you can initialize an array at the time of creation by providing the elements within parentheses. These elements are assigned to the array in the order they are provided, starting from index 0.

Modifying an element in a Scala array involves assigning a new value to a specific index. This is done using the assignment operator (=) and the array's index.

Traversing or iterating over an array in Scala can be done using loops or higher-order functions. This allows you to access and manipulate every element in the array sequentially.

Hiring Remote Scala and React Developers with Grafana Skill: The Reintech Advantage

Hire Expert Remote Scala and React Developers Skilled in Zookeeper

Hire Remote Scala and Node.js Developers Skilled in Prometheus

• Scala Tutorial
• Scala - Home
• Scala - Overview
• Scala - Environment Setup
• Scala - Basic Syntax
• Scala - Data Types
• Scala - Variables
• Scala - Classes & Objects
• Scala - Access Modifiers
• Scala - Operators
• Scala - IF ELSE
• Scala - Loop Statements
• Scala - Functions
• Scala - Closures
• Scala - Strings

Scala - Arrays

• Scala - Collections
• Scala - Traits
• Scala - Pattern Matching
• Scala - Regular Expressions
• Scala - Exception Handling
• Scala - Extractors
• Scala - Files I/O
• Scala Useful Resources
• Scala - Quick Guide
• Scala - Useful Resources
• Scala - Discussion
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Scala provides a data structure, the array , which stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables. This tutorial introduces how to declare array variables, create arrays, and process arrays using indexed variables. The index of the first element of an array is the number zero and the index of the last element is the total number of elements minus one.

Declaring Array Variables

To use an array in a program, you must declare a variable to reference the array and you must specify the type of array the variable can reference.

The following is the syntax for declaring an array variable.

Here, z is declared as an array of Strings that may hold up to three elements. Values can be assigned to individual elements or get access to individual elements, it can be done by using commands like the following −

Here, the last example shows that in general the index can be any expression that yields a whole number. There is one more way of defining an array −

Following picture represents an array myList . Here, myList holds ten double values and the indices are from 0 to 9.

Processing Arrays

When processing array elements, we often use loop contol structures because all of the elements in an array are of the same type and the size of the array is known.

Below is an example program of showing how to create, initialize and process arrays −

Save the above program in Demo.scala . The following commands are used to compile and execute this program.

Scala does not directly support various array operations and provides various methods to process arrays in any dimension. If you want to use the different methods then it is required to import Array._ package.

Multi-Dimensional Arrays

There are many situations where you would need to define and use multi-dimensional arrays (i.e., arrays whose elements are arrays). For example, matrices and tables are examples of structures that can be realized as two-dimensional arrays.

The following is the example of defining a two-dimensional array −

This is an array that has three elements each being an array of integers that has three elements.

Try the following example program to process a multi-dimensional array −

Concatenate Arrays

Try the following example which makes use of concat() method to concatenate two arrays. You can pass more than one array as arguments to concat() method.

Create Array with Range

Use of range() method to generate an array containing a sequence of increasing integers in a given range. You can use final argument as step to create the sequence; if you do not use final argument, then step would be assumed as 1.

Let us take an example of creating an array of range (10, 20, 2): It means creating an array with elements between 10 and 20 and range difference 2. Elements in the array are 10, 12, 14, 16, and 18.

Another example: range (10, 20). Here range difference is not given so by default it assumes 1 element. It create an array with the elements in between 10 and 20 with range difference 1. Elements in the array are 10, 11, 12, 13, …, and 19.

The following example program shows how to create an array with ranges.

Scala Array Methods

Following are the important methods, which you can use while playing with array. As shown above, you would have to import Array._ package before using any of the mentioned methods. For a complete list of methods available, please check official documentation of Scala.

• ▼Scala Programming Exercises
• Scala Programming Exercises Home
• Control Flow
• Object Oriented Program
• ..More to come..

Scala Programming Array - Exercises, Practice, Solution

Scala programming array [40 exercises with solution].

[ An editor is available at the bottom of the page to write and execute the scripts.   Go to the editor ]

1. Write a Scala program to sum values of an given array. Click me to see the sample solution

2. Write a Scala program to check if a given number is present in fast or last position of a given array of length 1 or more. Click me to see the sample solution

3. Write a Scala program to calculate the average value of an array of element. Click me to see the sample solution

4. Write a Scala program to check if the value of the fast or last element of a given array ( length 1 or more) are same or not. Click me to see the sample solution

5. Write a Scala program to find the index of an element in a given Array. Click me to see the sample solution

6. Write a Scala program to check whether the value of the fast or last element of two given array ( length 1 or more) of integers are same or not. Click me to see the sample solution

7. Write a Scala program to remove a specific element from an given array. Note: The size of an Array can't be changed, so we can't directly delete elements from an array but replace them with "" / null etc. Click me to see the sample solution

8. Write a Scala program to rotate one element left of an given array (length 1 or more) of integers. Click me to see the sample solution

9. Write a Scala program to find the maximum and minimum value of an array of integers. Click me to see the sample solution

10. Write a Scala program to calculate the sum of the last 3 elements of an array of integers. If the array length is less than 3 then return the sum of the array. Return 0 if the array is empty. Click me to see the sample solution

11. Write a Scala program to create a new array taking the middle element from three arrays of length 5. Click me to see the sample solution

12. Write a Scala program to reverse an array of integer values. Click me to see the sample solution

13. Write a Scala program to check two numbers, 4 or 7 present in a given array of integers. Click me to see the sample solution

14. Write a Scala program to find the maximum value from first, middle and last values of a given array of integers. Array length should be 1 and more and odd. Click me to see the sample solution

15. Write a Scala program to find the common elements between two arrays of integers. Click me to see the sample solution

16. Write a Scala program to find the common elements between two arrays of strings. Click me to see the sample solution

17. Write a Scala program to remove duplicate elements from an array of strings. Click me to see the sample solution

18. Write a Scala program to remove duplicate elements from an array of integers. Click me to see the sample solution

19. Write a Scala program to find the second largest element from a given array of integers. Click me to see the sample solution

20. Write a Scala program to find the second smallest element from a given array of integers. Click me to see the sample solution

21. Write a Scala program to test the equality of two arrays. Click me to see the sample solution

22. Write a Scala program to find a missing number in an array of integers. Click me to see the sample solution

23. Write a Scala program to find the number of even and odd integers in a given array of integers. Click me to see the sample solution

24. Write a Scala program to get the difference between the largest and smallest values in an array of integers. The length of the array must be 1 and above. Click me to see the sample solution

25. Write a Scala program to compute the average value of an array element except the largest and smallest values. Click me to see the sample solution

26. Write a Scala program to remove the duplicate elements of a given sorted array and return the new length of the array. Click me to see the sample solution

27. Write a Scala program to find smallest and second smallest elements of a given array. Click me to see the sample solution

28. Write a Scala program to segregate all 0s on left side and all 1s on right side of a given array of 0s and 1s. Click me to see the sample solution

29. Write a Scala program to find the two elements from a given array of positive and negative numbers such that their sum is closest to zero. Click me to see the sample solution

30. Write a Scala program to find all combination of four elements of a given array whose sum is equal to a given value. Click me to see the sample solution

31. Write a Scala program to count the number of possible triangles from a given unsorted array of positive integers. Note: The triangle inequality states that the sum of the lengths of any two sides of a triangle must be greater than or equal to the length of the third side. Click me to see the sample solution

32. Write a Java program to arrange the elements of a given array of integers where all positive integers appear before all the negative integers. Click me to see the sample solution

33. Write a Scala program to separate even and odd numbers of a given array of integers. Put all even numbers first, and then odd numbers. Click me to see the sample solution

34. Write a Scala program to replace every element with the next greatest element (from right side) in a given array of integers. There is no element next to the last element, therefore replace it with -1. Click me to see the sample solution

35. Write a Scala program to find all pairs of elements in an array whose sum is equal to a specified number. Click me to see the sample solution

36. Write a Scala program to find maximum product of two integers in a given array of integers. Sample Input: nums = { 2, 3, 5, 7, -7, 5, 8, -5 } Sample Output: Pair is (7, 8), Maximum Product: 56 Click me to see the sample solution

37. Write a Scala program to rearrange a given array of unique elements such that every second element of the array is greater than its left and right elements. Salple Input: nums= { 1, 2, 4, 9, 5, 3, 8, 7, 10, 12, 14 } Sample Output: Array with every second element is greater than its left and right elements: [1, 4, 2, 9, 3, 8, 5, 10, 7, 14, 12] Click me to see the sample solution

38. Write a Scala program to find maximum difference between two elements in a given array of integers such that smaller element appears before larger element. Sample Input: nums = { 2, 3, 1, 7, 9, 5, 11, 3, 5 } Sample Output: The maximum difference between two elements of the said array elements 10 Click me to see the sample solution

39. Write a Scala program to find contiguous subarray within a given array of integers which has the largest sum. Sample Input: int[] A = {1, 2, -3, -4, 0, 6, 7, 8, 9} Sample Output: The largest sum of contiguous sub-array: 30 Click me to see the sample solution

40. Write a Scala program to find minimum subarray sum of specified size in a given array of integers. Sample Input: nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9,10} Sample Output: Sub-array size: 4 Sub-array from 0 to 3 and sum is: 10 Click me to see the sample solution

Scala Code Editor:

More to Come !

Test your Python skills with w3resource's quiz

Follow us on Facebook and Twitter for latest update.

• Weekly Trends and Language Statistics

Copy an Array to Another in Scala

Last updated: March 18, 2024

• Scala Collections

It's finally here:

>> The Road to Membership and Baeldung Pro .

Going into ads, no-ads reading , and bit about how Baeldung works if you're curious :)

1. Overview

In this tutorial, we’ll discuss different approaches to copying the elements of an array to another array in Scala .

2. Using Array as a Variable Argument

We know that the Array constructor accepts variable arguments. So, instead of passing all the array elements to another array, we can pass the entire array and use the splat operator in the constructor:

The above statement creates a new copy of array2 in the memory. This means that both array1 & array2 will point to different arrays in the memory:

Therefore, any change in array2 won’t affect array1 and vice versa:

3. Using the Array.copyToArray() Method

The copyToArray() method of class Array provides a better way to copy the elements of an array to another. It simply accepts an array that we want to fill:

Here, we’ve called the copyToArray() method on array1 and passed the newly created array2 as the parameter. Moreover, we should note that the size of array2 is 4. Thus, we can copy all the elements of array1 into array2 .

Consequently, it stops copying based on two conditions – either all the elements of array1 have been copied or the end of the array2 is reached

Also, one of the overloaded methods accepts three parameters – an array that is to be filled, the start index in the array, and the length which signifies the number of elements to be copied:

It also stops copying based on three conditions:

• all of the elements of array1 have been copied
• or the end of array2 is reached
• or the len number of elements have been copied

Let’s see an example:

Here, we have called the copyToArray() method on array1 and passed the newly created array2 as the first parameter. Then, the second parameter, 0, is the start index of array2 . And finally, the third parameter, 4, signifies the number of elements we need to copy from array1 to array2 .

Moreover, both the arrays have separate memory locations allotted to them:

4. Using the Array.map() Method

We can also use the map() method of class Array to copy all the elements of array1 to array2 .

For this, we can pass the identity function to the map() method that essentially returns whatever we pass to it.

Certainly, both the arrays have separate memory locations allotted to them:

5. Using Array.clone() Method

If we check the definition of class Array in Scala, we can see that it extends the java.lang.Cloneable interface:

Thus, we can use the clone() method to get the exact duplicate of array1, which also holds a different memory location:

However, we should avoid using the clone() method because of its obvious bad design decisions .

6. Can We Use the Assignment Operator?

We might think that the simplest way of copying an array into another is using an assignment operator:

However, this may not be the right way to do this. The reason is that the assignment operator doesn’t actually create a new array. Instead, it simply points array2 to array1 .

So, any change in array2 will result in the change in array1 and vice versa:

Therefore, assigning an array to another should not be considered a way of copying array elements to another.

7. Conclusion

In this article, we’ve seen various approaches for copying the elements of an array into another. Which approach fits best? Well, the first three approaches – using the given array as a vararg , using the Array.copyToArray()  and Array.map() methods – that we mentioned above work well. The clone() method and the assignment operator may not be good options for copying an array to another.

As always, the complete code samples for this article can be found over on GitHub .

Utility methods for operating on arrays. For example:

where the array objects a , b and c have respectively the values Array(1, 2) , Array(0, 0) and Array(1, 2, 0, 0) .

Type members

Value members, concrete methods.

Creates an array with given elements.

the elements to put in the array

an array containing all elements from xs.

Creates an array of Boolean objects

Creates an array of Byte objects

Creates an array of Short objects

Creates an array of Char objects

Creates an array of Int objects

Creates an array of Long objects

Creates an array of Float objects

Creates an array of Double objects

Creates an array of Unit objects

Concatenates all arrays into a single array.

the given arrays

the array created from concatenating xss

Copy one array to another.

Copy one array to another. Equivalent to Java's System.arraycopy(src, srcPos, dest, destPos, length) , except that this also works for polymorphic and boxed arrays.

Note that the passed-in dest array will be modified by this call.

destination array.

starting position in the destination array.

the number of array elements to be copied.

the source array.

starting position in the source array.

java.lang.System#arraycopy

Copy one array to another, truncating or padding with default values (if necessary) so the copy has the specified length.

Copy one array to another, truncating or padding with default values (if necessary) so the copy has the specified length. The new array can have a different type than the original one as long as the values are assignment-compatible. When copying between primitive and object arrays, boxing and unboxing are supported.

Equivalent to Java's java.util.Arrays.copyOf(original, newLength, newType) , except that this works for all combinations of primitive and object arrays in a single method.

java.util.Arrays#copyOf

Equivalent to Java's java.util.Arrays.copyOf(original, newLength) , except that this works for primitive and object arrays in a single method.

Returns an array of length 0

Compare two arrays per element.

A more efficient version of xs.sameElements(ys) .

Note that arrays are invariant in Scala, but it may be sound to cast an array of arbitrary reference type to Array[AnyRef] . Arrays on the JVM are covariant in their element type.

Array.equals(xs.asInstanceOf[Array[AnyRef]], ys.asInstanceOf[Array[AnyRef]])

an array of AnyRef

true if corresponding elements are equal

Returns an array that contains the results of some element computation a number of times.

Note that this means that elem is computed a total of n times:

the element computation

the number of elements desired

an Array of size n, where each element contains the result of computing elem .

Returns a two-dimensional array that contains the results of some element computation a number of times.

the number of elements in the 1st dimension

the number of elements in the 2nd dimension

Returns a three-dimensional array that contains the results of some element computation a number of times.

the number of elements in the 3rd dimension

Returns a four-dimensional array that contains the results of some element computation a number of times.

the number of elements in the 4th dimension

Returns a five-dimensional array that contains the results of some element computation a number of times.

the number of elements in the 5th dimension

Build an array from the iterable collection.

the iterable collection

an array consisting of elements of the iterable collection

Returns an array containing repeated applications of a function to a start value.

the function that is repeatedly applied

the number of elements returned by the array

the start value of the array

the array returning len values in the sequence start, f(start), f(f(start)), ...

Returns a new scala.collection.mutable.ArrayBuilder .

Creates array with given dimensions

Creates a 2-dimensional array

Creates a 3-dimensional array

Creates a 4-dimensional array

Creates a 5-dimensional array

Returns an array containing a sequence of increasing integers in a range.

the end value of the array, exclusive (in other words, this is the first value not returned)

the array with values in range start, start + 1, ..., end - 1 up to, but excluding, end .

Returns an array containing equally spaced values in some integer interval.

the increment value of the array (may not be zero)

the array with values in start, start + step, ... up to, but excluding end

Returns an array containing values of a given function over a range of integer values starting from 0.

The function computing element values

The number of elements in the array

A traversable consisting of elements f(0),f(1), ..., f(n - 1)

Returns a two-dimensional array containing values of a given function over ranges of integer values starting from 0 .

Returns a three-dimensional array containing values of a given function over ranges of integer values starting from 0 .

Returns a four-dimensional array containing values of a given function over ranges of integer values starting from 0 .

Returns a five-dimensional array containing values of a given function over ranges of integer values starting from 0 .

Called in a pattern match like { case Array(x,y,z) => println('3 elements')} .

the selector value

sequence wrapped in a scala.Some , if x is an Array, otherwise None

Concrete fields

Provides an implicit conversion from the Array object to a collection Factory

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Multiple assignment in Scala without using Array?

I have an input something like this: "1 2 3 4 5" .

What I would like to do, is to create a set of new variables, let a be the first one of the sequence, b the second, and xs the rest as a sequence (obviously I can do it in 3 different lines, but I would like to use multiple assignment).

A bit of search helped me by finding the right-ignoring sequence patterns , which I was able to use:

What I do not understand is that why doesn't it work if I try it with a tuple? I get an error for this:

The error message is:

Are there any alternatives for multiple-assignment without using Array ?

I have just started playing with Scala a few days ago, so please bear with me :-) Thanks in advance!

• functional-programming
• pattern-matching
• variable-assignment

5 Answers 5

Other answers tell you why you can't use tuples, but arrays are awkward for this purpose. I prefer lists:

• That is more clean –  Fanis Despoudis Commented Aug 14, 2019 at 11:44

Simple answer

The syntax you are seeing here is a simple pattern-match. It works because "1 2 3 4 5".split(" ") evaluates to an Array :

Since the right-hand-side is an Array , the pattern on the left-hand-size must, also, be an Array

The left-hand-side can be a tuple only if the right-hand-size evaluates to a tuple as well:

More complex answer

Technically what's happening here is that the pattern match syntax is invoking the unapply method on the Array object, which looks like this:

Note that the method accepts an Array . This is what Scala must see on the right-hand-size of the assignment. And it returns a Seq , which allows for the @_* syntax you used.

Your version with the tuple doesn't work because Tuple3 's unapplySeq is defined with a Product3 as its parameter, not an Array :

You can actually "extractors" like this that do whatever you want by simply creating an object and writing an unapply or unapplySeq method.

The answer is:

Should clarify that in some cases one may want to bind just the first n elements in a list, ignoring the non-matched elements. To do that, just add a trailing underscore:

• I posted apparently seconds after @Rex. Well, nice to know I had the same thought as a Scala "heavy" ;-) –  virtualeyes Commented Apr 24, 2012 at 18:08

I'm not an expert in Scala by any means, but I think this might have to do with the fact that Tuples in Scala are just syntatic sugar for classes ranging from Tuple2 to Tuple22.

Meaning, Tuples in Scala aren't flexible structures like in Python or other languages of the sort, so it can't really create a Tuple with an unknown a priori size.

• Ahh, now you mention it I can also recall that I read about that (I recall Tuple22 , but the point is the same, it is strictly limited). –  rlegendi Commented Apr 24, 2012 at 17:52

We can use pattern matching to extract the values from string and assign it to multiple variables. This requires two lines though.

Pattern says that there are 3 numbers([0-9]) with space in between. After the 3rd number, there can be text or not, which we don't care about (.*).

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged arrays scala functional-programming pattern-matching variable-assignment or ask your own question .

• The Overflow Blog
• Where does Postgres fit in a world of GenAI and vector databases?
• Mobile Observability: monitoring performance through cracked screens, old...
• Featured on Meta
• Announcing a change to the data-dump process
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Staging Ground Reviewer Motivation
• Feedback requested: How do you use tag hover descriptions for curating and do...

Hot Network Questions

• Where does the energy in ion propulsion come from?
• Motion of the COM of 2-body system
• Image Intelligence concerning alien structures on the moon
• Which version of Netscape, on which OS, appears in the movie “Cut” (2000)?
• Is there a nonlinear resistor with a zero or infinite differential resistance?
• Rings demanding identity in the categorical context
• Why is the movie titled "Sweet Smell of Success"?
• How to count mismatches between two rows, column by column R?
• Can stockfish provide analysis with non-standard pieces like knooks?
• Is the spectrum of Hawking radiation identical to that of thermal radiation?
• magnetic boots inverted
• What prevents a browser from saving and tracking passwords entered to a site?
• Has a tire ever exploded inside the Wheel Well?
• Cannot open and HTML file stored on RAM-disk with a browser
• Does there always exist an algebraic formula for a function?
• Can you give me an example of an implicit use of Godel's Completeness Theorem, say for example in group theory?
• How to disable Google Lens in search when using Google Chrome?
• Whatever happened to Chessmaster?
• bash script to run a python command with arguments in batch
• I overstayed 90 days in Switzerland. I have EU residency and never got any stamps in passport. Can I exit/enter at airport without trouble?
• Is there a way to resist spells or abilities with an AOE coming from my teammates, or exclude certain beings from the effect?
• Determining Error Rate of Phase Shift Keying via Monte Carlo Simulation
• Stuck on Sokoban
• Could someone tell me what this part of an A320 is called in English?