Example code of Scala Collections (Scala のコレクション・クラスの使用例)

gistfile1.scala

//
// Scala の Array の実体は Java の配列
// - 各成分は mutable
// - 要素数の動的変更はできない
// - 必要に応じて implicite conversion で WrappedArray に変換されるため
//   Seq (or IndexedSeq ≒ Vector) と同じように扱うことができる
//

var xs = Array(1,2,4,8,16,32)    // 6個の成分を列挙した配列を作る
xs(3)                            // 丸カッコで index を与える
xs.apply(3)                      // 実際にはこのメソッドが呼び出される（ようにコンパイルされる）
xs.length()                      // 要素数を得るメソッド
xs.length                        // Scala では，無引数のときカッコを省略してよい
xs.size()                        // length と同じ
xs.size

var xs = new Array[Int](10)      // Int の配列で成分の個数が10
xs(9) = 512                      // mutable なのでいつでも代入できる

// 以上が基本機能
// Java の Array だから，これしか機能はない。
// しかし implicit conversion により WrappedArray に変換されるため Seq の機能を持つ
// Seq については，次で述べる

// また，他のコレクションに合わせて，次のような初期化ができる。
// 多次元配列（ただし，現在のコレクションライブラリでは 5次元まで）を簡単に作れる

Array.ofDim[T](n)                // new Array[T](n) と同じ
Array.ofDim[T](n1, n2)           // 2次元配列
Array.ofDim[T](n1, n2, ..., n5)  // 5次元配列
Array.fill[T](n){ math.random } 　// 乱数を初期値とする配列； random は成分ごとに呼び出され，
　　　　　　　　　　　　　　　　　　　// 各成分には異なる値が代入される
Array.fill[T](n1,n2,n3,n4,n5){ math.random } 　// 5次元まで可能
Array.tabulate(n){ k => f(k) }   // インデックスを引数とする関数で初期化
Array.tabulate(n){ f(_) }        // プレースホルダによるシンタックスシュガー
Array.tabulate(m,n){ (i,j) => f(i,j) }   // 2次元以上だとインデックスはタプルで与える
Array.tabulate(m,n){ f(_,_) }            // プレースホルダによるシンタックスシュガー


//
// List の基本機能
//

var xs = List(1,2,3,4,5)
Nil                           // 空リスト：List() と同じ
1::Nil　　　　　　　　　　　　　　// List(1) と同じ
1::2::Nil　　　　　　　　　　　　// 1::(2::Nil) のこと；List(1,2) と同じ
1::2::3::Nil　　　　　　　　　　// List(1,2,3) と同じ

// 次のようなパターンマッチで :: の左右に分解できる
var x::xs = List(1,2,3)

// x: Int = 1
// xs: List[Int] = List(2, 3)

// パターンマッチは，代入よりも match 文でよく使われる

// 次のメソッドでも :: の左右を得られるが，あまり使わない
xs.head                         // 先頭の成分 (Lisp の car)
xs.tail                         // 先頭を除いた成分 (Lisp の cdr)

// その他 Seq のメソッドが使える

// List 固有の機能

List(1,2,3):::List(4,5,6)      // 右結合の ++ ; データ構造に起因する理由によりこちらの方が高速
List(1,2,3) reverse_::: Nil    // reverse append

//
// Seq
//

// 初歩

var xs = Seq(1,2,4,8,16,32)
var ys = Seq(64,128,256,512,1024)

xs(3)
xs.apply(3)
xs ++ ys
xs.length
xs.size
xs.isEmpty

// 基礎
xs.take(3)
xs.drop(3)
xs.split(3)
xs.indexOf(4)
xs.lastIndexOf(4)
xs.startWith(List(1,2))
xs.endsWith(List(16,32))


// 集約する演算
xs.sum
xs.product
xs.max
xs.min
xs.mkString(" + ")
xs.mkstring("(", " + ", ")")

// 高階関数
xs.map(x => x*x)
xs.filter(x => x % 2 == 0)
xs.filterNot(x => x % 2 == 0)

xs.takeWhile(x => x < 5)
xs.dropWhile(x => x < 5)
xs.partition(x => x < 5)

xs.foldLeft(0){ (s,x) => s+x }
xs.foldRight(List(64,128)){ (x,xs) => x::xs }
xs.reduceLeft{ (min, x) => if (min < x) min else x }

xs.count{x => x % 2 == 0}
xs.forall{x => x % 2 == 0}
xs.exists{x => x % 2 == 0}

xs.sortBy{x => -x}
xs.sortWith{(x,y) => x > y}