Scala Работа со списками

isEmpty

ls.isEmpty // true или false

length

List(1, 2, 8).length // 3

sum

List(1, 2, 3).sum // 6

max

List(1, 2, 3, 0).max // 3

min

List(1, 2, 0, 3).min // 0

head

List(10, 2, 3).head // 10

tail

List(10, 2, 3).tail // List(2, 3)

init

List(10, 2, 3).init // List(10, 2)

last

List(10, 2, 30).last // 30

foreach

ls.foreach((i: Int) => println(i))

ls.foreach(i => println(i))

ls.foreach(println)

for

for (s <- ls) println(s.toUpperCase)

for ((elem, count) <- ls.zipWithIndex) {
println(s”element $count is $elem”)
}

for (e <- ls) yield e * 2 // новый список из старого

for {
c <- ls
if c.startsWith(“M”)
} yield c

distinct

List(1, 1, 2, 2, 3).distinct // 1, 2, 3

filter

val v = List(1, 2, 3)
v.filter(_ > 1)  // List(2, 3)

list.filter {
case s: String => true
case _ => false

}

map

val v = List(1, 2, 3)
v.map(_ * 2) // List(2, 4, 6)

flatten

val ls = List(List(1,2), List(3,4))

ls.flatten // List[Int] = List(1, 2, 3, 4)

flatMap

List(“1”, “2”, “three”, “4”, “one hundred seventy five”).flatMap(toInt).sum // 7

zip

val prices = List(5.0, 20.0, 9.95)
val quantities = List(10, 2, 1)

prices zip quantities // List((5.0, 10), (20.0, 2), (9.95, 1))

(prices zip quantities) map { p => p._1 * p._2 } //  List(50.0, 40.0, 9.95)

((prices zip quantities) map { p => p._1 * p._2 }) sum

zipAll

Значения по умолчанию для более короткого списка

List(5.0, 20.0, 9.95).zipAll(List(10, 2), 0.0, 1) // List((5.0, 10), (20.0, 2), (9.95, 1))

zipWithIndex

ls.zipWithIndex.max._2 // индекс наибольшего числа

ls.zipWithIndex.foreach {
case(el, count) => println(s”$count is $el”)
}

unzip

val (a,b) = List((“a”,4), (“b”,5)).unzip // (List(a, b),List(4, 5))

sorted

val ls = List(List(“kim”, “al”), List(“julia”, “terry”))

ls.flatten.map(_.capitalize).sorted // List[String] = List(Al, Julia, Kim, Terry)

sortWith

List(10, 5, 8, 1, 7).sortWith(_ < _) // List(1, 5, 7, 8, 10)

reverse

List(1, 2, 3).reverse // List(3, 2, 1)

drop

List(1, 2, 3, 4, 5).drop(2) // List(3, 4, 5)

dropWhile

List(1, 2, 9, 4, 7).dropWhile(_ < 6) // List(9, 4, 7)

dropRight

List(1, 2, 3, 4, 5).dropRight(2) // List(1, 2, 3)

take

List(1, 2, 3, 4, 5).take(2) // List(1, 2)

takeWhile

List(1, 2, 9, 4, 7).takeWhile(_ < 6) // List(4, 5)

takeRight

List(1, 2, 3, 4, 5).takeRight(2) // List(1, 2, 3)

slice

List(1, 2, 3, 4, 5).slice(1, 3) // List(2, 3)

groupBy

List(15, 10, 5, 8, 20, 12).groupBy(_ > 10) // Map(false -> List(10, 5, 8), true -> List(15, 20, 12))

partition

List(15, 10, 5, 8, 20, 12).partition(_ > 10) // (List(15, 20, 12), List(10, 5, 8))

span

List(15, 7, 22, 10, 5, 8, 26, 12).span(_ < 20) // (List(15, 7),List(22, 10, 5, 8, 26, 12))

splitAt

List(15, 10, 5, 8, 20, 12).splitAt(2) // (List(15, 10), List(5, 8, 20, 12))

reduceLeft

List(1, 2, 3, 4).reduceLeft(_ + _) // 10

ls.reduceLeft((x,y) => x + y)

List(1, 2, 3, 4).reduceLeft(_ * _) //  24

List(1, 2, 3, 4).reduceLeft(_ min _) // 1

ls.reduceLeft((x,y) => if (x > y) x else y)

reduceRight

List(1, 2, 3, 4).reduceRight(_ + _) // 10

reduce

List(1, 2, 3, 4).reduce(_ + _) // 10

foldLeft

List(1, 2, 3, 4).foldLeft(10)(_ + _) // 20

foldRight

List(1, 2, 3, 4).foldRight(10)(_ + _) // 20

scanLeft

List(1, 2, 3, 4).scanLeft(0)(_ + _) // List(0, 1, 3, 6, 10)

scanRight

List(1, 2, 3, 4).scanRight(0)(_ + _) // List(10, 9, 7, 4, 0)

force

(0 to 1000).view.map(pow(10, _)).map(1 / _).force // без создания промежуточной коллекции

match

lst match {
case 0 :: Nil => “0”
case x :: y :: Nill => x + y
case 0 :: tail => “0 … ”
case _ => “other”
}

range

List.range(1, 10) // List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

1 to 10 by 2 toList // List(1, 3, 5, 7, 9)

intersect

List(1, 2, 3, 4).intersect(List(1, 3, 5)) // List(1, 3)

diff

List(1, 2, 3, 4).diff(List(1, 3, 5)) // List(2, 4)

concat или :::

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

view

(1 to 100).view // lazy

mkString

List(1, 2, 3).mkString(“! “) // 1! 2! 3!

fill

List.fill(3)(“test”) // List(“test”, “test”, “test”)

tabulate

List.tabulate(5)(n => n * n) // List(0, 1, 4, 9, 16)