코틀린 (Kotlin) 컬렉션

코틀린 컬렉션

fun functionalFilter(numList : List<Int>) : List<Int> = numList.filter { it % 2 == 0 }
  • 코드 간결성/가독성 향상
  • 결과값을 저장하기 위한 별도의 리스트를 생성할 필요가 없다
  • 비즈니스 로직에 집중
  • 버그가 발생할 확률이 적다
  • 테스트가 용이
  • 유지보수가 용이

fun functionalMap(numList: List<Int>) : List<Int> {
    return numList.map { it + 2 }
}
  • map 함수는 내부적으로 새로운 리스트를 만들어서 반환 -> 부수효과 없음

tailrec fun<T, R> FunList<T>.map(acc: FunList<R> = FunList.Nil, f: (T) -> R): FunList<R> = when (this) {
    FunList.Nil -> acc.reverse()
    is FunList.Cons -> tail.map(acc.addHead(f(head)), f)
}
  • 제네릭과 고차함수를 활용해서 일반화된 함수를 만들고, 재사용성을 높이는 것이 함수적 접근 방식

명령형과 함수형의 차이

fun func(intList: List<Int>) =
    intList
        .map { n ->
            println("map=$n")
            n*n }
        .filter { n ->
            println("filter=$n")
            n < 10 }
        .first()

println(func(listOf(1,2,3,4,5))) //"1"출력


  • map 5번 실행, filter 5번 실행, first() 를 실행하기때문에 명령형보다 반복 계산이 많을 수 있음
코틀린에서 아래 상황에서는 컬렉션을 사용하지 않는것이 좋다
  • 성능에 민감할때
  • 컬렉션의 크기가 고정되어 있지 않을 때
  • 고정된 컬렉션 크기가 매우 클 때
코틀린의 컬렉션은 기본적으로 값이 즉시 평가되기 때문에 게으른 평가로 실행되지 않아 성능이 떨어진다.

시퀀스


fun seqFunc(intList: List<Int>) =
    intList
        .asSequence()
        .map { n ->
            println("map=$n")
            n*n }
        .filter { n ->
            println("filter=$n")
            n < 10 }
        .first()

시퀀스를 사용해서 성능을 향상 시킬수 있다.


Lazy 컬렉션

  • 람다로 매개변수를 받으면 Cons 생성되는 시점에 매개변수가 평가되지 않는다.

sealed class FunStream<out T> {
    object Nil : FunStream<Nothing>()
    data class Cons<out T>(val head: () -> T, val tail: () -> FunStream<T>) : FunStream<T>() 
}

fun <T> funStreamOf(vararg elements: T): FunStream<T> = elements.toFunStream()

fun <T> Array<out T>.toFunStream(): FunStream<T> = when {
    this.isEmpty() -> FunStream.Nil
    else -> FunStream.Cons({ this[0] }, { this.copyOfRange(1, this.size).toFunStream() })
}


fun <T> FunStream<T>.getHead(): T = when(this) {

    FunStream.Nil -> throw NoSuchElementException()
    is FunStream.Cons -> head()
}

fun <T> FunStream<T>.getTail(): FunStream<T> = when(this) {
    FunStream.Nil -> throw NoSuchElementException()
    is FunStream.Cons -> tail()
}
  • 리스트 크기가 클 때, Lazy 컬렉션처럼 사용하는 것이 성능에 좋다


무한대 값 만들기

  • generateFunSream()은 함수를 입력받기때문에 즉시 평가 되지 않는다.
  • 함수들은 실제로 평가될 때 어떤 일들을 해야 하는지만을 기록하고 있을뿐이다.

fun <T> generateFunStream(seed: T, generate: (T) -> T) : FunStream<T> =
    FunStream.Cons({seed}, {generateFunStream(generate(seed), generate)})

tailrec fun <T> FunStream<T>.forEach(f: (T)->Unit): Unit = when(this) {
    FunStream.Nil -> Unit
    is FunStream.Cons -> {
        f(head())
        tail().forEach(f)
    }
}

val infiniteVal = generateFunStream(0) {
    it + 5
}
infiniteVal.forEach {
    println(it)
}


*개인적으로 코틀린을 공부하면서 정리한 자료입니다. 수정 사항 및 이슈가 있는 경우 메일 부탁드립니다.

댓글

댓글 쓰기

이 블로그의 인기 게시물

코틀린 (Kotlin) filter, map, all, any, count, find, groupBy, flatMap 함수 정리

filter 함수 filter 함수는 리스트를 이터레이션하면서 리턴이 true 인 값만 필터링합니다. var listInts = listOf(1,2,3,4) //filter listInts. filter { it % 2 == 0 } //출력 [2,4] map 함수 map 함수는 값을 변형해서 새로운 리스트를 생성합니다. var listInts = listOf(1,2,3,4) listInts. map { it * it } //출력 [1,4,9,16] val people = listOf(Person("A", 27), Person("B", 35), Person("C", 35)) listInts. map { it.name } //출력 [A, B, C] //심플한 방법 people. map (Person::name) //30살이상의 이름 출력 people. filter { it.age >= 30 }. map (Person::name) //가장 나이가 많은 사람들 모두 출력하기 //1. 최대값을 구하는 반복작업이 쓸데없이 많은 코드 people. filter { it.age == (people.maxBy(Person::age)!!.age) } //매번 maxBy 호출 //2. 계산이 중복되는것을 피하자. 람다안에 람다를 넣는것은 내부 로직을 매우 복잡하게 할 수 있음 val maxAge = people. maxBy (Person::age)!!.age //외부로 빼서 불필요한 반복 제거 people. filter { it.age == maxAge } //맵 사용 //map 에는 filterKeys, mapKeys 와 filterValues, mapValues 함수가 있음 val numbers = mapOf (0 to "zero", 1 to "one") val upperNumbers = numbers.ma
자세한 내용 보기

코틀린 (Kotlin) 인터페이스 정리

인터페이스 코틀린의 인터페이스는 자바와 같이 interface 로 시작합니다. interface Clickable {     fun click() } interface 를 구현할 때는 [클래스: 인터페이스] 형식으로 구현됩니다. extends(확장)과 implements(구현) 둘 다 :(콜론) 으로 구현합니다. 코틀린은 1개의 상속과 여러개의 인터페이스를 구현할 수 있습니다. 그리고 override 변경자를 사용해서 자바의 @Override 를 대신합니다. 만약에 override 된 함수 이름과 다른 함수 이름이 중복될경우 둘중 하나는 다른 이름을 사용해야 됩니다. //클래스 상속이나 구현은 : 으로 구분 class Button : Clickable, View { //Clickable은 interface, View 는 상속      override fun click() {           //구현시 override 필수     } } 디폴트 메소드 자바8 에서는 디폴트 메소드인경우 default 를 붙이지만 코틀린에서는 따로 추가되는 변경자가 없이 함수를 구현하면 됩니다. interface Clickable {     fun click()     fun showOff() = Log.d("Clickable showoff") //디폴트 메소드 } 디폴트 메소드는 override 를 하지않은 경우 디폴트로 사용되는 함수 입니다. 같은 함수 이름을 갖는 interface 디폴트 함수 이름이 같은 두개의 인터페이스를 구현해야되는 경우를 생각해봅니다. 디폴트 함수 이름이 같은 이름인 인터페이스를 정의하면 컴파일 에러 가 발생합니다. interface Clickable {     fun click()     fun showOff() = Log.d("Clickable showoff") } interface Focusable {     fu
자세한 내용 보기

코틀린 (Kotlin) object 키워드와 동반 객체 정리

코틀린 obeject 키워드 object 는 흔히 자바나 안드로이드에서 사용하는 무명 내부 클래스(anonymous inner class) 처럼 사용할 수 있습니다. object 키워드는 클래스를 정의하면서 객체를 생성 합니다. 코틀린 싱글턴 만들기 코틀린은 object 키워드를 이용해서 별다른 코드없이 싱글턴 구현을 지원합니다. 자바처럼 클래스를 만들고 static 객체로 한번만 할당해주는 코드가 object Payroll 이라고 클래스를 생성해 주기만하면 static 객체에 할당해주는 것을 자동으로 생성해줍니다. object Payroll { //object 클래스 생성으로 싱글턴을 구현     val allEmplyees = arrayListOf<Person> ()     fun calculateSalary() {         //...     } } //사용 Payroll.calculateSalary() //싱글턴처럼 . 으로 접근 Payroll.allEmplyees. add(Person( "zerog" , Company( "zerog" , Address( "" )))) object 생성자 object 객체는 주 생성자와 부 생성자 모두 사용할 수 없습니다. //ERROR!!! object 는 생성자를 사용할 수 없음 object Payroll(val a:String) {    ... } object 상속 object 객체는 상속이 가능합니다. 예를들어 멤버변수로 상태값을 저장하지않고 메소드만 override 하여 사용하는 클래스의 경우 object 로 상속을 받아 생성자없이 바로 사용가능하도록 만들수 있습니다. //object 로 구현한 경우 object CaseInsensitiveFileComparator: Comparator {     override fun compare(o1: File?, o2: F
자세한 내용 보기