Scala 문법

원시 타입

• Scala 는 1(Int 리터럴) 과 같은 원시 타입(Primitive Type) 은 Object 로 취급한다.
  • java 원시 타입은 정수, 실수, 문자, Bool 과 같은 literal 의 실제 데이터 값을 저장하는 타입이고,
  • java 참조 타입은 Object 의 메모리 주소를 참조하는 타입이다.
  • scala 에서는 정수를 Object 로 참조하여 참조 타입 으로 취급하지만, 컴파일 이후에는 성능을 위해서 java 의 원시 타입을 사용한다.
• 1 + 2 와 같은 식에서 + 는 (1) 이라는 원시 타입 Object 의 method 다. 즉, 1 + 2 의 표현은 (1).+(2) 표현과 같다.
• Scala 는 +-*/ 같은 연산자 method 의 우선순위를 정하고 있다.

object Practice {
  def main(args: Array[String]): Unit = {
    println(1 + 2)
    println((1).+(2))
  }
}

// output:
// 3
// 3

변수, 상수

• 변수는 var, 상수는 val 로 선언한다.

object Practice {
  def main(args: Array[String]): Unit = {
    var a = 1 + 2
    println(a)
    a = 3 + 4
    println(a)

    val b = 1 + 3
    println(b)
//    b = 3 + 5  // 에러 발생, 상수에 값을 변경 할 수 없다.

    var l,m,n = 4
    println(l,m,n)

    val x,y,z = 5
    println(x,y,z)
  }
}

// output:
// 3
// 7
// 4
// (4,4,4)
// (5,5,5)

string 에 변수 값 넣기

• s"$x + $y = ${x + y}" 와 같이 s 를 prefix 로 붙이고, $ 와 변수명을 이용해서 string 에 변수 값을 넣을 수 있다.

object Practice {
  def main(args: Array[String]): Unit = {
    var x = 1
    var y = 2
    println(s"$x + $y = ${x + y}")

    var z = s"$x + $y = ${x + y}"
    println(z)
  }
}

// output:
// 1 + 2 = 3
// 1 + 2 = 3

method

• 함수와 비슷하게 보이고 동작하는 것으로 보이지만, 차이점 존재
• def 키워드로 메소드를 정의하고 이름, 매개변수, 반환 타입, 본문을 구성한다.
• 여러 줄의 표현식을 가질 수 있다.

object Practice {

  // 가장 기본 형태의 메소드, def 메소드명(파라미터) = { 코드블럭 } 로 블록을 만든다.
  // input arguments 로 사용 하는 이름과 타입,
  // output 의 타입을 정의하고,
  // return 을 통해 output 을 반환한다.
  def add1(a:Int, b:Int): Int = {
    return a + b
  }

  // scala 는 블록의 마지막 라인이 반환 문이기 때문에 return 을 명시하지 않아도 된다.
  def add2(a:Int, b:Int): Int = {
    a + b
  }

  // 블록의 라인이 한 줄인 경우 {} 를 생략하고 사용 할 수 있다.
  def add3(a:Int, b:Int): Int = a + b

  def main(args: Array[String]): Unit = {
    println(add1(2, 3))
    println(add2(2, 3))
    println(add3(2, 3))
  }
}

function

• 매개변수를 가지는 표현식
• => 를 기준으로 왼쪽에는 매개변수 오른쪽에는 매개변수를 이용한 표현식으로 구성된다.

object Practice {

  // 매개변수로 메소드를 받고, Int 형으로 리턴
  def wrapMethod(f: (Int, Int) => Int): Int = {
    // 매개변수 함수에 2, 3을 인자로 준다
    f(2, 3)
  }

  def main(args: Array[String]): Unit = {
    // 변수명, 타입을 명시적으로 선언하는 익명함수
    val ex1 = wrapMethod((a: Int, b: Int) => a + b)

    // 타입을 생략한 익명함수, wrapMethod 에 타입이 명시되어 있기 때문에 가능
    val ex2 = wrapMethod((a, b) => a + b)

    // wrapMethod 함수에 매개변수에 메소드 형태가 명시되어 있기 때문에 output 의 형태를 지정해 줄 수 있다.
    val ex3 = wrapMethod(_ + _)

    // 아래와 같이 곱하기 동작도 가능
    val ex4 = wrapMethod(_ * _)

    println(ex1, ex2, ex3, ex4)
  }
}

object Practice {

  // 메소드
  def add1(a:Int, b:Int) = a + b

  // 익명함수를 add2 상수에 assign
  val add2 = (a:Int, b:Int) => a + b

  // add3 의 타입이 (Int, Int) => Int 형태라고 명시하고, _ + _ 를 assign
  val add3: (Int, Int) => Int = _ + _

  def main(args: Array[String]): Unit = {
    println(add1(2, 3))
    println(add2(2, 3))
    println(add3(2, 3))
  }
}

Collections

Array

• java 의 배열과 같은 개념. java 의 int[] = scala Array[Int]
• mutable (값을 변경 할 수 있다, 배열 사이즈 X)

List

• scala.collection.immutable.List 이다.
• immutable (값을 변경 할 수 없다.)
• 값을 추가하거나 제거하면, 새로운 리스트를 만들어 낸다.
• Linked List 로 구현된다.

Set

• Predef.Set 이 기본 Set 이다.
• Set 은 크기가 1~4 까지는 별도 클래스가 존재한다. Set1, Set2, Set3, Set4
• 4보다 많아지는 Set 은 HashSet 으로 구현한다.
• Set 은 집합에 대응 하는 개념으로 값을 추가하면 기존 값을 덮어쓰고, 순서를 보장되지 않는다.

Map

• Predef.Map(scala.collection.immutable.Map) 이 기본 Map 이다.
• key, value 짝 형태로 구성 된다.
• Map 은 구성요소가 1~4 개 까지는 별도 클래스가 존재한다. Map1, Map2, Map3, Map4
• 4보다 많아지는 Map 은 HashMap 으로 구현한다.
• key 는 중복되지 않고, 순서가 보장되지 않는다.