Accéder à l'élément suivant dans la liste de comparer en Scala

Je suis nouveau à la Scala et je me demandais comment vous pouvez appeler le prochain élément de la liste parce que je suis en train de comparer l'état actuel de l'élément adjacent.
X donné que l'élément en cours, j'ai essayé similaire à java, x+1, mais qui n'a pas fonctionné. Toute aide?

for (x <- list; if (x == (next adj. element))) println("same")
S'il vous plaît poster un peu de code. Si x est la valeur (value) de l'élément courant, alors x+1 n'est pas d'être le prochain élément de Java. Si c'est l'indice de l'élément suivant, puis les choses devraient fonctionner.

OriginalL'auteur Dan | 2011-04-20

  1. 29

    Comment sur coulissantes?

    val list = List(1,2,3,4)
list.sliding(2).foreach(println)

//List(1, 2)
//List(2, 3)
//List(3, 4)

    OriginalL'auteur Landei

  2. 7

    Canonique de façons de le faire dans un for boucle serait:

    scala> val xs = List(1,2,3,4,3,2)
xs: List[Int] = List(1, 2, 3, 4, 3, 2)

scala> for (List(left,right) <- xs.sliding(2) if (left < right)) println(left + " < " + right)
1 < 2
2 < 3
3 < 4

scala> for ((left,right) <- (xs zip xs.tail) if (left < right)) println(left + " < " + right)
1 < 2
2 < 3
3 < 4

    (Soit dit en passant, vous êtes probablement mieux de mettre de l'instruction si l'extérieur plutôt qu'à l'intérieur de la compréhension dans cet exemple).

    Si vous avez des indices au lieu de valeurs, vous venez de déréférencer utilisant le même modèle. Personnellement, je ne trouve pas ce modèle très clair et utile. C'est lent, a bizarre coin-cas avec des listes qui ne sont pas complet, et il est difficile de suivre ce qu'il se passe. Au lieu de cela, je définir

    class PairedIterable[A](it: Iterable[A]) {
  def foreachpair(f: (A,A) => Unit) = {
    val i = it.iterator
    if (i.hasNext) {
      var prev = i.next
      while (!ans && i.hasNext) {
        val x = i.next
        f(prev,x)
        prev = x
      }
    }
  }
}
implicit def iterable_has_pairs[A](it: Iterable[A]) = new PairedIterable(it)

    qui peut ensuite être utilisé comme:

    scala> xs.foreachpair((left, right) => if (left < right) println(left + " < " + right))
1 < 2
2 < 3
3 < 4

    Variantes "forallpair", "existspair", et "findpair" sont particulièrement utiles.

    OriginalL'auteur Rex Kerr

  3. 3

    Ce serait mieux géré par les recursing sur le liste, au lieu d'une itération à travers le éléments, puisque les éléments ne sais rien à propos de la liste.

    Par exemple:

    def recurse[T](list: List[T]): Unit = list match {
    case List(x, y, _*) if x == y => 
        println("same")
        recurse(list.tail)
    case Nil =>
    case _   => recurse(list.tail)
}

    OriginalL'auteur Daniel C. Sobral

  4. 2

    Comme une option que vous pouvez utiliser match et récursivité au lieu de for:

    object Test {
  def main(args: Array[String]) {
    val list = List(1, 5, 3)
    loop(list)
  }

  def loop(list: List[Int]) {
    list match {
      case Nil => println("Empty list")
      case x :: Nil => println("last " + x)
      case x :: tail => {
        println(x + " - " + tail.head)
        loop(tail)
      }

    }
  }
}
    Vous pouvez même le faire case head :: second :: rest => ...

    OriginalL'auteur tonek

  5. 2
    scala> val xs = 1::3::5::4::Nil
xs: List[Int] = List(1, 3, 5, 4)

scala> (xs, xs.tail).zip.foreach(println)
(1,3)
(3,5)
(5,4)

scala>

    OriginalL'auteur Eastsun

  6. 0
    scala> val li = List (3, 4, 5) 
li: List[Int] = List(3, 4, 5)

scala> li.tail.head 
res74: Int = 4
    mais im essayant d'itérer sur la liste avec une boucle for. je ne vois pas comment cela pourrait fonctionner. comme pour (l < li; if (l != l+1))....
    Le message subliminal est que vous le faites mal. 🙂

    OriginalL'auteur user unknown

  7. 0

    liste.de la queue.tête

    donne à l'élément suivant si vous voulez aller à travers tous les éléments de l'avant de la liste. C'est parce que la tête est à l'avant-plus d'élément et de la queue est le reste de la liste.

    OriginalL'auteur Chris Murphy

  8. 0

    Comme dans Scala 2.11.7 suivantes sont valides:

    scala> val xs = List(1,2,3,4)
xs: List[Int] = List(1, 2, 3, 4)

    1) Zip la queue

    scala> xs.zip(xs.tail)
res0: List[(Int, Int)] = List((1,2), (2,3), (3,4))

    2) faites Glisser la fenêtre

    scala> xs.sliding(2)
res1: Iterator[List[Int]] = non-empty iterator

    OriginalL'auteur Kyr