Scala Trait Traversable 第2部分

在前面的Set中，我们已经看到了Taversable类的一些操作。现在，在本集中，我们将感知到更多的操作。

这些操作如下。

转换操作：
转换操作是toList, toSeq, toArray, toStream, toSet, toMap, toIterable, and toIndexedSeq 。这些操作将Traversable的集合变为一个相对独立的东西。

例子 :

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating Set of numbers
        val q = Set(2, 7, 8, 15, 19)
 
        // Converting Set to an Array
        val r = q.toArray
 
        // Displaying an Array
        println(r)
    }
}

输出

[I@506e1b77

在这里，转换操作即 toArray将把上述的Set（或任何Traversable）转换成数组。

例子

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating Set of numbers
        val q = Set(2, 6, 3, 7, 15, 20)
 
        // Converting a Set to a List
        val r = q.toList
 
        // Displaying a List
        println(r)
         
    }
}

输出

List(20, 6, 2, 7, 3, 15)

在这里， toList将把任何Traversable的集合转换成一个列表。

例子

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating List of numbers
        val x = List(9, 10, 13, 15, 18, 19)
 
        // Converting a List to a Set
        val y = x.toSet
 
        // Displaying a Set
        println(y)
    }
}

输出

Set(10, 9, 13, 18, 19, 15)

在这里，转换操作，即toSet将把任何Traversable的集合转换成一个集合。

例子

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating Set of numbers
        val m = Set(2, 4, 6, 8, 11, 15)
 
        // Converting a Set to a Sequence
        val n = m.toSeq
 
        // Displaying a Sequence
        println(n)
    }
}

输出

ArrayBuffer(6, 2, 11, 8, 4, 15)

在这里，转换操作，即toSeq，将任何Traversable的集合转换为一个序列。这里生成的序列在矢量中被利用。

例子

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating Set of numbers
        val x = Set(8, 10, 13, 15, 18)
 
        // Converting a Set to an Iterable
        val y = x.toIterable
 
        // Displaying an iterable
        println(y)
    }
}

输出

Set(10, 13, 18, 8, 15)

在这里，转换操作即toIterable（它遍历集合中的所有元素）将把任何Traversable的集合转换成Iterable。

例子:

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating Set of numbers
        val x = Set(2, 4, 5, 6, 7, 9)
 
        // Converting a Set to an
        // Indexed sequence
        val y = x.toIndexedSeq
 
        // Displaying an Indexed sequence
        println(y)
    }
}

输出

Vector(5, 6, 9, 2, 7, 4)

在这里，转换操作即toIndexedSeq将任何Traversable转换为一个索引序列。这里生成的索引序列可以在字符串和矢量中使用。

示例

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating Set of numbers
        val x = Set(15, 17, 18, 19, 22, 25)
 
        // Converting a Set to a stream
        val y = x.toStream
 
        // Displaying a Stream
        println(y)
    }
}

输出

Stream(25, ?)

在这里，转换操作即toStream将任何Traversable的集合转换为一个流。这个流被懒散地枚举出来。

例子

// Scala program of Conversion operation
 
// Creating object
object Conversion
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a Set of parameters
        val x = Set("GfG" -> "CS portal", "Nidhi" -> "a Geek")
 
        // Converting a Set to a Map
        val y = x.toMap
 
        // Displaying a Map
        println(y)
    }
}

输出

Map(GfG -> CS portal, Nidhi -> a Geek)

这里，toMap将把任何Traversable转换为Map。一个Set或一个List必须有参数。
大小信息操作：
大小信息操作是nonEmpty, isEmpty, hasDefiniteSize, 和size这些操作可以指定给定的操作是有限的还是无限的。

示例 :

// Scala program of Size info operation
 
// Creating object
object Sizeinfo
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a map
        val x = Map("gfg" -> "cs", "nidhi" -> "geek")
 
        // Applying Size info operation
        val y = x.isEmpty
 
        // Displays true if map is
        // empty
        println(y)
    }
}

输出

false

这里，isEmpty检查Traversable集合是否为空。如果元素集合是空的，那么它将打印出true，如果它不是空的，那么它将打印出false。

示例

// Scala program of Size info operation
 
// Creating object
object Sizeinfo
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a map
        val x = Map("gfg" -> "cs", "nidhi" -> "geek")
 
        // Applying Size info operation
        val y = x.nonEmpty
 
        // Displays true if map is
        // not empty
        println(y)
    }
}

输出

true

这里， nonEmpty检查Traversable集合是否包含元素。如果集合中有元素，那么它显示为true，否则为false。

例子:

// Scala program of Size info operation
 
// Creating object
object Sizeinfo
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a map
        val q = Map("gfg" -> "cs", "nidhi" -> "geek",
                                    "geeta" -> "coder")
 
        // Applying Size info operation
        val r = q.size
 
        // Displays size of the Map
        println(r)
    }
}

输出

在这里， size被用来评估可穿越集合的大小。

例子

// Scala program of Size info operation
 
// Creating object
object Sizeinfo
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a map
        val q = Map("gfg" -> "cs", "nidhi" -> "geek",
                                    "geeta" -> "coder")
 
        // Applying Size info operation
        val r = q.hasDefiniteSize
 
        // Displays true if number of
        // elements in Map are finite
        println(r)
    }
}

输出

true

这里， hasDefiniteSize被用来检查Traversable集合是否有有限元素。如果集合是有限的，那么它返回true，否则返回false。
元素检索操作：
元素检索操作包括last, head, lastOption, headOption, 和 find 。这些操作被用来检索Traversable集合的第一个或最后一个元素，或者检索与给定条件对应的第一个元素。

例子 :

// Scala program of Element
// retrieval operation
 
// Creating object
object Retrieval
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a Set of numbers
        val x = Set(12, 13, 14, 15)
 
        // Applying element retrieval
        // operation
        val y = x.lastOption
 
        // Displays last element
        // of the Set
        println(y)
    }
}

输出

Some(15)

这里，Traversable的最后一个元素由lastOption返回。所述的集合必须是有序的，如果集合中没有任何元素，那么将返回None。

例子

// Scala program of Element
// retrieval operation
 
// Creating object
object Retrieval
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a Set of numbers
        val x = Set(12, 13, 14, 15)
 
        // Applying element retrieval
        // operation
        val y = x.last
 
        // Displays last element
        // of the Set
        println(y)
    }
}

输出

这里，last将返回所述集合的最后一个元素。该集合必须是有序的，如果它不是有序的，那么将返回一些随机的元素。

例子

// Scala program of Element
// retrieval operation
 
// Creating object
object Retrieval
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a List of numbers
        val q = List(12, 24, 36, 48)
 
        // Applying element retrieval
        // operation
        val r = q.head
 
        // Displays first element
        // of the List
        println(r)
    }
}

输出

这里，如果Traversable集合是有序的，head将返回该集合的第一个元素；如果集合不是有序的，则返回任何随机元素。

例子

// Scala program of Element
// retrieval operation
 
// Creating object
object Retrieval
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Creating a List of numbers
        val x = List(8, 10, 21, 17, 29)
 
        // Applying element retrieval
        // operation
        val y = x.find(_ % 3 == 0)
 
        // Displays first element
        // matching the condition
        println(y)
 
    }
}

输出

Some(21)

在这里， find将检索出集合中符合所述条件的第一个元素。

例子:

// Scala program of Element
// retrieval operation
 
// Creating object
object Retrieval
{
 
    // Main method
    def main(args: Array[String])
    {
     
        // Creating List of numbers
        val p = List(7, 9, 11, 19, 21)
 
        // Creating a empty List
        val q = List()
 
        // Applying element retrieval
        // operation
        val r = p.headOption
        val s = q.headOption
 
        // Displays first element
        // if the List is not empty
        println(r)
        println(s)
    }
}

输出