CIDA Lab @ UoS

프로그래밍 언어 실습 네 번째

Scala 기초 3: 리스트 관련 메서드

       

실습 진행 시 어려운 점이 있으면 이루리 게시판을 이용해 질문하세요. 게시판을 통해 하기 어려운 질문이라면 아래 조교님들의 이메일을 통해 문의하시기 바랍니다.

   

조교: 김수현(tngus988207@gmail.com), 최한준(95gkswns@naver.com)

   

또한 본 자료는 아래의 인터넷 자료들을 참고하여 만들어졌으니 추가적으로 궁금한 점이 있으면 참고하시기 바랍니다.

           

1. reverse
  • reverse 메소드는 리스트를 역순으로 반환합니다.
  • 실행 예시
scala> List(1, 2, 3).reverse
res0: List[Int] = List(3, 2, 1)

 

 

2. zipAll
  • 주어진 리스트와 요소들을 순서대로 짝 지어 반환합니다.
  • 두 번째와 세 번째 매개변수는 각각 리스트의 길이가 다를 때 남는 값들과 묶어주기 위한 기본값을 의미합니다.
  • 리스트의 길이가 다를 때, 남는 원소들을 기본값과 묶어줍니다.
  • 실행 결과
scala> List(1, 2, 3, 4, 5, 6, 7).zipAll(List(4, 5, 3), 'A', 'B')
res1: List[(AnyVal, AnyVal)] = List((1,4), (2,5), (3,3), (4,B), (5,B), (6,B), (7,B))

scala> List(4, 5, 3).zipAll(List(1, 2, 3, 4, 5, 6, 7), 'A', 'B')
res2: List[(AnyVal, AnyVal)] = List((4,1), (5,2), (3,3), (A,4), (A,5), (A,6), (A,7))

 

 

3. zipwithindex
  • 리스트의 각 원소들을 인덱스와 짝을 지어 튜플의 리스트로 반환해줍니다.
  • 실행 결과
scala> List('a','b','c').zipWithIndex
res3: List[(Char, Int)] = List((a,0), (b,1), (c,2))

 

 

4. map

  • 리스트의 모든 원소에 함수를 적용한 결과값으로 이루어진 새 리스트를 반환합니다.

  • 실행 결과

scala> List(1, 2, 3).map(_ + 2)
res6: List[Int] = List(3, 4, 5)

scala> List("scala","is","fun").map(_.toUpperCase())
res7: List[String] = List(SCALA, IS, FUN)

 

 

5. flatten
  • 리스트안에 여러 리스트들을 순서대로 합쳐 하나의 리스트로 반환합니다.
  • 실행 결과
scala> List(List(4, 5, 7), List(7, 8), List(1, 2, 3)).flatten
res8: List[Int] = List(4, 5, 7, 7, 8, 1, 2, 3)

 

 

6. flatMap
  • map과 flatten을 합성한 메서드로 중첩된 리스트 안의 각 리스트에 함수를 적용하여 나온 결과를 하나의 리스트로 합쳐서 반환합니다.
  • 실행 결과
scala> List("scala", "is", "fun").flatMap(_.toUpperCase())
res9: List[Char] = List(S, C, A, L, A, I, S, F, U, N)

 

 

7. sorted
  • 리스트를 정렬해서 반환합니다.
  • 실행 결과 
    scala> List(7, 6, 5, 1 ,4, 2).sorted
res10: List[Int] = List(1, 2, 4, 5, 6, 7)

 

 

8. take와 takeRight
  • take는 리스트에서 첫 번째 $n$개 원소를 반환하고, takeRight은 끝에서부터 $n$개 원소를 반환합니다.
  • 실행 결과
scala> List(7, 6, 5, 1, 4, 2).take(4)
res11: List[Int] = List(7, 6, 5, 1)

scala> List(7, 6, 5, 1, 4, 2).takeRight(4)
res12: List[Int] = List(5, 1, 4, 2)

 

 

9. filter
  • 전달된 함수가 거짓을 반환하는 원소들을 제외하고 나머지 원소들로 이루어진 리스트를 반환합니다.
  • 실행 결과
scala> List(7, 6, 5, 1, 4, 2).filter(_ % 2 == 0)
res13: List[Int] = List(6, 4, 2)

 

 

10. foldRight와 foldLeft
  • foldRight는 리스트 오른쪽부터, foldLeft는 리스트 왼쪽부터 기본값과 함수를 적용합니다.

  • List$(a_1, a_2, \ldots, a_n)(v_0)(f) = f(a_1, f(a_2, f(a_3, \ldots, f(a_n, v_0))))$

  • 실행 결과
scala> List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10).foldLeft(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n }
m: 0 n: 1
m: 1 n: 2
m: 3 n: 3
m: 6 n: 4
m: 10 n: 5
m: 15 n: 6
m: 21 n: 7
m: 28 n: 8
m: 36 n: 9
m: 45 n: 10

scala> List(3, 6, 9).foldRight(1)((x:Int, y:Int) => x + y)
res15: Int = 19

scala> List(3, 6, 9).foldRight(1)(_ - _)
res16: Int = 5

 

 

11. collect
  • case를 활용한 부분 함수를 매개변수로 전달하여 부분 함수를 만족하는 원소들을 묶어 리스트로 반환합니다.
scala> List(2, "B", 1).collect{ case i:Int => i + 1 }
res17: List[Int] = List(3, 2)

 

 

12. foreach
  • map과 비슷하지만 foreach는 실행 시 값을 반환하지 않습니다.
  • 상태를 변화시키기 위해 사용됩니다.
  • 실행 예시
scala> List(1, 2, 3, 4).foreach(x => println(x))
1
2
3
4

scala> val ls = List(1, 2, 3, 4).foreach((x:Int) => x*2)
ls: Unit = ()

 

 

13. isEmpty
  • 리스트가 비어있는지 확인합니다.
  • 실행 예시 
    scala> List(1, 2, 3).isEmpty
res1: Boolean = false

 

 

14. nonEmpty
  • 리스트안에 내용이 있는지 확인합니다.
  • 실행 예시 
    scala> List(1, 2, 3).nonEmpty
res1: Boolean = true

 

 

15. partition
  • 리스트의 원소들을 조건에 따라 나눈 후
  • 실행 예시 
    scala> List(1, 2, 3, 4).partition(_ % 2 == 0)
res1: (List[Int], List[Int]) = (List(2, 4),List(1, 3))

 

 

16. drop과 dropWhile
  • drop은 처음 $n$개의 원소를 제거합니다.
  • dropWhile은 리스트의 앞에서부터 주어진 조건식을 만족하는 원소들을 제거합니다. 조건식이 최초로 거짓을 반환하면 그 뒤의 원소들은 남깁니다.
  • 실행 예시
scala> List(1, 2, 3, 4).drop(2)
res1: List[Int] = List(3, 4)

scala> List(2, 4, 6, 7, 2, 4).dropWhile( _ % 2 == 0)
res2: List[Int] = List(7, 2, 4)

 

 

17. find
  • 리스트에서 함수를 만족하는 첫 원소를 반환합니다.
  • Option은 Scala에서 어떤 객체가 존재하거나 존재하지 않을 수 있을 때 사용하는 클래스입니다.
  • 실행 예시
scala>  List(2, 4, 6, 7, 2, 4).find( _ % 2 != 0)
res1:  Option[Int] = Some(7)

 

 

18. length
  • 리스트의 길이를 반환합니다.
  • 실행 예시
scala > List(1, 2, 3, 4).length
res1: Int = 4

 

 

19. head와 last
  • head는 리스트의 첫 원소를, last는 마지막 원소를 반환합니다.
  • 실행 예시
scala> List(1, 2, 3, 4).head
res1: Int = 1

scala> List(1, 2, 3, 4).last
res2: Int = 4

 

 

20. tail
  • 리스트의 첫번째 원소(head)를 제외한 나머지 원소들의 리스트를 반환합니다.
  • 실행 예시
scala> List(1, 2, 3, 4).tail
res1: List[Int] = List(2, 3, 4)

 

 

21. contains
  • 리스트에 매개변수로 주어진 원소가 존재한다면 true, 없다면 false 를 반환합니다.
  • 실행 예시
scala> List(1, 2, 3, 4).contains(3)
res1:Boolean = true

 

 

22. ++ 연산자
  • 두 개의 리스트를 연결하는 접속 연산자
  • 실행 예시
scala> List(1, 2, 3, 4) ++ List(5, 6, 7, 8)
res1:List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

 

 

23. :+ 연산자와 +: 연산자
  • :+는 리스트의 맨 뒤에, +:는 맨 앞에 원소를 추가하는 접속 연산자
  • 실행 예시
scala> List(1,2,3,4) :+ 2
res1: List[Int] = List(1, 2, 3, 4, 2)

 

 

24. max와 min
  • 리스트 안에 가장 큰 값, 또는 작은 값을 찾아 반환합니다.
  • 실행 예시
scala> List(1, 2, 3, 4).max
res0: Int = 4

scala> List(1, 2, 3, 4).min
res1: Int = 1

 

 

25. sum
  • 리스트 안의 모든 요소를 더한 값을 반환합니다.
  • 실행 예시
scala> List(1, 2, 3, 4).sum
res2: Int = 10

 

 

26. Range
  • 특정 범위에 해당하는 원소들을 순서대로 포함하는 객체
  • toList 메서드를 통해 Range 객체를 List로 변환 가능
  • 실행 예시
scala> (1 to 10).toList
res1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> (0 until 10).toList
res1: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
Search