在Scala中遍历集合的奇数成员

在Scala中，基于索引位置，仅迭代集合的奇数成员的有效方法是什么

鉴于这一名单：

val fruits: List[String] = List("apples", "oranges", "pears", "bananas")

我想跳过苹果和梨，加工橙子和香蕉。谢谢

根据给出的回复进行更新：

哇，前三名的答案都有优点。从Scala集合语法的角度来看，我最初指的是“高效”一词，我只是在寻找一种巧妙的方法来为后续迭代创建子列表@Senia在引入slide（）函数方面做得很好，非常适合这个特定的用例，但我也喜欢@Brian使用zipWithIndex（）的更通用的方法

然而，当我考虑问题的实际措辞和最初的回答时，我认为他会为此而获奖。

scala> List("apples", "oranges", "pears", "bananas").drop(1).sliding(1, 2).flatten.toList
res0: List[java.lang.String] = List(oranges, bananas)

zipWithIndex将列表中的每个元素与一个索引配对，该索引给出：

List[（String，Int）]=List（（苹果，0），（橘子，1），（梨，2），（香蕉，3））

使用

过滤器（u.\u 2%2==1）过滤奇数元素

给出：

List[（String，Int）]=List（（橘子，1），（香蕉，3））

通过使用

.map（u.\u 1）

获取每个元组的第一个元素，将列表[（String，Int）]映射为仅列出[String]：

---

List[String]=List（橙子、香蕉）

我将提出另一种方法，使用递归，在我看来，它似乎尽可能少地进行操作，即使它没有其他解决方案那么花哨

def iterateOdd(myList:List[String]):List[String] = myList match{
  case _::odd::tail => odd::iterateOdd(tail)
  case _ => Nil
}

或者，如果您只想处理奇数成员

def iterateOdd(myList:List[String]):Unit = myList match{
  case _::odd::tail => println(odd); iterateOdd(tail)
  case _ =>   
}

---

下面是一种直接迭代奇数项的方法：

val fruits: List[String] = List("apples", "oranges", "pears", "bananas")
//> fruits  : List[String] = List(apples, oranges, pears, bananas)

val oddFruitsIterator = 
  Iterator.from(1, 2).takeWhile(_ < fruits.size).map(fruits(_))
//> oddFruits  : Iterator[String] = non-empty iterator

oddFruitsIterator.foreach(println)                      
//> oranges
//> bananas

请注意，迭代器本身与它所迭代的集合是分开的。下面是另一个更清楚的例子：

scala> val oddSeqIterator = 
   (seq: Seq[String]) => Iterator.from(1, 2).takeWhile(_ < seq.size).map(seq(_))
oddSeqIterator: Seq[String] => Iterator[String] = <function1>

scala> val fruits: List[String] = List("apples", "oranges", "pears", "bananas")
fruits: List[String] = List(apples, oranges, pears, bananas)

scala> oddSeqIterator(fruits)
res0: Iterator[String] = non-empty iterator

scala> res0.foreach(println)
oranges
bananas

scala>val oddseq迭代器=
（seq:seq[String]）=>Iterator.from（1,2）.takeWhile（迭代器[String]=
scala>val水果：列表[字符串]=列表（“苹果”、“橙子”、“梨”、“香蕉”）
水果：列表[串]=列表（苹果、桔子、梨、香蕉）
scala>OddSeq迭代器（水果）
res0:迭代器[字符串]=非空迭代器
scala>res0.foreach（println）
橘子
香蕉

• 我有另一种方法来解决这类问题
• 我们可以利用List.range（start，end）方法

列表。范围（0,5）将给出列表（0,1,2,3,4）

• 我们可以生成索引列表并对其进行筛选
  scala>val水果：列表[字符串]=列表（“苹果”、“橙子”、“梨”、“香蕉”）
  scala>List.range（0，fruits.length）.filter（%2！=0）.map（x=>fruits（x））
  res0:List[String]=列表（桔子、香蕉）

---

另一种选择，基于以下两种方法的组合：按对划分项目（这提供了一种以奇数位置访问项目的简便方法）和处理奇数长度的集合：

// val fruits = List("apples", "oranges", "pears", "bananas", "tomatoes")
fruits.grouped(2).collect { case a :: b => b }.toList
// List("oranges", "bananas")

---

或者，当你有一个

过滤器

后跟一个

映射

，你可以使用

收集

，例如，

水果.zipWithIndex.collect{case（item，idx），如果idx%2==1=>item}

这篇文章真不错！Scala集合包证明了它在分布式计算中的使用是合理的。到目前为止，没有一个答案通过奇数成员相互作用。相反，它们生成了一个奇数成员列表（当然，可以对其进行迭代）。但是，必须有一种简单的方法直接迭代它们？List。范围（0,5）将给出List（0,1,2,3,4）

scala> val oddSeqIterator = 
   (seq: Seq[String]) => Iterator.from(1, 2).takeWhile(_ < seq.size).map(seq(_))
oddSeqIterator: Seq[String] => Iterator[String] = <function1>

scala> val fruits: List[String] = List("apples", "oranges", "pears", "bananas")
fruits: List[String] = List(apples, oranges, pears, bananas)

scala> oddSeqIterator(fruits)
res0: Iterator[String] = non-empty iterator

scala> res0.foreach(println)
oranges
bananas

// val fruits = List("apples", "oranges", "pears", "bananas", "tomatoes")
fruits.grouped(2).collect { case a :: b => b }.toList
// List("oranges", "bananas")