Scala Trait Traversable | Set-1

Last Updated : 12 Apr, 2019

Introduction:
A root trait of the entire class of the Scala collections is Trait Traversable. It is available at the uppermost position of the collection hierarchy. It has uniquely one abstract operation, which is foreach. Here each of the operations are assured to be executed in a single-threaded approach.
Syntax:

def foreach[U](f: Elem => U)

Here, the operation f is concerned with all the elements of the collection and Elem => U is the type of operation, where “Elem” is the type of elements in the Scala’s collection and “U” is an inconsistent result type.

Some Important points:

Traversable is accomplished by the Scala’s Collection classes.
It is obligatory for Traversable to define foreach method only, as Traversable can inherit all the other methods.
The foreach method could traverse all the elements of the Scala’s collection class.
There are numerous concrete methods which are defined by Traversables.
List, Array, Map, Set, and many more are the subclass of Traversables.

Operations performed by the Class Traversable are as follows:

Abstract Method:
The only abstract method here is foreach, which can traverse over all the elements of the Collection.
Example :

   //Scala program of abstract method 
  
//Creating object  
object CS  
{ 
    //Main method 
    def main(args: Array[String])  
    { 
        //Creating an Array of elements 
        val x = Array("GEEKS", "FOR", "GEEKS") 
  
        //Calling foreach method 
        x.foreach { E =>
        val y = E.toLowerCase 
  
        //Display strings 
        println(y) 
        } 
    } 
} 
 
  

Output:

  geeks  for  geeks

Here, all the elements of the Array stated above are traversed by foreach method and then they are converted from uppercase to lowercase.
Example:

   // Scala program of abstract method 
  
// Creating object  
object GFG 
{ 
    // Main method 
    def main(args: Array[String])  
    { 
        //Creating list of numbers 
        val l = List(2, 6, 8, 7, 10, 11, 13) 
  
        //Calling foreach and displaying 
        //numbers of list after  
        //multiplication each of them 
        l.foreach(n => println(n * 6)) 
    } 
} 
 
  

Output:

  12  36  48  42  60  66  78

Here, foreach method traverses all the numbers of the list and multiplies each of them.

Addition operation:
Here, Addition operation i.e, ++ adds two Traversables together or adds each of the elements of an iterator to a Traversable.
Example:

   // Scala program of addition operation 
  
// Creating object  
object GFG 
{ 
    // Main method 
    def main(args: Array[String])  
    { 
        // Creating set of numbers 
        val x = Set(7, 8, 9, 10) 
  
        // Creating list of numbers 
        val y = List(1, 5, 8, 18) 
  
        //performing addition operation 
        val s1 = x ++ y 
        val s2 = y ++ x 
  
        //Displaying set 
        println(s1) 
  
        //Displaying list  
        println(s2) 
    } 
} 
 
  

Output:

  Set(5, 10, 1, 9, 7, 18, 8)  List(1, 5, 8, 18, 7, 8, 9, 10)

Here, when a Set is added to a List then a Set is generated and when a List is added to a Set then a List is generated.

Map operations:
The three Map operations are map, flatMap, and collect.
These Map operations create a new collection by assigning a few function to the elements of Scala collection.
Example :

   // Scala program of Map operations 
  
// Creating object  
object GFG 
{ 
  
    // Main method 
    def main(args: Array[String])  
    { 
  
        // Creating Set of numbers 
        val x = Set(8, 9, 5, 10) 
  
        // Applying map operation 
        val y = x.map(_ * 9) 
  
        // Displaying Set  
        println(y) 
    } 
} 
 
  

Output:

  Set(72, 81, 45, 90)

Here, the Map operation (i.e, map) will assign the stated function on each elements of a Traversable and will return a new collection as output.
Example :

   // Scala program of Map operations 
  
// Creating object  
object GFG 
{ 
  
    // Main method 
    def main(args: Array[String])  
    { 
  
        // Creating a List of lists 
        val q = List(List(7), List(8, 9, 10), List(11, 12, 13)) 
  
        // Applying map operation 
        val r = q.flatMap(_.map(_ + 3)) 
  
        // Displaying List 
        println(r) 
    } 
} 
 
  

Output:

  List(10, 11, 12, 13, 14, 15, 16)

Here, the flatMap will assign the stated function on each elements within the elements and then will Concatenate the output.
Example :

   // Scala program of Map operations 
  
// Creating object  
object GFG 
{ 
  
    // Main method 
    def main(args: Array[String])  
    { 
  
        // Creating List of numbers 
        val x = List(9, 3, 5, 11, 15, 4) 
  
        // Applying map operation  
        val y = x.collect  
        { 
  
            // Partial function 
            case z : Int if (z % 3 == 0) => z + 2
        } 
  
        //Displaying list 
        println(y) 
    } 
} 
 
  

Output:

  List(11, 5, 17)

Here, collect will assign a partial function to each elements of Traversable and will give a non-identical collection as output.

Program to convert Java Set of strings to a Traversable in Scala

nidhi1352singh

Improve

Article Tags :

Scala
Scala

Scala Trait Traversable | Set-1

Similar Reads