HAMA 블로그

이 시리즈는 스칼라언어의 창시자인 마틴 오더스키가 직접 저술한   Programming in Scala (2판)   

을 참고로 하여 정리할 예정입니다.  잘못된 점이 있으면 지적해주시면 바로 수정하겠습니다.

List

스칼라의 배열이 값을 변경 할 수 있는 순서가 정해진 시퀀스라면 스칼라의 리스트는 기본적으로  값을 변경 할 수 없는 시퀀스입니다. 

배열 생성과 비슷합니다.

val x = List.fill(3)("foo") // List(foo, foo, foo)

List.tabulate(5)(n => n * n) // List(0, 1, 4, 9, 16)

val a = List(1,2,3) 

a(2)  

두개의 리스트 합치기 

두개의 리스트를 합쳐보겠습니다.

val a = List(1,2)

val b = List(3,4)

val c = a ::: b

이렇게 합니다.

:::  는 두개의 리스트를 합쳐주는 메소드 입니다.

val d = a ++ b  이렇게 할 수도 있습니다.  ( ::: 는 오로지 리스트에서만 사용) 

Scala list concatenation, ::: vs ++

리스트 앞에 요소 추가 

그럼 앞에다가 요소하나를 붙여주는 메소드는 무엇일까요?

List(1,2) 앞에다가 0 을 붙여서  (0,1,2) 로 만드는 방법 말이죠.

그건  :: 입니다.  콜론이 2개짜리네요.

근데 여기서 생각해 볼것은 서두에 List 는 변경 불가능하다고 했는데 앞에 숫자를 붙히다니? 

무슨 소리하는지 의심스러울거 같은데요.

예를 한번 봅시다.

val a = List(1,2)

val b = 0 :: a

이건데요. 

네 a 를 바꾼게 아니었습니다.  a 앞에 0 을 추가한 또 다른 b 라는 List 를 만든거에요.

즉 무엇을 변경해서 쓰려면, 기존것은 냅두고 기존것을 이용해서 새것을 만들어서 쓰라는 말입니다.

또 궁금한게 있을거 같은데요.

도대체 0 :: a 를 하는데 어떻게 a 앞에 0 이 들어가게 되는지 말이죠.

그 이유는 

:: 메소드는 0 의 메소드가 아니라  a 의 메소드입니다. 근데 앞에 있는 이유는 

그냥 규칙입니다. -.-;; 

우리의 마틴오더스키씨는 아주 많은걸  자신이 만든 언어에 쑤셔 넣었습니다.

그 규칙은 이름이 콜론(:) 으로 끝나는 메소드는 오른쪽 피연산자의 것으로 호출한다. 라고 합니다.

따라서

0 :: a  는  a.::(0) 이 되는 것입니다.

리스트 뒤에 요소 추가 

그럼 뒤에 추가하는것은 무엇일까요?

:+  입니다.

예를들어  

val a = List(1,2)

val b = a :+ 2

이런거죠.

하지만 웬간하면 이걸 쓰지마세요.

뒤에 추가하는 연산은 리스트의 길이만큼 오래 걸린다고 합니다.

이걸 효율적으로 하려면

일단 리스트를 뒤집고, 앞에다가 원소를 추가한후에 다시 뒤집으세요.

(4 :: List(1,2,3).reverse).reverse

List(1,2,3) ::: List(4)

입니다.

List 의 다양한 메소드들 

자 이런 변경 불가능한 List 를 사용해서 편하게 작업할 수 있는 방법들이 무지 많습니다.

문제는 편해지려면 이거 공부하고 외워야한다는거죠.  러닝커브가 올라갑니다. ;;

대표적인 몇가지만 살펴보도록 하겠습니다.

// 빈리스트

List()   

// 두번째 인덱스 원소 얻기 

val a = List(1,2,3) 

a(2)

// 두번째 원소 까지  제거

val a = List(1,2,3) 

val b = a.drop(2) 

결과 : List(3)  

눈여겨 볼것은 자체의  원소를 제거한게 아니라,  원소 제거한 새로운 리스트를 반환합니다. 

// 요소중 길이가 3인것의 개수를 센다

val a = List ("hello", "world", "boy") 

a.count(s=> s.length == 3)   

s=> s.length == 3 은 람다식이죠? 인자가 s 인 함수란 야그입니다.  다음과 같아요

bool  func ( s ) {

  return s.length == 3

}

// 리스트의 각 원소를 변경하여 새 리스트를 반환합니다. 여기선 각 문자열 뒤에 X 를 붙힙니다.

val a = List ("hello", "world", "boy") 

val b = a.map(s => s + "X") 

자 다양한 메소드를 보았는데요. 이거 말고도 더 있긴합니다. 근데 여기서 생각해 봐야할것은 메소드가 많구나~~ 이게 아닙니다.
이런 메소드를 사용함으로써 var 를 안쓰게 됬다는겁니다. var 은 변경 가능한 변수를 만들때 씁니다.
예를들어 
위에서 count 같은 경우 대략 함수를 만들어 보면 

def count( all : Seq[String] ):Int = { 
   var temp = 0  
   for ( one <-  all ) {       
    if ( one.length == 4 )          
       temp = temp + 1   
    } 
    temp
}

이렇게 되잖습니까? 위에 보면 var 가 사용되었네요. 스칼라에서는 var 를 사용하지 말도록 합시다!!! (마틴오더스키는 var, val 둘다 만들어서 알아서 적재적소에 쓰이길 바랬지만 , 제 글을 보시는 분들은 절대로 var 를 안쓰는 방향으로 '만' 생각하자구요. ) 

* 재귀를 활용한 count 함수  

 def count(list: Seq[String]): Int = {      
 	@tailrec def count(value: Int, remaining: Seq[String]): Int = {       
      remaining match {         
      	case head :: tail if head.length == 4 => count(value + 1, tail)         
        case head :: tail => count(value, tail)         
        case Nil => value       
        }     
     }      
     count(0, list)   
 }

이렇게 count 를 var 없이 구현 할 수 있습니다. 꼬리재귀라는것을 사용한것인데요

순수함수형 언어에서는 재귀를 주로 사용한다네요. 공재귀로 분해해보는 연습을 해야 합니다. 이거보고 스칼라는 쓸 때없이 복잡한거네라고 생각하지마시구요 여기서는 그냥 이런게 있구나 하고 지나치시고 나중에 다시 차근차근 쉽게쉽게 살펴보자구요. 분명히 먼가 좋으니깐 저렇게 쓰는거다라고 생각하시고 넘어갑시다.

마지막 

List 의  짜증나는 규칙을 하나 억지로 외워봅시다.

val a = 1 :: 2 :: 3 :: Nil

는 List(1,2,3) 을 만들게 됩니다.

저 Nil 은 뭘까요? 

리스트 끝에 Nil 이 필요로 하는 이유는 :: 메소드가 List 클래스의 멤버이기 때문이랍니다.

만약 1 :: 2 :: 3 만 사용했다고 치면 , 마지막의 3 이 Int 형이라서 :: 메소드가 없기때문에

그냥 꽝이 되버리는 반면

마지막에 Nil 을 넣어주게되면 Nil 은 List 의 멤버이기때문에 타입을 추론해서 List 로 만들어 줍니다. 

이 시리즈는 스칼라언어의 창시자인 마틴 오더스키가 직접 저술한   Programming in Scala (2판)   
을 참고로 하여 정리할 예정입니다.  잘못된 점이 있으면 지적해주시면 바로 수정하겠습니다

Array

요렇게 넣으면 됩니다.  

여기서 눈여겨 볼것은 일단 val 로 선언했는데 값을 바꾼겁니다. 이건 전에 얘기했다시피 변수를 재 할당 할 수 없는거지, 변수가 가르키는 객체 안의 내용은 여전히 변경가능하다는거죠. 

- 자바에서는 String a[] = new String[2] 이렇게 만듭니다. 
- 코틀린에서는 
var array1 : Array<String?> = emptyArray()
var array2: Array<String?> = arrayOfNulls(4)
var array3 = arrayOf<String>("Mashroom", "Kitkat", "Oreo", "Lolipop")
var array4 = Array(2, {""}))

자 그럼 값을 출력해볼까요?

값 가져오기

print(a(0)) 

이렇게 하면 값을 꺼내와서 출력에 사용합니다.

() 를 통해서 접근했는데요. 어떻게 가능 할까요??

스칼라에서는 변수 뒤에 하나 이상의 값을 괄호로 둘러싸서 호출하면 

그 변수의 apply() 메소드를 호출하는것으로 바꾸어줍니다.

즉 a.apply(0) 이렇게 변경된다는거죠. 

a(0) 는 a.apply(0) 입니다. 배열객체에서 apply 는 해당 인덱스에 해당하는 값을 꺼내오는 겁니다.

이런 apply 는 배열객체에만 있는건 아닙니다. 

값 넣기  

그럼 값을 짚어넣는건 어떻게 된걸까요?

a(0) = "hello"

이거 말입니다.  이것도 역시 생략된것인데요.

괄호로 둘러싼 인자들이 있는 표현식에 할당이 되면 컴파일러는 

a.update(0, 'hello') 이렇게 바꾸어줍니다.  

즉 값을 가져오거나 넣을때 사용하는 () 는 좀 편하게 쓰라고 스칼라 창시자가 만든 장치입니다.

실상은 메소드 호출이란 야그죠. 

배열을 만드는 더 간편한 방법 

val a = Array("hello", "world") 

이렇게 만들 수 있습니다.

new 도 생략되었고 [String] 도 생략되었습니다.

[String]  생략

초기화할때 인자로 String 이 들어가기때문에 타입을 추론한겁니다.

new  생략

암시적으로 apply 라는 이름의 팩토리 메소드를 호출해서 객체를 만들어줍니다.

Array.apply("hello", "world") 원랜 이런거란거죠.

스칼라 창시자는 참 별걸 다 신경써서 만들어 주네요.

마침.

위에서 보면 값을 할당하고 그러잖아요? 네 Array 는 변경가능합니다. 변경 불가능 한것도 있다고 하네요. 

스칼라 언어는 변수의 값을 변경 할 수 있냐? 없냐를 매우 중요하게 생각하는거 같습니다.