코딩 바보의 Scala 입문하기 #3 Collection

Scala #3

scala> def double(x:Int):Int = x * 2
double: (x: Int)Int

scala> double(4)
res3: Int = 8

scala> def double(x:Int):Int = {
     | x * 2}
double: (x: Int)Int

val이 불변을 의미하고, var는 값이 변할 수 있음을 뜻한다. 스칼라에서는 가급적으로 var을 가급적 피하는 것이 최선이다.

scala> var mutable = "I am mutable"
mutable: String = I am mutable

scala> mutable ="True and False , So "
mutable: String = True and False , So

scala> val immutable = "Solution"
immutable: String = Solution

scala> immutable = "val"
<console>:11: error: reassignment to val
       immutable = "val"
                 ^

컬렉션

scala> List(1,2,3)
res4: List[Int] = List(1, 2, 3)

scala> List("one","two","Three")
res5: List[String] = List(one, two, Three)

scala> List("one","two",3)
res6: List[Any] = List(one, two, 3)

scala> List("one","two",3)(2)
res7: Any = 3

scala> Nil//빈 리스트이다.
res8: scala.collection.immutable.Nil.type = List()

scala> val animals = Set("lions","tigers","bears")
animals: scala.collection.immutable.Set[String] = Set(lions, tigers, bears)

scala> animals + "cat"
res9: scala.collection.immutable.Set[String] = Set(lions, tigers, bears, cat)

scala> animals - "tigers"
res10: scala.collection.immutable.Set[String] = Set(lions, bears)

scala> animals ++ Set("tiger","cat","doc"
     | )
res11: scala.collection.immutable.Set[String] = Set(bears, tiger, tigers, lions, doc, cat)

scala> animals ++ Set("bears")//합집합 연산
res12: scala.collection.immutable.Set[String] = Set(lions, tigers, bears)

scala> animals -- Set("bears")//차집합 연산
res13: scala.collection.immutable.Set[String] = Set(lions, tigers)

scala> animals & Set("tigers")//교집합 연산
res15: scala.collection.immutable.Set[String] = Set(tigers)//실제 집합에는 영향이 없다.

아래의 차이점은 무엇일까?

scala> Set(1,2,3) == Set(3,2,1)
res16: Boolean = true

scala> List(1,2,3) == List(3,2,1)
res17: Boolean = false

바로 , 리스트는 순서를 고려하지만, 집합은 순서를 고려하지 않는다.

scala> val myMap = Map (0 -> "zero", 1 -> "one")                             
myMap: scala.collection.immutable.Map[Int,String] = Map(0 -> zero, 1 -> one) 

scala> myMap(1)                                                              
res18: String = one                                                          

scala> import scala.collection.mutable.HashMap                               
import scala.collection.mutable.HashMap                                      

scala> val map = new HashMap[Int,String]                                     
map: scala.collection.mutable.HashMap[Int,String] = Map()                    

scala> map += 4 -> "four"                                                    
res19: map.type = Map(4 -> four)                                             

scala> map += 0 -> "zero"                                                    
res20: map.type = Map(4 -> four, 0 -> zero)                                  

scala> map += "1" -> 1                                                       
<console>:13: error: type mismatch;                                          
 found   : (String, Int)                                                     
 required: (Int, String)                                                     
       map += "1" -> 1                                                       
                  ^

Any와 Nothing

Any는 스칼라의 클래스 계층 구조에서 가장 상위에 존재하는 뿌리 클래스이다. Root type이라 생각 할 수 있을 것 같다.

마찬가지로 Nothing은 모든 자료형의 하위 자료형이다. 즉, 모든 것은 Any를 상속하고, Notthing은 모든 것을 상속한다.

nil 개념

Null은 Trait이고, null은 Null 자료형의 인스턴스로 자바의 null과 비슷하다. 즉, 텅빈 값으로 생각 할 수 있다.
Nothing은 모든 것의 하위 자료형에 해당하는 트레이트이며, Nothing은 인스턴스가 없기 때문에 그에 대한 참조를 Null처럼 제거(derefence) 할 수 없다.

컬렉션과 함수

scala> val list = List("call","cat","doc","mus")
list: List[String] = List(call, cat, doc, mus)

scala> list.foreach(idx => println(idx))
call
cat
doc
mus

scala> val test = Set("fro","pro","test","commig up")
test: scala.collection.immutable.Set[String] = Set(fro, pro, test, commig up)

scala> test.foreach(idx => println(idx))//익명 함수 사용
fro
pro
test
commig up

scala> val map_test = Map("one" -> 1, "Two" -> 2)
map_test: scala.collection.immutable.Map[String,Int] = Map(one -> 1, Two -> 2)

scala> map
map   map_test

scala> map_test.foreach(idx -> println(map_test))
<console>:13: error: not found: value idx
       map_test.foreach(idx -> println(map_test))
                        ^

scala> map_test.foreach(idx => println(map_test))
Map(one -> 1, Two -> 2)//튜플을 리턴한다.
Map(one -> 1, Two -> 2)

List 관련 메소드

scala> list
res26: List[String] = List(call, cat, doc, mus)

scala> list.isEmpty
res27: Boolean = false

scala> list.length
res28: Int = 4

scala> list.size
res29: Int = 4

scala> list.head
res30: String = call

scala> list.tail
res31: List[String] = List(cat, doc, mus)

scala> list.last
res32: String = mus

scala> list.init
res33: List[String] = List(call, cat, doc)

scala> list.reverse//리스트 반전
res34: List[String] = List(mus, doc, cat, call)

scala> list.drop(1)//처음 n개의 요소가 제거된 리스트
res35: List[String] = List(cat, doc, mus)

scala> list
res36: List[String] = List(call, cat, doc, mus)

scala> list.drop(2)
res37: List[String] = List(doc, mus)

count, map, filter 및 기타 메서드

scala> val seungdols = List("paypal","gold star","Lucky star") 
seungdols: List[String] = List(paypal, gold star, Lucky star)  

scala> seungdols.count(seungdols => seungdols.size>2)          
res38: Int = 3                                                 

scala> seungdols.filter(seungdols => seungdols.size > 2)       
res39: List[String] = List(paypal, gold star, Lucky star)      

scala> seungdols.map (seungdols => seungdols.size)             
res40: List[Int] = List(6, 9, 10)                              

scala> seungdols.forall(seungdols => seungdols.size>1)         
res41: Boolean = true                                          

scala> seungdols.exists(seungdols => seungdols.size>4)         
res42: Boolean = true

foldLeft

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)
scala> val sum = (0 /: list) {(sum,i) => sum + i}
//초기 값 /: 코드 블록
sum: Int = 15

커링 (Currying)

여러 개의 매개변수를 받아들이는 함수를 저마다의 매개변수를 받아들이는 여러 개의 작은 함수로 변형시키는 기법을 사용하는 것을 말함.

scala> val list = List(1,2,3)
list: List[Int] = List(1, 2, 3)
scala> list.foldLeft(0)((sum, value) => sum + value)
res43: Int = 6