💌 컬렉션 타입과 람다

📌 집합 연산 함수

💜 forEach(), forEachIndexed()

• forEach()
  컬렉션 타입의 데이터 개수만큼 특정 구문 반복 실행
• forEachIndexed()
  forEach()와 동일하며 단지 람다함수에 인덱스 값까지 전달

 listOf(1,2,3).forEachIndexed { index, value ->
        println("index: $index , value: $value")
    }

🖥
index: 0 , value: 1
index: 1 , value: 2
index: 2 , value: 3

💜 all(), any()

• all()
  컬렉션 타입의 데이터가 특정 조건에 만족하는지 판단
• any()
  특정 조건에 만족하는 데이터가 있는지 판단

class User(val name: String, val age: Int)
var list = listOf(User("lee",22), User("kim",33))

println("all test: ${ list.all { it.age > 30 } }")
println("any test: ${ list.any { it.age > 30 } }")

🖥
all test: false
any test: true

💜 count(), find()

• count()
  람다식으로 대입한 조건에 만족하는 데이터 개수 반환
• find()
  조건에 만족하는 가장 첫 번째 데이터 반환

class User(val name: String, val age: Int)
var list = listOf(User("lee",22), User("kim",33))
  
println("count test: ${ list.count { it.age > 25 } }")
val user = list.find { it.age > 25 }
println("find test: ${user?.name}, ${user?.age}")

🖥
count test: 1
find test: kim, 33

💜 reduce(), reduceRight(), fold(), foldRight()

• fold() - 초깃값 지정 가능
  foldRight() - fold()와 동일, 데이터를 마지막부터 전달
  reduce() - 초깃값 지정 불가
  reduceRight() - reduce()와 동일, 데이터를 마지막부터 전달
  
  람다 함수 대입 시 컬렉션 타입의 데이터를 람다 함수에 차례로 전달하며 결괏값 반환

var result = listOf(1, 2).fold(10, {total, next ->
        println("$total... $next")
        total + next
    })
    println("fold test : $result")

🖥
10... 1
11... 2
fold test : 13

// 전체 데이터 중 max 구하기
// fold 힘수
var result = listOf(1, 11, 5).fold(10){max, next ->
       if (next > max) next else max
    }
    println("fold test : $result")
    
// reduce 함수
var result = listOf(1, 11, 5).reduce{max, next ->
       if (next > max) next else max
    }

🖥
fold test : 11

💜 max(), maxBy(), min(), minBy()

• max() - 가장 큰 값 반환
• maxBy() - 람다 함수를 매개변수
• min() - 가장 작은 값 반환
• minBy() - 람다 함수를 매개변수

 var result = listOf(1, 11, 5).maxBy{it % 10}
    println("fold test : $result")

🖥
fold test : 5

💜 none(), sumBy()

• none() - 람다 함수에 지정한 조건에 맞는 데이터 유무 판단
• sumBy() - 람다 함수를 거쳐 반환한 모든 값 더하기

📌 필터링 함수

💜 filter()

• 특정 조건에 맞는 데이터만 추출

💜 filterNot(), filterNotNull()

• filterNot()
  filter와 반대
• filterNotNull()
  null 아닌 데이터만 추출

💜 drop(), dropWhile(), dropLastWhile()

• 데이터 중 일부분 제외하고 나머지를 추출
• drop()
  대입한 숫자 개수만큼을 앞에서부터 제외하고 추출
• dropWhile() / dropLastWhile()
  매개변수인 람다 함수 조건에 만족하지 않는 데이터가 나올 때 그 데이터부터 추출 / 순서반대

// 11부터는 10보다 작아도 추출
var result = listOf(1, 3, 11, 5, 23).dropWhile { it < 10 }
        .forEach{ println(it) }

🖥
11
5
23

💜 slice(), take(), takeLast(), takeWhile()

• 특정위치에 있는 데이터 추출
• slice()
  범위나 위치에 있는 데이터 추출
• take()
  앞에서부터 개수만큼 데이터 추출
• takeLast()
  뒤에서부터
• takeWhile()
  조건에 맞지 않을때까지의 데이터 추출

var result = listOf(13, 12, 5, 23, 5, 4).takeWhile{it >10}
        .forEach{ println(it) }

🖥
13
12

📌 매핑함수

💜 map(), mapIndexed()

• forEach()와 비슷(반환값 차이),
• map()
  데이터 개수만큼 반복 실행 후 반환
• mapIndexed()
  map()와 동일, 인덱스까지 전달

val list2 = listOf(13, 12, 5, 23, 5, 4).filter { it >10 }
        .map { it * 10 }
        .forEach{ println(it) }

🖥
130
120
230

💜 groupBy()

• 컬렉션 타입의 데이터를 특정 데이터로 묶을 때 사용

📌 요소함수

💜 contains()

• 특정 데이터가 있는지 판단

💜 elementAt(), elementAtOrElse(), elementAtOrNull()

• elementAt()
  특정 위치의 데이터 추출
• elementAtOrElse()
  범위 벗어나도 지정된 람다 함수 반환값 반환
• elementAtOrNull()
  범위 벗어나면 null 반환

💜 first(), firstOrNull(), last(), lastOrNull()

• first()
  조건에 맞는 첫 번째 데이터 추출
• firstOrNull()
  조건에 맞는 데이터 없으면 null 반환
• last()
  조건에 맞는 마지막 데이터 추출
• lastOrNull()
  조건에 맞는 데이터 없으면 null 반환

💜 indexOf(), indexOfFirst(), indexOfLast()

• indexOf()
  매개변수 위치하는 첫 번째 인덱스 반환, 데이터 없으면 -1
• indexOfFirst()
  람다 함수 결괏값에 해당하는 첫 번째 인덱스 반환
• indexOfLast()
  람다 함수 결괏값에 해당하는 마지막 인덱스 반환

📌 정렬 함수

💜 reversed()

• 데이터의 순서를 거꾸로 바꿈

💜 sorted(), sortedBy(), sortedDescending(), sortedByDescending()

• sorted()
  정렬
• sortedBy()
  람다 함수의 결괏값을 대상으로 정렬
• sortedDescending()
  역순 정렬
• sortedByDescending()
  역순으로 람다 함수의 결괏값을 대상으로 정렬