[Kotlin] 2. 연산자

연산자 구분

• 단항 연산자(Unary Operator) : 항이 하나인 연산자로 하나의 변수에서만 작동하는 연산자
• 이항 연산자(Binary Operator) : 두 개의 항을 처리하는 연산자로 두 변수의 값으로 작동하는 연산자

사칙연산자

표현식	메서드명	내부 실행
a + b	plus	a.plus(b)
a -b	minus	a.minus(b)
a * b	times	a.times(b)
a / b	div	a.div(b)
a % b	rem/mod	a.rem(b), a.mod(b)

println("num1 + num2 = ${num1 + num2}")
println("num1 - num2 = ${num1 - num2}")
println("num1 * num2 = ${num1 * num2}")
println("num1 / num2 = ${num1 / num2}")
println("num1 % num2 = ${num1 % num2}")

println("num1.plus(num2) = ${num1.plus(num2)}")
println("num1.minus(num2) = ${num1.minus(num2)}")
println("num1.times(num2) = ${num1.times(num2)}")
println("num1.div(num2) = ${num1.div(num2)}")
println("num1.rem(num2) = ${num1.rem(num2)}")
println("num1.mod(num2) = ${num1.mod(num2)}")

할당복합연산자

표현식	같은 표현식	내부 실행
a += b	a = a + b	a.plusAssign(b)
a -= b	a = a - b	a.minusAssign(b)
a *= b	a = a * b	a.timesAssign(b)
a /= b	a = a / b	a.divAssign(b)
a %= b	a = a % b	a.modAssign(b)

var num1 = 12.5
var num2 = 10.5
num1 += num2;
println("num1 + num2 = ${num1}")
num1 -= num2;
println("num1 - num2 = ${num1}")
num1 *= num2;
println("num1 * num2 = ${num1}")
num1 /= num2;
println("num1 / num2 = ${num1}")
num1 %= num2;
println("num1 % num2 = ${num1}")

단항연산자

연산자	의미	같은표현식	내부실행
+	양수표시	+a	a.unaryPlus()
-	음수표시	-a	a.unaryMinus()
!	not	!a	a.not()
++	증감연산	++a	a.inc()
—	감소연산	—a	a.dec()

var num1 = 10
var num2 = 15

println(" 양수표시 : ${num1.unaryPlus()}  / 음수표시 : ${ num2.unaryMinus()} ")
println(" 증감연산 : ${num1.inc()} / 감소연산 ${num2.dec()}")

비트 연산자

비트연산자를 메서드로만 제공

연산자	자바	의미
shl	<<	이진 수를 왼쪽으로 이동
shr	>>	이진수를 오른쪽으로 이동
ushr	>>>	부호 없는 이진수를 오른쪽으로 이동
and	&	논리곱 비트연산
or
xor	^	베타적 논리합 비트연산
inv	!	비트 반전

varbit1 = 10
varbit2 = 1

println(" 이진수를 왼쪽으로 이동 (<<) : ${bit1.shl(bit2)}")
println(" 이진수를 오른쪽으로 이동 (>>) : ${bit1.shr(bit2)}")
println(" 부호 없는 이진수를 오른쪽으로 이동 (>>>) : ${bit1.ushr(bit2)}")
println(" 논리곱 비트 연산  and (&) : ${bit1 and bit2}")
println(" 논리합 비트 연산  or (|) : ${bit1 or bit2}")
println(" 베타적 논리합 비트 연산  xor (^) : ${bit1 xor bit2}")
println(" 비트 반전 inv (!) : ${bit1.inv()}")

 

포함연산자

• 특정 범위에 속한 값이 포함하는지 여부를 확인 할 때 사용

연산자	표현식	메서드
in	a in b	b.contains(a)
!in	a !in b	!b.contains(a)

var height = 46;
println(height in 1..53); //특정 범위 내에 속하는지.
println(height !in 1..53); //특정 범위 내에 속하면 거짓.

연산자 의미

any	하나라도 참 인경우
all	모드 것이 참이 경우
none	모든 것이 거짓인 경우

var list = listOf(1,2, null);
println(list.any { it == null }); //리스트 모든 값에 null이 하나라도 있으면 참
println(list.all { it == null }); //리스트 모든 값이 null이면 참
println(list.none { it == null }); //리스트 모든 값이 null이 아니면 참

동등성 규칙

연산자 의미 메서드

연산자	의미	메서드
==	구조적 동등성으로 동일한 값을 비교	equals
===	참조적 동등성으로 객체 참조를 비교
?.equals	null이 들어올 경우 null값 체크

var a1 = 100;
var a2 = 100;
var a3 = null;
println("a1 == a2 ${a1 == a2}") // - true
println("a1.equals(a2) : ${a1.equals(a2)}") // - true
println("a1?.equals(a2) : ${a1?.equals(a3)}") //null타입 처리일 경우 null 체크 - false
println("a1 === a2 : ${a1 === a2}") //객체 참조비교 - true

When 조건문

단일 패턴 매칭: 특정 값이나 특정 패턴을 하나만 처리

복합 패턴 매칭: 여러 종류의 패턴을 하나의 구문에서 처리

패턴이 없는 경우: if문 처럼 임의의 패턴을 지정해서 처리

val [return 변수] = when([변수명]) {
	[조건 값] -> [결과 값]              -- 특정 조건 값이 있을 경우
   in [S...N 조건 값] -> [결과 값]    -- 특정 조건 값이 있을 경우 
	else -> [결과 값]                 -- 원하는 조건 값이 없을 경우
}

when 표현식

val cores = Runtime.getRuntime().availableProcessors();

    val result = when (cores) {
        1 -> "1 Core"                     //특정 값 패턴 조건
        in 2..16 -> "$cores Cores" //특정 값 패턴 조건
        else -> "I want your machine"    //패턴 불일치
    }

    println("result : $result");

when 내부에 지역변수 정의하여 함수 반환에 직접 대입

fun main(args: Array<String>) {
    println(sysInfoCore());
}
fun sysInfoCore() : String = when 
        (val cores = Runtime.getRuntime().availableProcessors()) {
            1 -> "1 Core"                     //특정 값 패턴 조건
            in 2..16 -> "$cores Cores" //특정 값 패턴 조건
            else -> "I want your machine"    //패턴 불일치
        }

if 조건식 처럼 사용 가능

val num = 12

when {
    num < 0 -> println("음수")
    num == 0 -> println("ZERO")
    num % 2 == 0 -> println("짝수")
    else -> println("홀수")
}

예외처리

특 정 조건에서 예외가 발생할 경우 프로세스가 중단되는 것을 방지하기 위한 처리방법

try {
    [내용]
} catch (e : Exception) {
		[예외처리]
} finally {
    [나머지 처리]]
}

예외 던지기

throw 키워드를 통해 예외를 강제로 발생 시킬 수 있으며 예외가 발생하면 catch문에서 예외를 처리해준다.

try {
    throw Exception("예외 강제 발생")
} catch (e : Exception) {
    println(e);
} finally {
    println("나머지 처리")
}

fun main(args: Array<String>) {
		try {
        exp();
    } catch (e : Exception) {
        println(e)
    } finally {
        println("나머지 처리")
    }
}

fun exp() : Nothing {
    return throw Exception("exp() 예외발생");
}

예외 처리를 변수에 할당하여 결과 값을 변수에 할당되게 할 수 있다.

val exVal = try {
    100
    throw Exception("예외발생")
} catch (e : Exception) {
    200
} finally {
    300;
}
println(exVal);// 200