Scala Trait 可遍历 |第 3 组

先决条件：
Scala Trait 可遍历 |第一组
Scala Trait 可遍历 |第 2 组
建议在本集之前查看(Set-1, Set-2)。
操作如下：

• 子集合检索操作：
  这里的操作是slice、drop、dropWhile、filter、filterNot、tail、take、takeWhile 和 init 。这些操作用于返回一些子集合。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(17, 19, 21, 29, 31)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.init 
    
          // Displays all the elements of 
          // the List except the last one
          println(y)
      }
  }
  

  输出：

  List(17, 19, 21, 29)
  

  在这里， init检索 Traversable 集合中除最后一个元素之外的所有元素。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(17, 19, 21, 29, 31)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.tail
    
          // Displays all the elements of 
          // the List except the first one
          println(y)
      }
  }
  

  输出：

  List(19, 21, 29, 31)
  

  在这里， tail检索 Traversable 集合中除第一个元素之外的所有元素。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(27, 29, 31, 49, 51, 56)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.slice(2, 5)
    
          // Displays the elements 
          // from index 2 to 4 
          println(y)
      }
  }
  

  输出：

  List(31, 49, 51)
  

  在这里， slice将返回给定索引范围内的元素，不包括最后一个索引。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(37, 49, 51, 69, 71, 86)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.take(2)
    
          // Displays the first two 
          // elements of the list
          println(y)
      }
  }
  

  输出：

  List(37, 49)
  

  在这里，此操作将返回在take操作的参数中给定的元素数量。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(33, 34, 36, 37, 39, 40, 44)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.drop(4)
    
          // Displays all the elements of 
          // the list except the first 
          // four elements
          println(y)
      }
  }
  

  输出：

  List(39, 40, 44)
  

  在这里，此操作将返回集合中的所有元素，除了drop操作参数中给出的第一个元素数。
  例子：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(2, 5, 9, 13, 17, 20)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.dropWhile(_ < 10)
    
          // Displays all the elements of 
          // the list which are greater 
          // than or equal to 10
          println(y)
      }
  }
  

  输出：

  List(13, 17, 20)
  

  在这里， dropWhile将删除元素，直到满足给定条件并返回剩余的左侧元素。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(2, 5, 9, 10, 13, 17, 20)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.takeWhile(_ < 13)
            
          // Displays all the elements of 
          // the list which are less 
          // than 13
          println(y)
      }
  }
  

  输出：

  List(2, 5, 9, 10)
  

  在这里， takeWhile将获取元素，直到满足给定条件并返回这些元素。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(9, 65, 99, 10, 23, 17, 12)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.filter(_ < 23)
    
          // Displays all the elements of 
          // the list which are less 
          // than 23
          println(y)
      }
  }
  

  输出：

  List(9, 10, 17, 12)
  

  在这里，过滤器将返回所有元素，直到满足给定条件并丢弃其余元素。
  例子 ：

  // Scala program of Sub-Collection
  // retrieval operation
    
  // Creating object 
  object SubCollection
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(9, 65, 99, 10, 23, 17, 12)
    
          // Applying Sub-Collection 
          // retrieval operation
          val y = x.filterNot(_ < 23)
    
          // Displays all the elements of 
          // the list which are greater 
          // than or equal to 23
          println(y)
      }
  }
  

  输出：

  List(65, 99, 23)
  

  在这里， filterNot将返回所有不满足给定条件的元素并丢弃其余元素。

• 细分操作：
  这些操作包括span、partition、splitAt、groupBy 。这些操作用于分解集合的元素并返回一些子集合。
  例子 ：

  // Scala program of Subdivision 
  // operations
    
  // Creating object 
  object Subdivision
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val q = List(7, 9, 11, 15, 17, 19, 22)
    
          // Applying Subdivision 
          // operations
          val r = q.span(_ < 15)
    
          // Displays all the elements in 
          // two parts
          println(r)
      }
  }
  

  输出：

  (List(7, 9, 11), List(15, 17, 19, 22))
  

  在这里， span会将给定的 Traversable 元素集合分成两部分，其中第一部分通过执行takeWhile操作获得，第二部分通过执行dropWhile操作获得。
  例子 ：

  // Scala program of Subdivision 
  // operations
    
  // Creating object 
  object Subdivision
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val q = List(17, 29, 31, 36, 37, 39, 42)
    
          // Applying Subdivision 
          // operations
          val r = q.partition(_ < 35)
    
          // Displays all the elements in 
          // two parts
          println(r)
      }
  }
  

  输出：

  (List(17, 29, 31), List(36, 37, 39, 42))
  

  在这里， partition将集合分为两部分，第一部分将返回元素，直到满足给定条件，第二部分将返回其余元素。
  例子 ：

  // Scala program of Subdivision 
  // operations
    
  // Creating object 
  object Subdivision
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val q = List(17, 29, 31, 36, 37, 39, 42)
    
          // Applying Subdivision 
          // operations
          val r = q.splitAt(4)
    
          // Displays all the elements in 
          // two parts
          println(r)
      }
  }
  

  输出：

  (List(17, 29, 31, 36), List(37, 39, 42))
  

  在这里， splitAt将集合的元素在给定位置分为两部分，其中第一部分将通过执行 take 操作获得，第二部分将通过执行 drop 操作获得。
  例子 ：

  // Scala program of Subdivision 
  // operations
    
  // Creating object 
  object Subdivision
  {
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(21, 20, 33, 40, 27, 62)
    
          // Applying Subdivision 
          // operation 
          val y = x.groupBy 
          {
    
              // Partial function
              case z : Int if (z % 3 == 0) => z + 3
              case z : Int if (z % 2 == 0) => z + 2
          }
        
          // Displaying Map of lists
          println(y)
      }
  }
  

  输出：

  Map(42 -> List(40), 24 -> List(21), 64 -> List(62), 22 -> List(20), 36 -> List(33), 30 -> List(27))

  在这里， groupBy将根据给定的偏函数划分 Traversable 集合，并返回一个 Map。

• 元素测试方法：
  这些方法包括forall、exists 和 count 。这些方法用于根据规定的条件测试给定的 Traversable 集合。
  例子 ：

  // Scala program of Element 
  // test
    
  // Creating object 
  object Elementtest
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(21, 20, 33, 40, 27, 62)
    
          // Applying Element test 
          // method
          val y = x forall (_ < 63) 
    
          // Displays true if all the 
          // elements are lesser 
          // than 63
          println(y)
      }
  }
  

  输出：

  true
  

  在这里，如果集合的所有元素都满足给定条件， forall将返回 true，否则返回 false。
  例子 ：

  // Scala program of Element 
  // test
    
  // Creating object 
  object Elementtest
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(21, 20, 33, 40, 27, 62)
    
          // Applying Element test 
          // method
          val y = x exists (_ < 30) 
    
          // Displays true if some of 
          // the elements are lesser 
          // than 30
          println(y)
      }
  }
  

  输出：

  true
  

  在这里，如果集合的某些元素满足给定条件， exists将返回 true，否则返回 false。
  例子 ：

  // Scala program of Element 
  // test
    
  // Creating object 
  object Elementtest
  {
    
      // Main method
      def main(args: Array[String]) 
      {
    
          // Creating List of numbers 
          val x = List(21, 20, 33, 40, 27, 62)
    
          // Applying Element test 
          // method
          val y = x count(_ < 40) 
    
          // Displays the number of 
          // elements satisfying the 
          // given condition
          println(y)
      }
  }
  

  输出：

  4
  

  在这里， count将显示满足给定条件的集合元素的数量。