Scala クイックリファレンス

変数と定数

• 変数の定義

var x:Int = 10

• 定数の定義

val x:Int = 10

配列

var xs1:Array[Int] = new Array[Int](10);
var xs2:Array[Int] = Array[Int](1,2,3);
var a = xs2(0) //要素にアクセスする,a = 1;

コメント

/* comment1 */
// comment2

コレクション

List

val xs1:List[Int] = List()
val xs2:List[Int] = List(1,2,3)
var a = xs2(0) //要素にアクセスする,a = 1;
val xs3 = xs1 :: xs2 //Listを結合する。
val xs4 = Nil //空のList

Listのメソッド

メソッド	説明
head	Listの先頭要素を返す
tail	Listの先頭要素を除く要素のListを返す
isEmpty	Listが空であればtrueを返す
length	Listのサイズを返す

Map

val map = Map[String,Int]("key1"->1,"key2"->2,"key3"->3) 
 
val a = map("key1") //要素にアクセスする

Mapのメソッド

メソッド	説明
empty	空のMapを返す
+	指定したキーと要素とペアを追加したMapを返す
-	指定したキーの要素を抜いたMapを返す
size	Mapのサイズを返す
keySet	キーのセットを返す
values	Mapの値をIterableで返す

Tuple

異なる型の要素を格納可能

val tuple = ("val1",10,"1234",200.0)
 
tuple._1 //要素にアクセスする
tuple._2 //要素にアクセスする
tuple._3 //要素にアクセスする
tuple._4 //要素にアクセスする

構文

条件文

Scalaのifは最後に評価された値を返す。

if( x > 5 ) println("true") else println("false")
 
//else if文
if( x > 5 ){
    println("x>5")
}else if (x == 1){
    println("x=1")
}else{
    println("else") 
}

for文

val xs = List(1,2,3,4,5)
val ys = List(100,200,300,400,500)
 
for( x <- xs; y <- ys){
  println(x+y)
}
 
//フィルタ
for( x <- xs if x>3){
  println(x)
}
 
//yield、新しいコレクションの生成
val xs = List(1,2,3,4,5)
val ys = for( x <-xs) yield x + 100 //ys = List(101, 102, 103, 104, 105)

while文

var i = 0
while( i<10 ){
   println(i)
   i += 1
}

do-while文

var i = 0
do{
   println(i)
   i += 1
}while( i<10 )

例外処理 try、catch、finally

//例外処理
try{
  var z = 100/0
}catch{
  case e => { println("exception!") }
 
}finally {
  println("finally!")
}
 
//例外の発生
throw new Exception("throw Exception!")

パターンマッチ

var x = 1
x match{
  case 1 => println("x is 1")
  case 2 => println("x is 2")
  case _ => println("default")
}
 
//パターンガード
x match {
  case x:Int => println("x is Int") //データの型でマッチング
  case x if x  < 5 => println("x<5") //if文でマッチング
  case _ => println("default")
}

関数

• 関数定義

def func(x:Int,y:Int) = x + y
def func(x:Int = 100 ,y:Int = 200) = x + y //デフォルト引数
def func(x:Int):Unit = println( "x ="+x ) //戻り値のない関数

• 可変長引数

def fx(args:Int*) =  for( x <- args ){ println(x) }
 
val xs = Array(100,200,300) //Arrayを引数に渡すときは":_*"を付加する
fx(xs:_*)

• プレイスホルダ

val fx:(Int,Int) => Int = _ + _
val gx = (_:Int) + (_:Int)

• 無名関数

val func = (x:Int,y:Int) => x+y
val func: (Int,Int) => Int = (x:Int,y:Int) => x+y //funcの型を明示的に宣言
func(1,2) //関数の呼び出し

• 部分適応

val fx = (x:Int,y:Int) => x+y
val gx = fx(_:Int,100)
gx(5) // 結果=105

• クロージャ

def inc() = {
  var n = 0
  () => {n+=1;n}
}
 
val fx = inc()
fx()// 戻り値=1
fx()// 戻り値=2
fx()// 戻り値=3

• サンプル

• 関数を引数に取る関数

def fx( gx:(Int,Int)=>Int , x:Int ) = gx(x,x)
fx((x,y)=>x+y,7) // 結果=14
fx((x,y)=>x*y,7) // 結果=49

• 高階関数

def fx(x:Int) = (y:Int,z:Int) => x + y + z
val gx = fx(1000)
gx(100,5) //結果=1105

• ローカル関数

def fx(x:Int,y:Int):Int = {
    def gx(x:Int) = {2*x}
    return (gx(x)+y)
}
 
fx(100,5) //戻り値=205

クラス

• クラスの宣言

class ClassA(var i:Int){ //基本コンストラクタの引数 varやvalを指定しないで引数を記述すると、フィールドへクラス外からアクセスできなくなる。
  // 基本コンストラクタ start
  println("init")
  var x = 100 //フィール定義
  var y = i //フィール定義
  // 基本コンストラクタ end
 
  def show() = println(this.x) //メソッド定義
}
 
var classA = new ClassA(5) //インスタンス生成
 
var classA = new ClassA()
classA.x //フィールドアクセス
classA.show() //メソッドアクセス

• メソッドのオーバーロード

class ClassA(){
  def print(x:Int) = println(x)
  def print(x:String) = println(x)
  def print(x:Int,y:String) = println(x)
}

• 補助コンストラクタ

基本コンストラクタをオーバーロードする場合に定義する。

class ClassA(var a:Int,var b:Int){
  // 基本コンストラクタ start
  println("init")
  var x = a+b
  // 基本コンストラクタ end
 
  def this() = this(100,10) //補助コンストラクタ
  def this(n:Int) = this(100,n) //補助コンストラクタ
 
  def show() = println(this.x)
}
 
var c1 = new ClassA(1000,5) //基本コンストラクタの呼び出し x=1005
var c2 = new ClassA() //補助コンストラクタの呼び出し x=110
var c3 = new ClassA(5) //補助コンストラクタの呼び出し x=105

• シングルトンオブジェクトの宣言

object ClassA{  
  def print(x:Int) = println(x)
}
 
ClassA.print(5)

• コンパニオンオブジェクトの宣言

同じ名前を持つclassとobjectが存在するとき、それをコンパニオンオブジェクトと呼ぶ。 コンパニオンクラスのprivateなフィールドやメソッドに対してアクセスができる

class ClassA private (a:Int){ //基本コンストラクタをprivateとして宣言
  var x = a
}
 
object ClassA{
  def apply(a:Int) = {
    new ClassA(a)
  }
}
 
val classA = ClassA(100) 
println(classA.x) // x = 100