17장 collections

17.1 Sequences

시퀀스 타입은 정렬된 데이터를 보여준다.

Lists
- 리스트의 head에서 아이템을 추가/삭제하는 것은 빠르다. -> pattern matching works well [Chapter 15]
- 불변성 -> 정확하고, 효율적인 알고리즘을 개발할 때 (리스트의 복사본을 만들 필요가 없기 때문에)
- 임의의 인덱스에 있는 아이템에 접근은 빠르지 않다. (인덱스에 접근하기 위해 리스트를 연속적으로 반복해야 하기 때문에)

Arrays
- 임의의 엘리먼트 접근 및 0기반의 인덱스로 엘리먼트를 얻거나 업데이트 하는 것이 쉽다.
- 스칼라의 배열은 Array(1,2,3), 자바의 배열은 Array[1,2,3]
List buffers
- List에 엘리먼트를 추가하면 마지막에 reverse를 호출하게 된다. >> 이걸 피하는 방법으로 사용
- ListBuffer는 mutable object이며
- += append +=: prepend, 엘리먼트를 추가하고 toList를 호출하면 List가 생성된다.
- 스택오버플로우의 가능성을 제거한다.
Array buffers
- 시퀀스의 시작과 끝에 엘리먼트 추가/삭제하는 것을 빼고 Array와 비슷하다.
- ArrayBuffer를 사용하기 위해서는 scala.collection.mutable.ArrayBuffer를 import한다.
Strings (via StringOps)
- String은 StringOps로 implicit conversion되어 StringOps의 메소드를 사용할 수 있다.

17.2 Sets and maps

스칼라 collection에서는 immutable과 mutable한 Set/Map을 제공한다.
기본적으로 사용하는 Set/Map은 immutable이며 mutable을 사용하려면 명시적으로 import해야 한다.
immutable사용을 장려하는 차원으로, Predef에서 immutable을 쉽게 접근할 수 있도록 암시적으로 import했다.

    object Predef {  
     type Map[A, +B] = collection.immutable.Map[A, B]  
     type Set[A] = collection.immutable.Set[A]  
     val Map = collection.immutable.Map  
     val Set = collection.immutable.Set  
     // ...  
    }

한 소스파일에서 immutable과 mutable을 같이 쓰고 싶으면 패키지 이름으로 import한다.
scala> import scala.collection.mutable

Using sets
- Set은 키의 성질을 갖고 있어 동일한(==) 객체는 한 번밖에 저장되지 않는다.

Using maps
- index가 0으로 시작하지 않는 것만 빼면 Array와 비슷하다.
- Map을 생성할 때는 key와 value의 타입을 지정해야 한다.
Default sets and maps
- 엘리먼트의 수에 따라 구현하는 클래스가 달라진다.
Sorted sets and maps
- 스칼라 라이브러리는 trait SortedSet과 trait SortedMap을 제공
- 이들을 구현한 TreeSet, TreeMap을 사용할 수 있다.
- 엘리먼트를 특정한 순서로 정렬해준다.

17.3 Selecting mutable versus immutable collections

스칼라는 collection에서 immutable을 mutable로 바꾸기 쉽게 문법설탕을 제공한다.

17.4 Initializing collections

collection을 생성하고 초기화하는 일반적인 방법

companion object에 있는 팩토리메소드에 초기 엘리먼트를 전달한다.

    scala> List(1,2,3)
    res0: List[Int] = List(1, 2, 3)

    scala> import scala.collection.mutable
    import scala.collection.mutable

    scala> val stuff = mutable.Set[Any](42)
    stuff: scala.collection.mutable.Set[Any] = Set(42)

    scala> stuff += "ab"
    res1: stuff.type = Set(ab, 42)

서로 다른 타입을 가지는 collection을 만들고 싶을 때: 타입 [Any]를 명시한다.

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

    scala> val numSet = TreeSet(num)
    <console>:12: error: No implicit Ordering defined for List[Int].
           val numSet = TreeSet(num)
                           ^
    scala> val numSet = TreeSet[Int]() ++ num
    numSet: scala.collection.immutable.TreeSet[Int] = TreeSet(1, 2, 3, 4, 5, 6)

    scala> val st = mutable.Set[Any](1)
    st: scala.collection.mutable.Set[Any] = Set(1)

    scala> st += "a"
    res2: st.type = Set(1, a)

    scala> val sSet = Set[Any]() ++ st
    sSet: scala.collection.immutable.Set[Any] = Set(1, a)

collection(1)으로 collection(2)을 초기화하고 싶을 때: collection(1)에 타입을 명시한다.

Converting to array or list
- toList나 toArray로 List/Array로 변환할 수 있다.
- List나 Array로 변환할 때 collection의 엘리먼트를 복사하기 때문에 collection이 크면 느리다.

Converting between mutable and immutable sets and maps
- empty메소드를 사용하여 collection을 생성하고 ++이나 ++=을 사용하여 엘리먼트를 추가한다.

17.5 Tuples

Array나 List와 달리 다른 타입의 오브젝트를 포함할 수 있다.
("String", 123, List(1,2,3))

tuple은 다른 타입의 오브젝트를 포함하고 있기 때문에 Traversable을 상속하지 않는다.
tuple의 엘리먼트는 ._위치(1부터 시작)로 접근할 수 있다.
tuple의 엘리먼트는 할당할 수 있는데, ()를 빼면 tuple이 할당된다.

    scala> ("String", 123, List(1,2,3))
    res10: (java.lang.String, Int, List[Int]) = (String,123,List(1, 2, 3))

    scala> val (a, b, c) = res10
    a: java.lang.String = String
    b: Int = 123
    c: List[Int] = List(1, 2, 3)

    scala>  val d, e, f = res10
    d: (java.lang.String, Int, List[Int]) = (String,123,List(1, 2, 3))
    e: (java.lang.String, Int, List[Int]) = (String,123,List(1, 2, 3))
    f: (java.lang.String, Int, List[Int]) = (String,123,List(1, 2, 3))

쓰기 쉽다.

Provide feedback

Saved searches