chap13 콜렉션 (Collections)

1. 콜렉션 계층도

scala의 콜렉션 계층도는 이렇다.
크게, set,map,seq






http://docs.scala-lang.org/tutorials/FAQ/collections.html


2. 수정가능한 콜렉션과 수정불가능한 콜렉션

 앞의 Map을 다룰때 한번 나왔었다, immutable, mutable한 Map
 수정불가능한것은 값이 변하지 않으니 안전하게 참조할 수 있어 좋다.
 스칼라에서는 별도 명시가 없을 경우 immutable 한 경우로 취급한다.

3. 시퀀스

 Vector는 Arraybuffer의 수정불가능한 버전, 각노드가 32개까지 자식을 가질 수 있는 트리로 구현된다. 백만개의 원소가 있는 벡터는 4개의 노드 레이어가 필요(10의6승 ~ 32의4승) 그래서 4번만의 접근이 가능.

 Range는 시퀀스의 모든값을 저장하지 않는다. 시작, 종료, 증가분만 저장, to, until 메소드로 생성된다.


4. 리스트

scala> val digits = List(4,2)

digits: List[Int] = List(4, 2)
scala> digits.head
res0: Int = 4
scala> digits.tail
res1: List[Int] = List(2)
scala> digits.tail.head
res2: Int = 2

:: 연산자로 리스트 멤버를 추가

scala> 9 :: digits
res4: List[Int] = List(9, 4, 2)

List에서 원소들을 방문할때 이터레이터를 사용하지만 스칼라에서는 재귀를 사용하는게 자연스럽다

scala> def sum(lst: List[Int]):Int =
     | if(lst==Nil) 0 else lst.head + sum(lst.tail)
sum: (lst: List[Int])Int

scala> sum(digits)
res5: Int = 6

5. 집합

scala> Set(1,2,3,4,5,6)
res10: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

순서를 보장하지 않는다,
집합은 원소가 hashCode 메소드의 값에 따라 정리되는 해시집합으로 구현된다.
해시집합에서 원소를 찾는 것은 배열이나 리스트에서 찾는것보다 훨씬 빠르다.

링크드 해시집합은 원소의 삽입순소를 기억한다.

scala> scala.collection.mutable.LinkedHashSet(1,2,3,4,5,6)
res15: scala.collection.mutable.LinkedHashSet[Int] = Set(1, 2, 3, 4, 5, 6)

6. 원소 추가/삭제

 ㄱ. 시퀀스 뒤에 추가 (:+) 혹은 앞에 추가(+:)
 ㄴ. 순서없는 콜렉션에 추가(+)
 ㄷ. 제거 (-)
 ㄹ. 대량 추가/제거(++/--)
 ㅁ. 리스트에대해서는 :: / ::: 선호
 ㅂ. 변경은 += , ++=, -=, --=
 ㅅ. 집합에 대해서는 ++, &, --


7. 리듀싱, 폴딩, 스캐닝

scala> List(1,7,2,9).reduceLeft(_-_)
res1: Int = -17
scala> List(1,7,2,9).reduceRight(_-_)
res2: Int = -13

reduceLeft : ((1-7) -2) -9 = -17
reduceRight : 1-(7-(2-9)) = - 13

초기값을 주고 시작할 수 도 있다.

scala> List(1,7,2,9).foldLeft(0)(_ - _)
res13: Int = -19

중간결과에 콜렉션을 얻을 수도 있다.

scala> (1 to 10).scanLeft(0)(_ + _)
res14: scala.collection.immutable.IndexedSeq[Int] = Vector(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)

scala> (1 to 10).foldLeft(0)(_ + _)
res15: Int = 55

8. 지핑

두개의 list를 합칠수도 있다.

prices: List[Double] = List(5.0, 20.0, 9.95)
quantities: List[Int] = List(10, 2, 1)
scala> prices zip quantities
res16: List[(Double, Int)] = List((5.0,10), (20.0,2), (9.95,1))

갯수가 같아서 망정이지
한쪽이 적으면 적은수 기준으로 많은쪽 컬렉션의 원소들은 zip에서 제외된다.
하지만 디폴트값으로 예방할 순 있다.

scala> prices zipAll(List(10,2),0.0,1)
res21: List[(Double, Int)] = List((5.0,10), (20.0,2), (9.95,1))

9. 스트림

이터레이터 비슷한 기능인데, '레이지' 개념을 바탕으로 한다.
따라서, 컬렉션의 필요하지 않은 남은 원소들을 계산하는 비용이 들지 않는 장점이 있다.

scala> def numsFrom(n : BigInt): Stream[BigInt] = n#::numsFrom(n +1)
numsFrom: (n: BigInt)Stream[BigInt]

scala> val tenOrMore = numsFrom(10)
tenOrMore: Stream[BigInt] = Stream(10, ?)

scala> tenOrMore.tail
res0: scala.collection.immutable.Stream[BigInt] = Stream(11, ?)

scala> val squares = numsFrom(1).map(x=>x*x)
squares: scala.collection.immutable.Stream[scala.math.BigInt] = Stream(1, ?)

scala> squares.take(5).force
res1: scala.collection.immutable.Stream[scala.math.BigInt] = Stream(1, 4, 9, 16, 25)

10 병렬콜렉션

par 메소드는 콜렉션의 병렬구현을 생성한다.

scala> for (i <- (0 until 100).par) print ( i + " ")
0 50 51 52 25 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 7 ...

순서대로 안나오는거 보면 병렬을 하는거 싶기도하다.