[Kotlin] 코틀린 문법 고급 1

컬렉션

• 기본 컬렉션 타입 👉 List, Set, Map

fun main(){
	
    // immutable
    val currencyList = listOf("달러", "유로", "원") // add 불가
    val numberSet = setOf(1, 2, 3, 4)
    val numberMap = mapOf("one" to 1, "two" to 2) // to 중위함수로 key-value 구조 전달
    
    // mutable
    
    // 1) List
    val mutableCurrencyList = mutableListOf<String>()
    mutableCurrencyList.add("달러")
    mutableCurrencyList.add("유로")
    mutableCurrencyList.add("원")
    
    // 2) Set
    val mutableSet = mutableSetOf<Int>()
    
    // 3) Map
    val mutableNumberMap = mutableMapOf<String, Int>()
    mutableNumberMap["one"] = 1
    mutableNumberMap["two"] = 2
    mutableNumberMap["three"] = 3
}

 

• apply 함수 사용 시 가독성 좋아짐

val mutableCurrencyList = mutableListOf<String>().apply {
    add("달러")
    add("유로")
    add("원")
}

 

• 컬렉션 빌더를 사용해 컬렉션 생성 가능 👉 buildList, buildSet, buildMap

val numberList: List<Int> = buildList {
    // buildMap 내부엔 MutableMap
    add(1)
    add(2)
    add(3)
}

 

 

 

🔷 컬렉션 반복

• 컬렉션은 Iterable 구현체이므로 순차적 반복 가능 

val iterator = currencyList.iterator()
while (iterator.hasNext()) {
	println(iterator.next())
}

for (currency in currencyList) {
	println(currency)	
}

• forEach, map, filter와 같은 인라인 함수 제공

currency.forEach {
	println(it)
}

 

• for loop를 map으로 변환하기 전

val lowerList = listOf("a", "b", "c", "d")
val upperList = mutableListOf<String>()

for(lowerCase in lowerList){
	upperList.add(lowercase.uppercase())
}

println(upperList)
// // [A, B, C, D]

• map으로 변환 후

val upperList = lowerList.map { it.uppercase() }
println(upperList)
// [A, B, C, D]

 

• filter 변환 전

val filteredList = mutableListOf<String>()
for (upperCase in upperList) {
    if (upperCase == "A" || upperCase == "C") {
    	filteredList.add(upperCase)
    }
}
println(filteredList)
// [A, C]

• filter 변환 후

val filteredList = upperList.filter { it == "A" || it == "C" }
println(filteredList)
// [A, C]

 

 

💥 자바 8의 스트림과 비교

val filteredList = upperList.stream().filter { it == "A" || it == "C" }

println(filteredList)
// java.util.stream.ReferencePipeline$2@77b52d12​

 

👉 중간 연산자(map, filter, flatMap 등)만 사용시 아무런 동작하지 않으며 값을 얻고 싶으면 최종 연산자를 사용해야 함

val filteredList = upperList.stream()
    .filter { it == "A" || it == "C" }
    .collect(Collectors.toList())
    
println(filteredList)
// [A, C]​

🔹 코틀린에서는 sequence를 사용해 자바 8 스트림과 같이 Lazy하게 동작시킬 수 있으며 시퀀스 API도 최종 연산자를 사용해야 중간 연산자가 동작

val filteredList = upperList
    .asSequence()
    .filter { it == "A" || it == "C" }
    .filter {it == "C" }
    .filter {it == "C" }
    .filter {it == "C" }
    .filter {it == "C" }
    .toList()
    
println(filteredList)
// [A, C]

👉 시퀀스 API는 각각의 함수가 동작할 때 시퀀스를 생성하고 최종 연산자를 호출할 때 1개의 컬렉션 생성
👉 일반적으로 인라인 함수가 빠르므로 인라인 함수를 사용하나, 대량의 데이터를 다루거나 체인이 많아질 때는 시퀀스  API 사용 추천

 

 

 

데이터 클래스

데이터를 보관하거나 전달하는 목적을 가진 객체를 만들 때 사용 👉 DTO

data class Person(val name: String, val age: Int)

• 데이터 클래스 사용 시 컴파일러가 자동으로 만들어주는 함수
  • equals()
  • hashCode()
  • toString()
  • componentN(), copy()
• 기존 자바에서는 주로 Lombok 사용 👉 @Data
• JDK 15에서는 record

@Data
public class Person {
    private final String name;
    private final int age;
}

public record Person(String name, int age) {
}

 

✨ Kotlin decomplie to Java

인텔리제이에서 유용한 기능을 제공한다. 코틀린 파일을 자바로 decompile 해주는 것이다.

Tools > Kotlin > Show Kotlin Bytecode > decompile 을 누르면

이렇게 파일이 생성되어 자바 코드로는 어떻게 구현되는지 확인할 수 있다. 

 

 

 

🔷 데이터클래스가 필요한 이유

• 객체 동등성 비교 (equals)

// 일반 클래스
class Person(val name: String, val age: Int)

fun main() {
    val person1 = Person(name = "tony", age = 12)
    val person2 = Person(name = "tony", age = 12)
    println(person1 == person2)
}
// false

// 데이터 클래스
data class Person(val name: String, val age: Int)

fun main() {
    val person1 = Person(name = "tony", age = 12)
    val tony2 = Person(name = "tony", age = 12)
    println(person1 == person2)
}
// true

 

• hashCode
  • equals 재정의할 때 반드시 hashCode도 재정의

data class Person(val name: String, val age: Int)

fun main() {
    val person1 = Person(name = "tony", age = 12)
    val person2 = Person(name = "tony", age = 12)
    println(person1 == person2)
    // true
    
    val set = hashSetOf(person1)
    println(set.contains(person2))
    // true
}

 

• toString

data class Person(val name: String, val age: Int)

fun main() {
    val person1 = Person(name = "tony", age = 12)
    println(person1.toString())
}
// Person(name=tony, age=12)

• copy
  • 프로퍼티를 val로 유지해 불변성 유지
  • 원하는 프로퍼티만 변경하면서 새로운 불변 객체 생성

data class Person(val name: String, val age: Int)

fun main() {
    val person1 = Person(name = "tony", age = 12)
    val person2 = person1.copy(name= "strange")
    
    println(person2.toString())
    // Person(name=strange, age=12)
}

• componentN 👉 프로퍼티를 순서대로 가져옴

fun main() {
    val person1 = Person(name = "tony", age = 12)
    
    println("이름=${person1.component1()}, 나이=${person1.component2()}")
    // 이름=tony, 나이=12
}

 

 

 

 

싱글톤과 동반객체

클래스의 인스턴스를 하나의 단일 인스턴스로 제한
객체 선언을 통해 싱글톤 기본 지원 👉 object 키워드 사용

 

🔷 싱글톤

object Singleton {
	val a = 1234
    	
	fun printA() = println(a)
}

fun main() {
    println(Singleton.a)
    Singleton.printA()
}

 

🔷 동반객체

클래스 내부에 정의되는 객체로, 클래스의 인스턴스를 생성하지 않고도 접근할 수 있는 멤버를 가질 수 있게 함
👉 자바의 static 멤버와 유사한 역할 

companion 키워드 사용해 클래스 내부에 객체 선언 사용

 

class MyClss{
	private constructor()
    
    companion object {
    	val a = 1234
        
        fun newInstance() = MyClass()
    }
}

fun main() {
	println(MyClass.a)
    println(MyClass.newInstance())
    
    // 이렇게도 가능하나 생략 가능
    println(MyClass.Companion.a)
    println(MyClass.Companion.newInstance())
}

👉 생성자를 private으로 숨기고 newInstance 함수를 통해서만 객체 생성 가능