Bir dizi yüklemeye göre nasıl iki parçaya bölünür?

Bir diziyi bir yüklemeye göre iki listeye nasıl bölerim?

Alternatif: Kullanabilir filterve filterNotveya kendi yöntemimi yazabilirim, ancak daha genel (yerleşik) bir yöntem yok mu?

partitionYöntemi kullanarak :

scala> List(1,2,3,4).partition(x => x % 2 == 0)
res0: (List[Int], List[Int]) = (List(2, 4),List(1, 3))

İyi partitionİstediğin şeydi - ayrıca ikiye listesini bölmek için bir yüklemi kullanan başka bir yöntem var: span.

İlki, bölüm tüm "true" öğeleri bir listeye ve diğerlerini ikinci listeye koyacaktır.

span , bir öğe "yanlış" olana kadar (yüklem açısından) tüm öğeleri tek bir listeye koyacaktır. Bu noktadan sonra, öğeleri ikinci listeye koyacaktır.

scala> Seq(1,2,3,4).span(x => x % 2 == 0)
res0: (Seq[Int], Seq[Int]) = (List(),List(1, 2, 3, 4))

Scalex.org'a bir göz atmak isteyebilirsiniz - bu, scala standart kitaplığında işlevleri imzalarına göre aramanıza olanak tanır. Örneğin, şunu yazın:

List[A] => (A => Boolean) => (List[A], List[A])

Bölme göreceksiniz .

Biraz fazladan bir şeye ihtiyacınız varsa foldLeft'i de kullanabilirsiniz. Bölüm kesmediğinde böyle bir kod yazdım:

val list:List[Person] = /* get your list */
val (students,teachers) = 
  list.foldLeft(List.empty[Student],List.empty[Teacher]) {
    case ((acc1, acc2), p) => p match {
      case s:Student => (s :: acc1, acc2)
      case t:Teacher  => (acc1, t :: acc2)
    }
  }

Partiye geç kalabileceğimi ve daha spesifik cevaplar olduğunu biliyorum, ancak şunu iyi bir şekilde kullanabilirsiniz: groupBy

val ret = List(1,2,3,4).groupBy(x => x % 2 == 0)

ret: scala.collection.immutable.Map[Boolean,List[Int]] = Map(false -> List(1, 3), true -> List(2, 4))

ret(true)
res3: List[Int] = List(2, 4)

ret(false)
res4: List[Int] = List(1, 3)

Bu, koşulu boole olmayan bir şeye dönüştürmeniz gerekiyorsa kodunuzu biraz daha geleceğe hazır hale getirir.

Bir listeyi 2'den fazla parçaya bölmek ve sınırları göz ardı etmek istiyorsanız, bunun gibi bir şey kullanabilirsiniz (ints'i aramanız gerekiyorsa değiştirin)

def split(list_in: List[String], search: String): List[List[String]] = {
  def split_helper(accum: List[List[String]], list_in2: List[String], search: String): List[List[String]] = {
    val (h1, h2) = list_in2.span({x: String => x!= search})
    val new_accum = accum :+ h1
    if (h2.contains(search)) {
      return split_helper(new_accum, h2.drop(1), search) 
    }
    else {
    return accum
    }
  }
  return split_helper(List(), list_in, search)
}

// TEST

// split(List("a", "b", "c", "d", "c", "a"), {x: String => x != "x"})