<header>
  <h1>LOGO</h1>
  <h2>검색</h2>
  <input type="text">
</header>

# map()함수에서는 컬렉션 내 인자를 다른 값 혹은 타임으로 변환할 때 사용한다.
val cities = listOf("Seoul", "Newyork", "London")
cities.map { city -> city.toUpperCase() }.forEach { println(it) }
//출력결과
SEOUL
NEWYORK
LONDON

# mapIndexed()함수를 사용하면 컬렉션 내 포함된 인자의 인덱스 값을 변환 함수 내에서 사용할 수 있다
val numers = 1..10
numbers.mapIndexed { index, number -> index * number }.forEach { print(it) }
//출력 결과
0 1 4 9 16 25 ...

# mapNotNull()은 컬렉션 내 각 인자를 변환함과 동시에, 변환한 결과가 널 값인 경우 이를 무시한다.
val cities = listonf {"Seoul", "Newyork", "London"}
cities.mapNotNull { city -> if(city.lengt == 5) city else null }.forEach { println(it) }
//출력 결과
Seoul

# flatMap() 함수는 map()함수와 유사하게 컬렉션 내 인자를 다른 형태로 변환해주는 역할을 한다. 하지만 map() 함수와 달리 변환 함수의 반환형이 interable이다.
val number = 1..5
numbers.flatMap { number -> 1..number }.forEach { print(it) }
//출력 결과
1 1 2 1 2 3 1 2 3 4 1 2 3 4 5

# groupBy()함수는 컬렉션 내 인자들을 지정한 기준에 따라 분류하며, 각 인자들의 리스트를 포함하는 맵 형태로 결과를 반환한다.
val cities = listonf {"Seoul", "Newyork", "London"}
cities.groupBy { city -> if(city.length == 5) "A" else "B" }.forEach { key, value -> println("$key, $value") }
//출력 결과
A, Seoul
B, Nework
B, London

# filter()함수는 컬렉션 내 인자들 중 주어진 조건과 일치하는 인자만 걸러주는 역할을 한다.
val cities = listonf {"Seoul", "Newyork", "London"}
cities.filter { city -> city.length <= 5 }.forEach { println(it) }
//출력 결과
Seoul

# take() 함수의 인자로 받은 개수만큼만을 인자로 갖는 리스트를 반환
cities.take(1).forEach { println(it) }
//출력결과
Seoul

# takeLast() take()함수와 반대
cities.takeLast(1).forEach { println(it) }
//출력결과
London

# takeWhile() 첫 번째 인바부터 시작하여 주어진 조건을 만족하는 인자까지를 포함하는 리스트를 반환한다.
cities.takeWhile { city -> city <= 5 }.forEach { println(it) }
// 출력 결과
Seoul

# takeLastWhile() takeWhile()함수와 반대
cities.takeLastWhile { city -> city >= 5}.forEach { println(it) }
// 출력 결과
없음

# drop()함수는 take()함수와 반대의 역할을 하며, 조건을 만족하는 하목을 컬렉션에서 제외한 결과를 반환한다.
# drop(), dropLast(), dropWhile(), dropLastWhile() 존재
cities.drop(1).forEach { println(it) }
//출력결과
Newyork
London

# first() 함수는 컬렉션 내 첫번째 인자를 반환한다. 조건을 사용하여 조건을 만족하는 첫번쨰 인자를 반환하는 것도 가능
# 조건을 만족하는 인자가 없는 경우 NoSuchElementException 예외를 발생, firstorNull() 함수를 사용하면 예외 대신 널 값을 반환 한다.
println(cities.first())
println(cities.last())
println(cities.first { city -> city.lenth == 5 })
println(cities.firstOrNull { city -> city.isEmpty() })
//출력결과
Seoul
London
Seoul
null

# distinct() 함수는 컬렉션 내에 포함된 항목 중 중복된 항목을 거러낸 결과를 반환한다.
# distinctBy() 함수를 사용하면 비교에 사용할 조건을 직접 설정 할 수 있다.
cities.distinct().forEach { println(it) }
//출력결과
Seoul
Newyork
London

cities.distinctBy { city -> city.contains("e") }.forEach { println(it) }
//출력결과
Seoul
London

# zip() 함수는 두 컬렉션 내의 자료들을 조합하여 새로운 자료를 만들떄 사용된다.
# 두 컬렉션 간 자료의 개수가 달라도 사용하 수 있으며, 이 경우에 반환되는 컬렉션의 자료수는 조합에 사용하는 컬렉션의 수 중 더 적은 쪽을 따라간다.
# 기본값으로 조합된 결과를 Pair로 만들어주며, 원하는 경우 조합 규칙을 사용자가 정의할 수 있다.

# JoinToString() 함수는 컬렉 션 내 자료를 문자열 형태로 변한함과 동시에, 이를 조합하여 하나의 문자열로 생성한다.
println(cities.joinToString())
println(cities.joinToString(" "))
println(cities.joinToString("|"))
//출력결과
Seoul, Newyork, London
Seoul Newyork London
Seoul|Newyotk|London

# count() 함수는 컬렉션 내 포함된 자료의 개수를 반환하며, 조건식을 추가하며 해당 조건을 만족하는 자료의 개수를 출력한다.
println(cities.count())
println(cities.count { city -> city.length == 5 }
//출력결과
3
1

# reduce() 함수는 컬렉션 내 자료들을 모두 합쳐 하나의 값으로 만들어주는 역할을 한다.
# reduce() 함수는 컬렉션 내 첫번쨰 자료부터 조합을 시작하며, reduceRight() 함수는 컬렉션 내 마지막 자료부터 시작한다

# 코틀린의 경우
fun print(body: (Int, Int) -> Int) {
 println(body(5, 5))
}

print({a, b -> a})

# 자바의 경우
public final void print(@NotNull Fuction body) {
 Object result = body.invoke(5, 5);
 System.out.println(result);
}

private fun print(body: (Int, Int) -> Int) {
 println(body(10, 5))
}

fun sum(a: Int, b: Int) = a + b
fun sub(a: Int, b: Int) = a - b

printResult(::sum) //result = 15
printResult(::sub) //result = 5

# 코틀린의 경우
fun doSomething(body: () -> Unit) {
 body()
}

fun callFunction() {
 doSomeThing{ println("out") }
}
 
 # 자바의 경우
public void doSomethings(Function body) {
 body.invoke();
}
 
public void callFunction() {
 doSomething(new Function() {
  @Override
  public void invoke() {
   System.out.println("out");
  }
 });
}

inline fun doSomeThing(body: () -> unit) {
 body()
}

fun callFunction() {
 doSomething { println("out") }

# 재귀함수
fun factorial(n: Int, acc: Int): Int {
 return if (n <= 0) {
  acc
 } else {
  factorial(n-1, n*acc)
 }
}

# 꼬리재귀
fun factorial(n: Int, acc: Int): Int {
 return if (n <= 0) {
  acc
 } else {
  factorial(n-1, n*acc)
 }
}

# 재귀함수가 컴파일된 바이트 코드를 자바로 변환시
public static final int factorial(int n, int acc) {
 if (n <= 0) {
  return acc;
 }
 return factorial(n-1, n*acc)
}

# 꼬리재귀가 컴파일된 바이트 코드를 자바로 변환시
public static fianl int factorial(int n, int acc) {
 for (int n2 = n; n2 > 0; n2--) {
  acc = acc * n2;
 }
 return acc;
}

# Java Generics 정의
interfacce Generic<T> {
 void setItem(T item);
}

# Kotilin Generics 정의
interface Generic<in T> {
 fun setItem(item: T)
}

# 코틀린에서 제네릭을 상속 받는 경우
class Sample : Generic<Generic Type을 정의> {
 overrie fun setItem(item: generic Type을 정의) {
  //doSomeThing
 }
}

# 변수로 함수 넘기기
fun calc(x: Int, y:Int, operation: (Int, Int)->Int) = operation(x, y)
run { println(calc(5,5, {x, x -> x+x})) }
//실행결과 : 10

# 함수 리턴
fun getCalcFunctions(action: Int): (Int, Int)->Int {
  when(action)
    1 -> return {x: Int, y:Int -> x+y}
    2 -> return {x: Int, y:Int -> x-y}
}

val calFunction = getCalcFunctions(2)
run { println(calFunction(5, 5)) }
//실행결과 : 0

# 기본형태
val lambda09 = { parm1: Int, parm2: Int -> parm1 + parm2 }

fun main(args: Array<String>) {
 println(lambda09(1, 2))
}

# 내용이 여러 줄일 경우 가장 마지막 줄이 반환값이 된다.
val lambda09 = {parm1: Int, parm2: Int ->
 println("labmda")
 parm1 + parm2
}

# 인자가 없으면 매개변수 부분을 입력하지 않아도 된다.
val labmda09 = {
 val parm1 = 10
 val parm2 = 10
 println("${parm1 + parm2}")
}

fun add(x: Int): (Int) -> Int {
 return fun(y: Int): Int {
  return x + y
 }
}
 
fun main(args: Array<String>) {
 val func = add(10)
 val result = func(20)

# forEach 함수는 익명함수를 인자로 받는다. 람다식으로 생성한 익명함수도 클로저 함수이며, outer scope의 변수에 접근할 수 있다.
var sum = 0
ints.filter { it > 0 }.forEach {
 sum = sum + it
}
print(sum)

# 자바로 아래처럼 리스너를 만들면 컴파일 에러 발생
int x = 5;

view.setOnClickListener(new View.OnClickListener() {
 @Override public void onClick(View v) {
  System.out.prinln(x); //x가 final이 아니기 때문에 클로저를 지원하지 않는 자바에서는 컴파일 에러가 발생.
 }
});

# 코틀린은 가능!
 var x = 5
 
 view.setOnClickListener {
  println(x)
 }

var sum = 0
ints.filter { it > 0 }.forEach {
 sum += it
}
println(sum)

# 클로저의 형태
{ (param1: Int, param2: Int: Stirng) -> Int in
 return param1 + param2
}

# 클로저 예제
let numbers = [1, 4, 56, 22, 5]
func sortAscending(_ i: Int, - j: Int) -> Bool {
 return i < j
}

//클로저 미사용
let sortedNumbers = numbers.sorted(by: sortAscending)

//클로저 사용
let sortedNumbers = numbers.sorted(by: { (i: Int, j: Int) -> Bool in
  return i < j
})

let sortedNumbers = numbers.sorted(by: { (i: Int, j: Int) -> Bool in
 i < j
 })

// 매개변수 타입 추론 축약
let sorted = numbers.sorted(by: { i, j in i < j})

// 축약형 인수형 문법
let sortedNubmers = numbers.sorted(by: { $0 < $1 })

let sortedNumbers = numbers.sorted() { $0 < $1 }

# 클로저가 함수에 대한 유일한 인자일 때 괄호를 완전히 생략할 수 있다.
let sortedNumbers = numbers.sorted { $0 < $1 }

# 코틀린의 경우 단일 명령문이 아니더라도 마지막 명령문이 자동으로 리턴된다.
val add = {x: Int, y: Int ->
 x * y
 x + y
}

println(add(10, 20))
//결과값: 30

# 코틀린의 경우에도 매개변수 타입을 추론할 수 있다면 축약가능하다.
fun exam(x: Int, operation: (Int, Int) -> Int) {
    
}

exam(10, {x, y -> x + y})

# 코틀린의 경우에도 함수가 유일한 인자일 때 괄호를 생략할 수 있다.
fun exam(operation: (Int, Int) -> Int) {
    
}

exam {x, y -> x + y}

# 마지막 인자가 함수일 때 소괄호 밖 중괄호로 인자를 뺄 수 있다.
fun exam(x: Int, operation: (Int, Int) -> Int) {
    
}

exam(10) {x, y -> x + y}

# null인지 확인
fun main() {
  val name: String? = "sonsation"
  if (name != null) println(name.length) // name의 null체크를 한후 널이 아니면 String 타입으로 스마트 캐스팅 된다. (null 체크 후 name을 강제 호출 하지 않아도 된다)
}

# 자바의 스마트 캐스팅 미지원
Object string = "is String!";

if (string instanceOf String) {
  String text = (String)string; // 별도의 다운 캐스팅을 해줘야함.
  System.out.println(text);
}

#코틀린의 스마트 캐스팅 지원
val string = "is String!"

if (string is String)
  println(string) // 별도의 캐스팅 없이 타입 체크만으로 캐스팅 되었기 때문에 따로 캐스팅이 필요없다.

# 스마트 캐스팅 미적용
val sum: (Int, Int)->Int = {x: Int, y:Int -> x + y}

# 스마트 캐스팅 적용
val sum = {x: Int, y:Int -> x + y}

fun main() {
  val letters = ('a'..'z').toList()
  println(letters.slice<Char>(0..2))
  println(letters.slice(10..13))
}

# JAVA
public class Car<T> {
  private T data;
  
  public void set(T data) {
    this.data = data
  }
  
  public T get() {
    return data;
  }
}

#Kotlin
class Car<T> {
  private var data:T? = null
    get() = { return data }
    set(value) = { field = value }

# JAVA
<T extends Number> T sum(List<T> list)

# Kotilin
fun <T: Number> List<T>.sum(): T

fun <T: Comparable<T>> max(first: T, second: T): T {
  return if (first > second) first else second
}

fun main() {
  println(max("kotlin", "java"))
}

fun <T> ensureTrailingPeriod(seq: T)
  where T: CharSequence, T: Appendable {
  
  if (!seq.endWith('.')) {
    seq.append('.')
  }
}

fun main() {
  val helloWorld = StirngBuilder("Hello World")
  ensureTrailingPeriod(helloWorld)
  println(helloWorld)
}

# nullable 선언
var nullable: String? = null

# nullable
//null check 후 실행
if (nullable != null) nullable.doSomething()

//Safe call
nullable?.doSomething()

# nullable 강제호출
//null 인지 non-null 인지 구분하지 않고 강제로 호출 null이면 NullPointException을 발생한다.
nullable!!.doSomething()

fun String.doSomethig(): String {

}

data class User(var name:String, var age: Int)

var animals = listOf("lion", "tiger")
animals.add("zebra") //컴파일 에러

# JAVA 텍스트 뷰에 대한 설정을 하기 위해 textView를 명시해줘야 한다.
TextView textView = findViewById(R.id.textView);
textView.setText("text")
textView.setSize(16)

# 범위 지정 함수의 수신객체가 매개변수로 암시적으로 전달된다.

# 코틀린 let은 지정된 값이 null이 아닌 경우에 코드를 실행할 수 있기 때문에 safe call을 할 수 있다.
textView?.let {
  it.text = "text"
  it.size = 16
}

# also also는 apply와 마찬가지로 수신 객체를 반환하지만 객체의 사이드 이팩트를 확인하거나, 수신객체의 프로퍼티에 데이터를 할당하기 전에 해당 데이터의 유효성을 검사할 때 사용.

class book(author: Person) {
  val author = author.also {
    requireNotNull(it.age)
    print(it.name)
  }
}

# apply 람다 내부에서 수신 객체의 함수를 사용하지 않고 수신 객체 자신을 다시 반환하려는 경우 사용.
val person = Person().apply {
  name = "sonsation"
  age = 27
}

# run 어떤 값을 계산할 필요가 있거나 여러개의 지역 변수의 범위를 제한할 때 사용.
val inserted: Boolean = run {
    val person: Person = getPerson()
    val personDao: PersonDao = getPersonDao()
    personDao.insert(person)
}
fun printAge(person: Person) = person.run {
    print(age)
}

# with Non-nullable 수신 객체 이고 결과가 필요하지 않은 경우에만 사용.
val person: Persion = getPerson()
  with(person) {
    print(name)
    print(age)
  }
}

# 변수로 함수 넘기기
fun calc(x: Int, y:Int, operation: (Int, Int)->Int) = operation(x, y)
run { println(calc(5,5, {x, x -> x+x})) }
//실행결과 : 10

# 함수 리턴
fun getCalcFunctions(action: Int): (Int, Int)->Int {
  when(action)
    1 -> return {x: Int, y:Int -> x+y}
    2 -> return {x: Int, y:Int -> x-y}
}

val calFunction = getCalcFunctions(2)
run { println(calFunction(5, 5)) }
//실행결과 : 0

# 코드의 간결성을 위해 규칙이 존재
# 1. 함수의 맨 마지막 인자가 람다라면() 안에서 뺴내서 밖에 람다를 표현할 수 있다.
# 2. 인자가 하나라면 그 인자는 람다식 내부에서 'it'으로 받을 수 있다.
# 3. 인자가 하나이면서 그 인자가 람다타입 이라면 ()을 생략할 수 있다.

people.maxBy ({p: Person -> p.age})
people.maxBy () {p: Person -> p.age}
people.maxBy {p: Person -> p.age}
people.maxBy {it.age}