[코틀린]코틀린걸음마中의 기록

네.. 안녕하세요 그간 몰아치는 시험으로 너무 정신 없어서 블로그에 잠시 소홀해졌네요 !!!! 

다시 마음을 다잡고 시작해보겠습니다 ㅎ...

오늘은 이번학기부터 시작한 코틀린에 대해 설명하려구 합니다.

중간 시험때 공부한걸 토대로 재구성해보았어요

전 과연 이 정리를 토대로 한 공부로 몇점을 얻어냈을까요?

그건 아직 모르는 일입니다... 무서워요

나중에 까먹을 미래의 저를 위해서라도 다시 기록해볼게요!!!

 

 

1. 문법 및 구문 

A. 데이터 타입 및 크기 

• 정수 타입 크기 암기: Int (32 bits), Long (64 bits).
• 부동 소수점 타입 크기 및 정밀도 암기: Float (32 bits, Decimal digits 6-7), Double (64 bits, Decimal digits 15-16).
• String Template (문자열 템플릿):
  • 템플릿 표현식은 달러 기호($)로 시작하며, 변수 이름 또는 중괄호 안의 표현식으로 구성됨.
  • 예시 문제: 다음 코드의 출력 결과를 맞추세요.
  • 정답: The length of s is 6

val s = "kotlin"
Log.d("ITM", "The length of s is ${s.length}")

B. 조건문 

if

• Kotlin에서 if는 표현식(expression)으로 사용되어 값을 반환하고 변수에 할당될 수 있음.
• 예시 문제: 다음 코드에서 max 변수에 할당되는 값은?
• 정답: 20

val a = 10 val b = 20 val max = if (a > b) a else b

 

 

when

• 다른 언어의 switch-case와 유사.
• 콤마(,) 사용: 여러 조건을 하나의 동작에 묶을 수 있음.
• Range 체크: in 또는 !in 구문을 사용하여 범위 확인. (예: in 90..100)
• 파라미터 없는 when: if-else if 체인을 대체할 수 있으며, 조건식을 직접 사용.

서로 다른 변수나 조건이 섞여 있을 때

• Type 체크: is 구문을 사용하여 타입 체크 가능.
• :는 타입 정할때 씀 any는 Kotlin의 모든 클래스의 최상위 슈퍼클래스

 

C. 배열과 컬렉션 

배열 

 

배열 초기화: IntArray vs. Array

• <Int>IntArray : 코틀린 기본형 배열(Java의 int[]와 유사)
• Array<Int> : 코틀린의 일반 배열. 내부적으로 Java의 Integer[]와 같이 박싱된 객체를 저장

intArrayOf(), arrayOf()

• 요소로 초기화. 명시적인 값으로 배열 생성

IntArray(size)

• 크기지정 기본값은 0으로 채워

IntArray(size) { value }

• 크기를 지정하고, 모든 요소를 단일 값으로 초기화합니다.

IntArray(size) { expression } / Array(size) { expression }

• 크기를 지정하고, 인덱스(it 또는 i)를 사용하여 계산된 값으로 각 요소를 초기화

val x: IntArray = intArrayOf(1, 2, 3) // use these values to create intArray
val y = arrayOf("one","two","three")
val arr = IntArray(5) // create IntArray with size of 5 
val arr2 = IntArray(5) { 42 } // create IntArray with size of 5, values of all= 42
var arr3 = IntArray(5) { it+1 } // create IntArray with size of 5, values of index+1
var arr4 = Array(5){i -> i*i}

Log.d("ITM","x.size: ${x.size}")
Log.d("ITM","arr.size: ${arr.size}")
Log.d("ITM",Arrays.toString(x))
Log.d("ITM",Arrays.toString(y))
Log.d("ITM",Arrays.toString(arr))
Log.d("ITM",Arrays.toString(arr2))
Log.d("ITM",Arrays.toString(arr3))
Log.d("ITM",Arrays.toString(arr4))

위 코드결과

컬렉션 - 동적으로 여러 객체를 저장하는 컨테이너

각각 불변(Immutable) 또는 가변(Mutable) 인터페이스로 나뉨

• 리스트

  종류	주요 특징	설명
  List	순서 O (Ordered), 인덱스로 접근, 중복 O (Duplicates Allowed)	요소의 순서가 유지되며, 동일한 요소가 여러 번 포함될 수 있습니다.

val numbers = listOf("one", "two", "three", "four")
Log.d("ITM", "Number of elements: ${numbers.size}")
Log.d("ITM", "Third element: ${numbers.get(2)}")
Log.d("ITM", "Fourth element: ${numbers[3]}")
Log.d("ITM", "Index of element \"two\": ${numbers.indexOf("two")}")

 

출력 라인 (Logcat 태그: ITM)	설명
Number of elements: 4	리스트 numbers에는 네 개의 문자열 요소가 있습니다.
Third element: three	numbers.get(2)는 인덱스 2에 위치한 요소. 겟쓰면 둥글게(소괄호)
Fourth element: four	numbers[3] 역시 인덱스 3에 위치한 요소
Index of element "two": 1	two에 대한 인덱스 반환

val numbers = mutableListOf(1, 2, 3, 4)

numbers.add(5) //[1, 2, 3, 4, 5]
numbers.removeAt(1) //인덱스 1에 있는 요소 (2)를 제거합니다. [1, 3, 4, 5]
Log.d("ITM", "${numbers}") //표현식 뿐만 아니라 리스트도 중괄

numbers[0] = 0 //인덱스 0에 있는 요소 (1)를 0으로 변경합니다. [0, 3, 4, 5]
numbers.shuffle() //리스트의 요소 순서를 무작위로 섞습니다.
Log.d("ITM", "${numbers}")

 

• 셋 (SET...)

  종류	주요 특징	설명
  Set (집합)	순서 X (Unordered/Order has no significance), 고유한 요소 (Unique Elements), 중복 X (No Repetitions)	수학적 집합처럼 중복을 허용하지 않습니다. 요소의 순서는 중요하지 않습니다.→인덱스 관련 [],겟은 xx

// ========================= SET 예제 =========================

// 1. 불변(Immutable) Set 생성 및 기본 Read 연산
val numbers = setOf(1, 2, 3, 4)
val numbersBackwards = setOf(4, 3, 2, 1) // 순서가 다름

// 요소 개수 확인
println("Number of elements: ${numbers.size}")

// 요소 포함 여부 확인
if (numbers.contains(1)) {
    println("1 is in the set")
}

// Set은 순서가 중요하지 않으므로, 포함된 요소가 같으면 동일하다고 판단 (true 출력)
println("The sets are equal: ${numbers == numbersBackwards}")


// 2. 가변(Mutable) Set 생성 및 Write 연산
val depts = mutableSetOf("ITM")

// 초기 상태 출력 및 크기 확인
println("Initial size: ${depts.size}")//1
println("Initial set: ${depts}") //[ITM]

// 요소 추가
depts.add("IISE")
depts.add("AIX")
depts.add("Computer")

// 추가 후 상태 출력
println("After adding 3 elements: ${depts}")

// 요소 제거 (없는 요소를 제거해도 오류 발생하지 않음)
depts.remove("Data science") // Set에 없는 요소 제거 시도
depts.remove("IISE")        // Set에 있는 요소 제거

// 제거 후 최종 상태 출력
println("After removal: ${depts}")

 

• 맵

종류	주요 특징	설명
Map (맵 또는 딕셔너리)	Key-Value 쌍, 키는 고유, 값은 중복 O	키(Key)와 값(Value)이 쌍으로 저장됩니다. 키는 유일해야 하지만, 값(Value)은 중복될 수 있습니다.

// ========================= MAP 예제 =========================

// 3. 가변(Mutable) Map 생성 및 Write/Read 연산
// Key: String (학생 이름), Value: Int (점수)
val studentGrade = mutableMapOf<String, Int>()

// 키-값 쌍 추가 (put)
studentGrade.put("Jeong", 100)
studentGrade.put("Kim", 90)
studentGrade.put("Hong", 80)
studentGrade.put("Park", 70)

println("Initial Map: ${studentGrade}")//전체 출력

// Key를 사용하여 값 가져오기 (get)
println("Jeong's grade: ${studentGrade.get("Jeong")}")

// 존재하지 않는 Key 조회 시 null 반환
println("Wow's grade (non-existent): ${studentGrade.get("Wow")}")

// 기존 Key에 새로운 값 할당 (업데이트)
// Map은 키가 고유해야 하므로, 기존 키로 put 하면 값이 덮어쓰여짐
studentGrade.put("Jeong", 0)

// 값 업데이트 후 최종 상태 출력
println("After updating Jeong's grade: ${studentGrade}")

여러형태로 표현가능!

• 컬렉션 생성 함수:
  • Immutable (listOf(), setOf(), mapOf()) - 리드온리!!!! 요소접근만
  • Mutable (mutableListOf(), mutableSetOf(), mutableMapOf()) - 쓰기(추가,제거,업뎃)로 확장!!

• 컬렉션의 변환(Transformation) 작업
  • 1. map() 함수 분석
    주어진 람다 함수를 컬렉션의 각 요소에 적용하고, 결과를 새로운 컬렉션(List)으로 반환합니다. 결과의 순서는 원본과 동일 (람다: 다른 코드에 전달할 수 있는 작은 익명(이름이 없는) 함수)
  • 1-1. Set .map() 예제

    코드	예상 출력 (Logcat 태그: ITM)	설명
    val numbers = setOf(1, 2, 3, 4, 5)		Set 초기화: {1, 2, 3, 4, 5}
    val numbers2 = numbers.map { it * 2 }		각 요소에 * 2를 적용한 새로운 List 생성.
    Log.d("ITM", "${numbers}")	[1, 2, 3, 4, 5]	원본 Set의 내용입니다.
    Log.d("ITM", "${numbers2}")	[2, 4, 6, 8, 10]	map() 결과는 **List**로 반환됩니다.

  • 1-2. Map .mapValues() 예제
  • Map은 key 와 value를 가지고 있어, map() 대신 mapValues()를 사용하여 값만 변환합니다

코드	예상 출력 (Logcat 태그: ITM)	설명
Log.d("ITM", "${grade}")	{Jinwoo=10, Kim=9, Hong=8, Park=7}	점수가 10분의 1로 변환된 새로운 Map입니다.

2. zip() 함수 분석

zip()은 두 컬렉션의 같은 위치(인덱스)에 있는 요소들을 묶어 Pair 객체의 List로 만듭니다. 두 컬렉션의 크기가 다르면, 작은 컬렉션의 크기만큼만 결과에 포함됩니다.

Log.d("ITM", "${colors zip animals}")

[(red, fox), (brown, bear), (grey, wolf)]

Log.d("ITM", "${colors.zip(twoAnimals)}")

[(red, fox), (brown, bear)]

Log.d("ITM", "${colors.zip(animals) { color, animal -> "The ${color.replaceFirstChar { it.uppercase() } } is $animal" }} ")

[The Red is fox, The Brown is bear, The Grey is wolf]

$\text{zip()}$에 람다를 넘겨 Pair 대신 문자열로 변환하여 $\text{List}$를 반환합니다.

3. filter() 함수 분석

주어진 조건(Predicate)과 일치하는 요소만 반환하여 새로운 컬렉션을 만듭니다.

List와 Set에 대해서는 List를 반환하며, Map에 대해서는 Map을 반환합니다.

3-1. List .filter() 예제

코드	예상 출력 (Logcat 태그: ITM)	설명
val longerThan3 = numbers.filter { it.length > 3 }	val 이름 = 리스트명.filter{조건}	길이가 3 초과인 요소만 필터링: "three" (5), "four" (4)

3-2. Map .filter() 예제

💻 코틀린 컬렉션 검색, 반복, 집계 예제 분석

1. 검색 (Retrieval) 함수 (first/last/find/findlast)

주어진 조건에 맞는 요소를 검색합니다.

val numbers = listOf("one", "two", "three", "four", "five", "six")
val numbers2 = listOf(1, 2, 3, 4)

// 길이가 3 초과인 요소 중 가장 처음 요소 검색 (first는 요소가 없으면 예외 발생)
println(numbers.first { it.length > 3 })
// 출력: three

// 'f'로 시작하는 요소 중 가장 마지막 요소 검색
println(numbers.last { it.startsWith("f") })
// 출력: five

// 짝수(it % 2 == 0)인 요소 중 가장 처음 요소 검색 (find는 요소가 없으면 null 반환)
println(numbers2.find { it % 2 == 0 })
// 출력: 2

// 짝수인 요소 중 가장 마지막 요소 검색
println(numbers2.findLast { it % 2 == 0 })
// 출력: 4

2. 반복자 (Iterator)

컬렉션의 구조를 노출하지 않고 요소를 순차적으로 접근합니다.

val numbers = listOf("one", "two", "three", "four")
val numbersIterator = numbers.iterator()

// hasNext()로 다음 요소가 있는지 확인하고 next()로 요소를 가져옴
while (numbersIterator.hasNext()) {
    println(numbersIterator.next())
}
// 출력:
// one
// two
// three
// four`

3. 집계 (Aggregate) 함수 ($\text{sum, average, max/min}$)

컬렉션의 요소들을 계산하여 단일 값을 반환합니다.

val numbers = listOf(6, 42, 10, 4)

// 요소의 개수
println("Count: ${numbers.count()}")
// 출력: Count: 4

// 최댓값 (maxOrNull은 비어있는 컬렉션에 대해 null 반환)
println("Max: ${numbers.maxOrNull()}")
// 출력: Max: 42

// 최솟값
println("Min: ${numbers.minOrNull()}")
// 출력: Min: 4

// 평균값: (6 + 42 + 10 + 4) / 4 = 15.5
println("Average: ${numbers.average()}")
// 출력: Average: 15.5

// 요소의 합계: 6 + 42 + 10 + 4 = 62
println("Sum: ${numbers.sum()}")
// 출력: Sum: 62`

 

물론 정리한건 더 길지만 일단 기본은 여기까지!!! 해볼게요

그리구 이거쓰는 와중에 점수가 공개되었는데요??

흠.. 제 정리가 그다지 좋은 효과를 이뤄내진 못했네요 

갠찮습니다 다음에 더잘하면 되죠 ㅎ.... 

다들 좋은하루 되세요 ~~~