Scala Trait 可遍历 |第一组

介绍：
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 ，它可以遍历 Collection 的所有元素。
例子：

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

在这里，上面所说的Array的所有元素都通过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 方法遍历列表的所有数字并将它们中的每一个相乘。

加法运算：
这里，加法运算，即++将两个Traversables相加或将迭代器的每个元素添加到Traversable中。
例子：

// 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和collect 。
这些 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)
    }
}

输出：

List(11, 5, 17)

在这里， collect将为 Traversable 的每个元素分配一个偏函数，并给出一个不相同的集合作为输出。