엄범


filterNotNull() : 널이 아닌 값만 추리고 싶은 경우

```kt
>>> val l = listOf(1, 2, null, 4, 5)
>>> println(l.filterNotNull())
[1, 2, 4, 5]
```

Note ) 걸러내고 난 결과 컬렉션의 타입은 ``kt null``이 제거되었으므로 ``kt List<Int>`` 타입이 된다.


filterIsInstance<T>() : 특정 타입만 추리고 싶은 경우

```kt

>>> val li = listOf(1, "b", 3)

>>> li.filterIsInstance<Int>()

[1, 3]

```


toTypedArray() : 배열을 넘겨야 하는데 데이터가 컬렉션에 들어있다면 배열로 변환

```kt
>>> val strings = listOf("a", "b", "c")
>>> println("%s/%s/%s".format(*strings.toTypedArray()))
a/b/c
```

toIntArray() : 박싱하지 않은 원시 타입 배열로 변환

```kt
val l = listOf(1, 2, 3)
l.toIntArray()
```

배열 n개 잡기

```kt
>>> val foo = List<Int>(3) {0}
>>> foo
[0, 0, 0]
```

빈 리스트 생성

```kt
val l = listOf<T>()
val l = emptyList<T>()
val l: List<Int> = ArrayList<Int>()    // 위 두개는 내부적으로 이렇게 처리되는거라, 직접 이렇게 써줘도 되기는 한다
// 다만 아래에 기술해 놓았 듯이 더 추상화 된 쪽을 쓰는게 좋으니까, 위에 있는 것을 사용하도록 하자.
```

컬렉션

코틀린 컬렉션은 자바 컬렉션과 동일한 클래스지만, 확장 함수를 이용해 더 많은 기능을 제공한다.

읽기 전용 컬렉션과 변경 가능 컬렉션

자바에서 컬렉션은 크게 ``java List / Set / Map``으로 구분할 수 있으며 코틀린에서 이를 사용하려면 다음 함수를 이용한다.

```kt

readonly      mutable

--------      -------

listOf        mutableListOf, arrayListOf

setOf         mutableSetOf, hashSetOf, linkedSetOf, sortedSetOf

mapOf         mutableMapOf, hashMapOf, linkedMapOf, sortedMapOf

```

  • 일반적으로 왼쪽에 있는 함수일 수록 사용을 권장하는 편이다.
  • 예를 들어 ``kt MutableList / ArrayList`` 둘 다 내부적으로는 ``kt ArrayList``로 컴파일 되기는 한다.
  • 전자는 아무 "가변 리스트"를 의미하므로 추후 코틀린 자료구조가 수정되면 더 좋은 자료구조로 변경될 수 있다. (조금 더 추상화 되어 있다.)
  • 반면 ``kt ArrayList``는 여기서는 딱 이 자료구조가 적합할 때 사용하는게 좋다.


``kt List<E>``자체는 interface지만 ``kt List<E>(3) {0}``과 같이 선언해서 사용할 수 있는데, 다음과 같이 인라인 되어 있기 때문이다. 최종적으로 반환되는건 ArrayList 객체지만, 타입은 List다. 그리고 List 계열이므로 read-only가 맞다.

```kt

@SinceKotlin("1.1")

@kotlin.internal.InlineOnly

public inline fun <T> List(size: Int, init: (index: Int) -> T): List<T> = MutableList(size, init)


public inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T> {

    val list = ArrayList<T>(size)

    repeat(size) { index -> list.add(init(index)) }

    return list

}

```

  • 코틀린 컬렉션은 읽기 전용 컬렉션 인터페이스 ``kt kotlin.collections.Collection``과 이를 상속해 기능을 확장한 변경 가능 컬렉션 인터페이스 ``kt kotlin.collections.MutableCollection``으로 나뉜다.
  • 웬만하면 ``kt val``를 사용하는 원칙과 같은 맥락에서, 웬만하면 읽기 전용 컬렉션을 사용한다.
  • Note ) 읽기 전용 컬렉션이 곧 불변(Immutable) 컬렉션을 의미하는 것은 아니다. 어떤 컬렉션에 대해 나는 읽기 전용 인터페이스로 접근 했는데, 다른 곳(또는 다른 스레드)에서는 변경 가능 인터페이스로 접근해 값을 변경한다면 컬렉션이 변경될 수 있다.
  • 따라서 읽기 전용 컬렉션이라고 thread safe하지는 않기 때문에 멀티스레드인 경우 동기화 문제를 고려해야 한다.


Note ) 컬렉션에 연산자 오버로딩은 웬만하면 사용하지 않는 것이 좋다.

연산자 오버로딩을 사용하면 아예 새로운 컬렉션을 만들어서 그 컬렉션을 가리키도록 변경되기 때문에, 읽기 전용 컬렉션을 ``kt var``로 선언한 경우 컬렉션이 변경되는 것 처럼 보일 수 있다.

```kt

>>> var l = listOf(1, 2, 3)    // val이면 연산자 오버로딩에서 에러 발생

>>> l += 4    // 이 때 아예 새로운 List가 반환된다.

>>> l.map({ println(it) })

1234

>>> val ml = mutableListOf<Int>(1, 2, 3)

>>> ml.add(4)

>>> ml.map({ println(it) })

1234

```


플랫폼 타입

자바에서는 읽기 전용 컬렉션을 따로 구분하지 않으므로 코틀린에서 읽기 전용이라도 자바에서는 그 컬렉션을 변경할 수 있다. 주의해야 한다.

* 같은 이슈가 non-null 타입에도 발생한다. 널이 될 수 없는 원소로 이루어진 컬렉션을 자바로 넘겼을 때, 자바에서 컬렉션에 ``kt null``을 넣어버릴 수도 있다.


또한 자바 쪽에서 선언한 컬렉션은 변경 가능성에 대해 알 수 없는 플랫폼 타입이므로 읽기 전용이나 변경 가능 어느 쪽으로든 다룰 수 있다.

보통 다음 세 가지 정도를 고려하면 된다.

  • 컬렉션 자체의 널 가능성
  • 컬렉션 원소의 널 가능성
  • 오버라이드 하는 메소드가 컬렉션을 변경할 수 있는지 여부


원소가 널 가능? 컬렉션 자체가 널 가능?

리스트 자체가 널 가능이면서 내부의 원소 ``kt Int``도 널이 될 수 있는 타입은 다음과 같다.
```kt
List<Int?>?
```


배열 - 컬렉션까지는 필요 없을 때.

배열을 사용해야 하는 경우는 주로 두 가지 정도다.

  • 배열을 인자로 받는 자바 함수를 호출하는 경우
  • ``kt vararg`` 파라미터를 받는 코틀린 함수를 호출하는 경우

박싱 타입 배열

```kt

>>> val a1 = arrayOf(1, 2, 3)

>>> a1.map({ println(it) })

123

>>> val a2 = arrayOfNulls<Int>(3)

>>> a2.map({ println(it) })

nullnullnull

>>> val a3 = Array<Int>(3) { i -> i+1 }

>>> a3.map({ println(it) })

123

```

``kt Array<Int>``는 제네릭 클래스처럼 보이지만 자바 배열로 컴파일된다. 원시 타입이 아니라 박싱 타입 배열로.

코틀린에서는 컬렉션에 사용할 수 있는 모든 확장 함수를 배열에도 제공한다. 단, 이런 함수가 반환하는 값은 배열이 아니라 리스트다.

원시 타입 배열

박싱하지 않은, 원시 타입 배열이 필요다하면 다음을 사용해야 한다.

```kt

// java int[] 대응

val primitive = IntArray(3)    // 0으로 초기화됨.

val primitive2 = intArrayOf(0, 0, 0)

val primitive3 = IntArray(3) { i -> i+1 }


CharArray()

ByteArray()

```


배열 순회 ( 반복 )

인덱스가 필요 없다면,
``kt map()``을 사용하는 방법,
``kt .forEach { }``를 사용하는 방법.

인덱스가 필요하다면
``kt .withIndex()``를 사용하는 방법, 
``kt .indices``를 사용하는 방법, 
``kt .forEachIndexed { }``를 사용하는 방법이 있다.
```kt
fun main(args: Array<String>) {
    args.forEachIndexed { i, s ->
        println("$i : $s")
    }
}
```


자바의 immutable?

```java

private static final Thing[] PRIVATE_VALUES = { ... };

public static final List<Thing> VALUES = 

    Collections.unmodifiableList(Arrays.asList(PRIVATE_VALUES));

```