Scala Trait Traversable 第1部分

简介：

Scala集合的整个类别的一个根属性是 Trait Traversable 它在集合层次结构的最上层是可用的。它只有一个抽象的操作，即 foreach 在这里，每个操作都保证以单线程的方式执行。

语法

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

这里，操作f关注的是集合中的所有元素， **Elem = > U **是操作的类型，其中 “Elem “是Scala的集合中元素的类型，”U “是不一致的结果类型。

一些重要的观点

Traversable是由Scala的Collection类完成的。
Traversable有义务只定义foreach方法，因为Traversable可以继承所有其他的方法。
foreach 方法可以遍历Scala的集合类中的所有元素。
有许多具体的方法都是由Traversables定义的。
List、Array、Map、Set等都是Traversables的子类。

Traversable类所进行的操作如下

抽象方法。
这里唯一的抽象方法是foreach，它可以遍历集合中的所有元素。

示例 :

//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)
        }
    }
}

输出:

geeks
for
geeks

在这里，上述数组的所有元素被foreach方法遍历，然后将它们从大写转换为小写。

示例:

// 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))
    }
}

输出:

在这里，foreach方法遍历了列表中的所有数字，并将它们一一相乘。

加法操作。
这里，加法操作，即++将两个遍历表加在一起，或者将一个迭代器的每个元素加到一个遍历表上。

示例:

// 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)
    }
}

输出:

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

在这里，当一个集合被添加到一个列表时，就会产生一个集合，当一个列表被添加到一个集合时，就会产生一个列表。

地图操作。
三个Map操作是map、flatMap和collection。
这些Map操作通过给Scala集合的元素分配一些函数来创建一个新的集合。

示例 :

// 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)
    }
}

输出:

Set(72, 81, 45, 90)

在这里，Map操作（即map）将在Traversable的每个元素上分配所述函数，并将返回一个新的集合作为输出。

示例 :

// 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)
    }
}

输出:

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

在这里，flatMap将对元素中的每个元素分配所述的函数，然后将输出串联起来。

示例 :

// 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)
    }
}

输出: