Scala Zip

The Scala zip function is the same as zip files. In the article, we have a deep demonstration of the Scala zip function that will improve the efficiency and readability of code. The Scala zip function combines two collections of elements pairwise and merges them into a new collection of elements. The function belongs to a concrete value member of the Abstract iterable class that will create new collections pairs in the form of tuples.

What is Zip() in Scala:

The Scala zip method takes two sets as an argument and intertwines them with a new collection containing combined elements. So basically, the Scala zip function combines two collections of objects to give a new collection. These collections are used by lists, strings, arrays, views, and iterators.

Syntax and parameter of the zip function in Scala:

The general syntax of the Zip function in Scala is given below:

def zip[I](that: Iterable[B]): List[(I, J)]

The iterable “that” provides the result of the second half pair from the new iterable collection. “List” is the resulting collection that is formed by combining a collection of elements in the list.

It returns an updated new scale holding a pair of corresponding elements from the original collection of lists. If the length of the two paired collections is the same, it will provide a zip of the same elements paired, or if the length of the two collections is not the same, then the pairing is done till the minimum length.

How to utilize Zip function in Scala in Ubuntu 20.04:

To understand the basics of using the zip function in Scala, we should take a look at the examples:

Example # 1: Using Zip function in Scala of the same length

As in the example, we are taking two collections of lists with the same length of the element just to get the new collection with the same length size as we have in the original one. Below we have an example code of using the Scala zip function for the same length of two collections that has to be paired and creating a new collection.

The code above has a class declared with “new”. We have the main function called where code is implemented in the class. We have variable values with the keyword “val”. The variable “val” is taking “L1” for list elements, and the second value of a variable is defined as “L2” for the other elements of the list. Then we have another variable that is actually using the Scala zip function for combining “L1” and “L2″ together. Printing the ” L3″ in print() function from the code.

As you can see, we got the result of the same length using the Scala zip function, and a new paired collection of lists was created.

Example # 2: Using Zip function in Scala of different length

Now we have the Scala zip function for different lengths of lists in this example code. Here we take one minimum length of the list to make a new collection of list elements. Let’s see the implementation of the code below.

In the example, the class is declared with the name “myList”, and our main is defined in the class. First, we define a variable with the keyword “val” representing “Lis1” and assign different values of list elements. Then we have another variable, “Lis2” which also has a list of elements in it, but not less than “Lis1” elements. So we are using the Scala zip function in a new variable, “Lis3” which will be a new collection of lists. Here we take another new variable, “Lis4” that will reverse the list in reverse order of pairing. Now printing the “Lis3” and “Lis4”.

Since we have “Lis2” less than “Lis1”, after using the Scala zip function, we have a length 4 of the paired list of the collection; also, we have the reverse order of the list in the output.

Example # 3: Using Zip function in Scala for string data type

Here, we are taking an example for the string data type for list elements in a list. We have a demonstration of this example as code below.

The class name is declared as “ABC” in the example code, which defines our main function. In the main function, we have variables with the “val” keyword defined as “playerList” that have different names of players in the list. Then we have a second variable as “sportList” and assign a different sports name which player plays. Using Scala zip functions, we have zipped “playerList ” and “sportList” together to get a new string collection. Observe that we use the foreach() method that will iterate elements of the list until the list elements have been processed by the method.

As it is presented in the output below from the above code implementation.

Example # 4: Using Zip function in Scala with the map function

We have another example of using the Scala zip function for map operation over the zipped collection and for other operational purposes. Let’s have an example code.

We have a class as “sum” of our main function that has a variable “S1” and “S2” which have assigned different numeric values and also the third variable as “S3”. Using the Scala zip function to zip “S1” and “S2” together. Now in our print statement, you can see we have used map function over zip function to sum the paired list values.

We are displaying the result from the zip collection of the list and map function that is done with zipped values. As it returned the sum of the list as output.


By all counts, we saw how the Scala zip function works with the different illustrations along with the codes. Also, how it helps in creating a new pair collection in Scala. We can also reverse the zip collection to get the original lists of collections, so Scala zip functions are good for approaching object-oriented programming.

About the author

Saeed Raza

Hello geeks! I am here to guide you about your tech-related issues. My expertise revolves around Linux, Databases & Programming. Additionally, I am practicing law in Pakistan. Cheers to all of you.