S-JIS[2011-02-13/2016-10-10] 変更履歴

Scalaコレクションメソッド

Scalaのコレクションの主なメソッド一覧。主なっちゅうか、共通メソッドとしてはほぼ全部。多すぎるわ！(苦笑)

全要素の順次処理

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] foreach [U] f: A => U Unit コレクションの全要素を1回ずつ処理する。
関数fの引数はコレクションの要素。fの戻り値は無視される。		 List(1,2,3).foreach(n => println(n)) 1
2
3
Traversable[A] map [B, T] f: A => B T コレクションの要素を変換する。
関数fでAを処理してBの値を返すことにより、Bのコレクションが作られる。
→filterとmapを同時に行いたいならcollect		 List(1,2,3).map(n => n*2) List(2, 4, 6)
Map('a->1,'b->2,'c->3).map(t => t._2*2) List(2, 4, 6)
Map('a->1,'b->2,'c->3).map(t => (t._1,t._2*2)) Map(('a,2), ('b,4), ('c,6))
Seq[A] reverseMap [B] f: A => B Seq[B] mapの逆順。 List("a2","b1","c4", "d3").reverseMap(s => s(1)) List(3, 4, 1, 2)
Map[K, V] mapValues [C] f: V => C Map[K, C] 値を変換したMapを返す。 Map(1->2,3->4,5->6).mapValues(v => Symbol(v.toString)) Map((1,'2), (3,'4), (5,'6))
Map[K, V] transform 　 f: (K, V) => V Map[K, V] 可変Mapの場合は自分の値を変換する。
不変Mapの場合は新しいMapを返す。		 val m = Map(1->2,3->4,5->6)
m.transform((k,v) => k+v)		 Map((1,3), (3,7), (5,11))
Traversable[A] flatMap [B, T] f: A => Traversable[B] T コレクションの要素を変換する。
関数fでAを処理して複数のBを返すと、それらを結合した新しいコレクションが作られる。		 List(0,1,2).flatMap(n => List(n,'A'+n)) List(0, 65, 1, 66, 2, 67)
Traversable[A] collect [B, T] pf: PartialFunction[A, B] T filterとmapを合わせたようなもの。[2011-06-24]
caseにマッチした結果だけでコレクションが作られる。		 List(1,2,3).collect{ case 1 => "one"; case 2 => "two" } List(one, two)
List[Any]("a",1,"b",2).collect{ case s:String => s } List[String](a, b)
Traversable[A]
（2.9.0〜）		 collectFirst [B] pf: PartialFunction[A, B] Option[B] caseにマッチした最初の値を返す。[2011-09-18] List(1,2,3).collectFirst{ case 2 => "two" } Some(two)
Traversable[A] flatten [B] implicit t: A => Traversable[B] Traversable[B] 要素がTraversableのとき、それを外して平坦化する。 List(Set(1,2),Set(3,4),Set(5,6)).flatten List(1, 2, 3, 4, 5, 6)
Traversable[A] transpose [B] implicit t: A => Traversable[B] Traversable[Traversable[B]] コレクションを組み替える？ List(Set(1,2,3),Set(4,5,6),Set(7,8,9)).transpose List(List(1, 4, 7), List(2, 5, 8), List(3, 6, 9))
Traversable[A] unzip [A1, A2] implicit a: A => (A1, A2) (Traversable[A1], Traversable[A2]) 要素を分離し、2つのコレクションにして返す。 List((1,'a),(2,'b),(3,'c)).unzip (List(1, 2, 3),List('a, 'b, 'c))
Traversable[A]
（2.9.0〜）		 unzip3 [A1, A2, A3] implicit a: A => (A1, A2, A3) (Traversable[A1], Traversable[A2], Traversable[A3]) 要素を分離し、3つのコレクションにして返す。[2011-09-18] List((1,'a,"foo"),(2,'b,"bar"),(3,'c,"zzz")).unzip3 (List(1, 2, 3),List('a, 'b, 'c),List(foo, bar, zzz))
Iterable[A] zip [B] that: Iterable[B] Iterable[(A, B)] 2つのコレクションの同じ位置の要素をペアにしたコレクションを返す。
長さは短い方に合わせられる。		 List(1,2,3,4) zip List('a,'b,'c) List((1,'a), (2,'b), (3,'c))
Iterable[A] zipAll [B] that: Iterable[B]
thisElem: A
thatElem: B		 Iterable[(A, B)] 2つのコレクションの同じ位置の要素をペアにしたコレクションを返す。
足りない要素は引数の値で補われる。		 List(1,2,3,4).zipAll( List('a,'b,'c), 0, 'z) List((1,'a), (2,'b), (3,'c), (4,'z))
Iterable[A] zipWithIndex 　 　 Iterable[(A, Int)] 要素と位置（インデックス）をペアにしたコレクションを返す。 List('a,'b,'c).zipWithIndex List(('a,0), ('b,1), ('c,2))
Seq[A] indices 　 　 Range 要素の位置（インデックス）のコレクションを返す。 List('a,'b,'c).indices Range(0, 1, 2)
Seq[A] sorted [B] 　 Seq[A] ソートされたコレクションを返す。
（暗黙のOrdering[A]を引数としている）		 List(2,1,4,3).sorted List(1, 2, 3, 4)
Seq[A] sortWith 　 lt: (A, A) => Boolean Seq[A] 関数ltで比較・ソートしたコレクションを返す。 List("a2","b1","c4", "d3").sortWith((s1,s2) => s1(1) < s2(1))
List("a2","b1","c4", "d3").sortWith(_.charAt(1) < _.charAt(1))
List("a2","b1","c4", "d3").sortWith(_.apply(1) < _.apply(1))
List("a2","b1","c4", "d3").sortWith(_(1) < _(1))		 List(b1, a2, d3, c4)
Seq[A] sortBy [B] f: A => B Seq[A] 要素AをBに変換し、Bでソートされたコレクションを返す。
→複数フィールドをキーとするソート
→複数フィールドの一部を逆順とするソート
→キーにnullがある場合のソート		 List("a2","b1","c4", "d3").sortBy(s => s(1)) List(b1, a2, d3, c4)
Seq[A] reverse 　 　 Seq[A] 逆順に並べ替えたコレクションを返す。
（順序の反転であって、逆順ソートではない）		 List(2,1,4,3).reverse List(3, 4, 1, 2)
Seq[A]
（2.9.0〜）		 combinations 　 r: Int Iterator[Seq[A]] 指定された個数ずつの全ての組み合わせ（nCr）を返す。[2011-09-18] List("a","b","c","d").combinations(2).foreach(println) List(a, b)
List(a, c)
List(a, d)
List(b, c)
List(b, d)
List(c, d)
List("a","b","c","d").combinations(3).foreach(println) List(a, b, c)
List(a, b, d)
List(a, c, d)
List(b, c, d)
Seq[A]
（2.9.0〜）		 permutations 　 　 Iterator[Seq[A]] 全ての順列組み合わせ（nPn）を返す。[2011-09-18] List("a","b","c").permutations.foreach(println) List(a, b, c)
List(a, c, b)
List(b, a, c)
List(b, c, a)
List(c, a, b)
List(c, b, a)
Map[K, V] keys 　 　 Iterable[K] キーのIterableを返す。 Map(1->2,3->4,5->6).keys Set(1, 3, 5)
Map[K, V] keySet 　 　 Set[K] キーのSetを返す。 Map(1->2,3->4,5->6).keySet Set(1, 3, 5)
Map[K, V] values 　 　 Iterable[V] 値のIterableを返す。 Map(1->2,3->4,5->6).values MapLike(2, 4, 6)
Seq[A]
Set[A]		 intersect 　 that: Seq[A] Seq[A] 積集合（双方に存在する要素のコレクション）を返す。 List(1,2,3) intersect List(3,4,2) List(2, 3)
Seq[A]
Set[A]		 union 　 that: Seq[A] Seq[A] 和集合を返す。++と同じ。 List(1,2,3) union List(3,4) List(1, 2, 3, 3, 4)
Seq[A]
Set[A]		 diff 　 that: Seq[A] Seq[A] 差集合を返す。 List(1,2,3) diff List(3,4) List(1, 2)
Seq[A] distinct 　 　 Seq[A] 重複を排除したコレクションを返す。 List(1,2,3,2,1,4).distinct List(1, 2, 3, 4)
Set[A] & 　 that: Set[A] Set[A] 積集合。intersectと同じ。 Set(1,2,3) & Set(3,4,2) Set(2, 3)
Set[A] | 　 that: Set[A] Set[A] 和集合。unionと同じ。 Set(1,2,3) | Set(3,4) Set(1, 2, 3, 4)
Set[A] &~ 　 that: Set[A] Set[A] 差集合。diffと同じ。 Set(1,2,3) &~ Set(3,4) Set(1, 2)

存在の判定・位置の探索

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] isEmpty 　 　 Boolean 空のときtrue。 　 　
Traversable[A] nonEmpty 　 　 Boolean 要素があるときtrue。 　 　
Seq[A] isDefinedAt 　 n: Int Boolean 位置nの要素があるときtrue。 List('a,'b,'c).isDefinedAt(1) true
Map[K, V] isDefinedAt 　 key: K Boolean キーが含まれるときtrue。 Map('a->11, 'b->22, 'c->33).isDefinedAt('b) true
Seq[A] indexOf [B] elem: B
from: Int = 0		 Int 最初に見つかった要素の位置を返す。
無い場合は-1が返る。		 List('a,'b,'c,'b,'d).indexOf('b) 1
Seq[A] lastIndexOf [B] elem: B
end: Int		 Int 一番右で見つかった要素の位置を返す。
無い場合は-1が返る。		 List('a,'b,'c,'b,'d).lastIndexOf('b) 3
Seq[A] indexOfSlice [B] that: Seq[B]
from: Int = 0		 Int 最初に見つかったSeqの位置を返す。 List('a,'b,'c,'b,'d).indexOfSlice(List('b,'c)) 1
Seq[A] lastIndexOfSlice [B] that: Seq[B]
end: Int		 Int 最後に見つかったSeqの位置を返す。 List('a,'b,'c,'b,'d).lastIndexOfSlice(List('b,'c)) 1

サイズ取得

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] size 　 　 Int 要素数を返す。
デフォルトでは内部で探索（イテレート）するので
isTraversableAgainがfalseの場合は注意。		 Seq("a", "b", "c").size 3
Seq[A] length 　 　 Int sizeと同様。 　 　
Seq[A] lengthCompare 　 len: Int Int 長さ（要素数）がlenより大きいとき正、等しいとき0、小さいとき負の数を返す。[/2011-03-05] val l = List(1,2,3)
l.lengthCompare(1)
l.lengthCompare(2)
l.lengthCompare(3)
l.lengthCompare(4)
l.lengthCompare(5)		 1
1
0
-1
-2
val a = Array(1,2,3)
a.lengthCompare(1)
a.lengthCompare(2)
a.lengthCompare(3)
a.lengthCompare(4)
a.lengthCompare(5)		 2
1
0
-1
-2
Traversable[A] count 　 p: A => Boolean Int 条件pを満たす要素の数を返す。 List(1,4,9).count(n => n%2==1) 2
Traversable[A] hasDefiniteSize 　 　 Boolean 有限のときtrue。
Streamだとfalse。		 Stream(1).hasDefiniteSize false
Traversable[A] isTraversableAgain 　 　 Boolean 何度も探索できるときtrue。
1度しか探索できないときfalse。（例：Source）		 　 　

位置（添字）による要素の取得

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Seq[A] apply 　 n: Int A 位置nの要素を返す。
nが範囲外のときは例外発生。		 val s = List('a,'b,'c)
s(1)		 'b
Set[A] apply 　 e: A Boolean 要素が含まれる場合true。
Setのcontainsと同じ。		 val s = Set('a,'b,'c)
s('b)		 true
Map[K, V] apply 　 key: K V キーに該当する値を返す。
無い場合は例外発生。		 val m = Map('a->11, 'b->22, 'c->33)
m('b)		 22
Seq[A]
（2.10〜）		 applyOrElse [B:>A] n: Int
f: Int => B		 B 位置nの要素を返す。
nが範囲外のときはfにnが渡され、その戻り値を返す。[2013-06-08]		 val s = Seq("a", "b", "c")
s.applyOrElse(1, (n:Int)=> "else"+n)
s.applyOrElse(3, (n:Int)=> "else"+n)		 b
else3
Map[K, V]
（2.10〜）		 applyOrElse [B:>V] key: K
f: K => B		 B キーに該当する値を返す。
無い場合はfにkeyが渡され、その戻り値を返す。[2013-06-08]		 val m = Map('a->11, 'b->22, 'c->33)
m.applyOrElse('b, (k:Symbol)=>99)
m.applyOrElse('z, (k:Symbol)=>99)		 22
99
Map[K, V] get 　 key: K Option[V] キーに該当する値をOptionに入れて返す。
無い場合はNone。		 val m = Map('a->11, 'b->22, 'c->33)
m.get('b)		 Some(22)
Map[K, V] getOrElse 　 key: K
default: => V		 V キーに該当する値を返す。
無い場合はdefaultを返す。		 val m = Map('a->11, 'b->22, 'c->33)
m.getOrElse('b, 99)
m.getOrElse('z, 99)		 22
99
可変Map[K, V] getOrElseUpdate 　 key: K
op: => V		 V キーに該当する値がある場合、その値を返す。
無い場合はopで更新し、その値を返す。		 val m = Map('a->11, 'c->33)
m.getOrElseUpdate('b, 9)
m.getOrElseUpdate('b, 789)		 9
9
Traversable[A] head 　 　 A 先頭要素を返す。
要素が無い場合は例外発生。		 List(1,2,3).head 1
Traversable[A] headOption 　 　 Option[A] 先頭要素をOptionに入れて返す。
要素が無い場合はNoneが返る。		 List(1,2,3).headOption Some(1)
Traversable[A] last 　 　 A 末尾要素を返す。 List(1,2,3).last 3
Traversable[A] lastOption 　 　 Option[A] 末尾要素をOptionに入れて返す。 List(1,2,3).lastOption Some(3)
Seq[A]
（2.10〜）		 runWith [U] f: A => U Int => Boolean 「位置nを受け取り、範囲内ならfに要素を渡して実行し、trueを返す。範囲外ならfalseを返す」
という関数を返す。[2013-06-08]		 val s = Seq("a", "b", "c")
val r = s.runWith((s:String)=>print(s+" "))
r(1)
r(3)		 b true
false
　
Map[K, V]
（2.10〜）		 runWith [U] f: V => U K => Boolean 「キーを受け取り、存在したらfに値を渡して実行し、trueを返す。存在しない場合はfalseを返す」
という関数を返す。[2013-06-08]		 val m = Map('a->11, 'b->22, 'c->33)
val r = m.runWith((v:Int)=>print(v+" "))
r('b)
r('z)		 22 true
false

位置によるサブコレクションの取得

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] init 　 　 Traversable[A] 末尾を除いた残りのコレクションを返す。 List(1,2,3).init List(1, 2)
Traversable[A] tail 　 　 Traversable[A] 先頭を除いた残りのコレクションを返す。 List(1,2,3).tail List(2, 3)
Traversable[A]
（2.9.0〜）		 inits 　 　 Iterator[Traversable[A]] 末尾を除いたコレクションを順次返す。[2011-09-18] List(1,2,3).inits.foreach(println) List(1, 2, 3)
List(1, 2)
List(1)
List()
Traversable[A]
（2.9.0〜）		 tails 　 　 Iterator[Traversable[A]] 先頭を除いたコレクションを順次返す。[2011-09-18] List(1,2,3).tails.foreach(println) List(1, 2, 3)
List(2, 3)
List(3)
List()
Traversable[A] take 　 n: Int Traversable[A] 先頭n個のコレクションを返す。 List('a,'b,'c,'d,'e).take(2) List('a, 'b)
Traversable[A] drop 　 n: Int Traversable[A] 先頭n個を除いたコレクションを返す。
→trimStart		 List('a,'b,'c,'d,'e).drop(2) List('c, 'd, 'e)
Iterable[A] takeRight 　 n: Int Traversable[A] 末尾n個のコレクションを返す。 List('a,'b,'c,'d,'e).takeRight(2) List('d, 'e)
Iterable[A] dropRight 　 n: Int Traversable[A] 末尾n個を除いたコレクションを返す。
→trimEnd		 List('a,'b,'c,'d,'e).dropRight(2) List('a, 'b, 'c)
Traversable[A] slice 　 from: Int
until: Int		 Traversable[A] 添字がfrom以上until未満の要素のコレクションを返す。 List('a,'b,'c,'d,'e).slice(1,4) List('b, 'c, 'd)
Traversable[A] splitAt 　 n: Int (Traversable[A], Traversable[A]) 位置nで分割したコレクションのペアを返す。
take(n)とdrop(n)のペア。		 List('a,'b,'c,'d,'e).splitAt(2) (List('a, 'b),List('c, 'd, 'e))

条件判定による要素・サブコレクションの取得

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] find 　 p: A => Boolean Option[A] 条件を満たす最初の要素をOptionに入れて返す。
無い場合はNoneを返す。		 List(1,2,3).find(n => n%2==0) Some(2)
Traversable[A] filter 　 p: A => Boolean Traversable[A] 条件を満たす要素だけのコレクションを返す。
→filterとmapを同時に行いたいならcollect
→条件を満たさなかった場合も出力したい場合はpartition		 List(1,2,3,4,5).filter(n => n%2==1) List(1, 3, 5)
Map(1->2,2->3,3->4).filter(t => t._1%2==1) Map((1,2), (3,4))
Traversable[A] filterNot 　 p: A => Boolean Traversable[A] 条件を満たさない要素だけのコレクションを返す。
→条件を満たした場合も出力したい場合はpartition		 List(1,2,3,4,5).filterNot(n => n%2==1) List(2, 4)
Map[K, V] filterKeys 　 p: K => Boolean Map[K, V] 条件を満たす要素だけのMapを返す。 Map(1->2,2->3,3->4).filterKeys(k => k%2==1) Map((1,2), (3,4))
可変Map[K, V] retain 　 p: (K, V) => Boolean 自分 条件を満たす要素だけ残す。
（その他を削除する）		 　 　
可変Set[A] retain 　 p: A => Boolean Unit val s = Set(1,2,3,4,5)
s.retain(n => n%2==1)
s		 Set(1, 5, 3)
Traversable[A] withFilter 　 p: A => Boolean FilterMonadic filterと同等だが、filterより高速。[2011-02-15]
後にforeachやmapが続くときに使う。		 →withFilterの例 　
Seq[A] indexWhere 　 p: A => Boolean
from: Int = 0		 Int 最初に条件を満たした要素の位置を返す。 List(1,2,3,4,5).indexWhere(n => n%2==0) 1
Seq[A] lastIndexWhere 　 p: A => Boolean
end: Int		 Int 最後に条件を満たした要素の位置を返す。 List(1,2,3,4,5).lastIndexWhere(n => n%2==0) 3
Seq[A] findIndexOf 　 p: (A)=>Boolean Int →indexWhere[2011-03-20] List(1,2,3).findIndexOf(_%2==0)
List(1,2,3).indexWhere(_%2==0)		 1
Seq[A] findLastIndexOf 　 p: (A)=>Boolean Int →lastIndexWhere[2011-03-20] 　 　
Traversable[A] partition 　 p: A => Boolean (Traversable[A], Traversable[A]) 条件を満たすコレクションと満たさないコレクションを返す。
filter(p)とfilterNot(p)のペア。		 List(1,2,3,4,5).partition(n => n%2==1) (List(1, 3, 5),List(2, 4))
Traversable[A] takeWhile 　 p: A => Boolean Traversable[A] 条件を満たす先頭のコレクションを返す。
条件を満たさなかった時点で終了する。		 List(1,3,2,5).takeWhile(n => n%2==1) List(1, 3)
Traversable[A] dropWhile 　 p: A => Boolean Traversable[A] 条件を満たす先頭の要素を除いていったコレクション。
条件を満たさなかった時点で終了する。		 List(1,3,2,5).dropWhile(n => n%2==1) List(2, 5)
Traversable[A] span 　 p: A => Boolean (Traversable[A], Traversable[A]) 条件を満たす先頭部分と満たさない残りの部分を返す。
takeWhile(p)とdropWhile(p)のペア。		 List(1,3,2,5).span(n => n%2==1) (List(1, 3),List(2, 5))
Seq[A] segmentLength 　 p: A => Boolean
from: Int		 Int 条件を満たす先頭部分の要素数を返す。 List(1,3,2,5).segmentLength(n => n%2==1, 0) 2
Seq[A] prefixLength 　 p: A => Boolean Int segmentLength(p, 0)と同じ。 List(1,3,2,5).prefixLength(n => n%2==1) 2
Seq[A] startsWith [B] that: Seq[B]
start: Int = 0		 Boolean 先頭（start以降）がthatと一致していたらtrue。 "abcd".startsWith("abc") true
Seq[A] endsWith [B] that: Seq[B] Boolean 末尾がthatと一致していたらtrue。 "abcd".endsWith("cd") true
Seq[A]
Set[A]
Map[A]		 contains 　 elem: Any Boolean 要素（Mapの場合はキー）が存在したらtrue。 List(1,2,3).contains(2) true
Seq[A] containsSlice [B] that: Seq[B] Boolean thatと一致する部分があったらtrue。 "abcd".containsSlice("bc") true
Seq[A] corresponds [B] that: Seq[B]
p: (A, B) ⇒ Boolean		 Boolean 2つのコレクションの各要素を比較し、全ての要素が条件を満たすときtrue。 (List(1,2,3) corresponds List(2,3,4)){(n,m)=> n < m} true
Set[A] subsetOf 　 that: Set[A] Boolean 自分がthatの部分集合であればtrue。 Set(2,4) subsetOf Set(1,2,3,4,5) true
Traversable[A] groupBy [K] f: A => K Map[K, Traversable[A]] キーでグルーピングしたMapを返す。
関数fで要素毎に対応するキーを返すようにする。		 List(1,2,3,4,5).groupBy(n => n%2) Map((1,List(1, 3, 5)), (0,List(2, 4)))

要素の条件判定

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] forall 　 p: A => Boolean Boolean 全ての要素が条件pを満たすとき、true。 List(1,2,3).forall(n => n<4) true
Traversable[A] exists 　 p: A => Boolean Boolean 1つでも条件pを満たす要素があるとき、true。 List(1,2,3).exists(n => n%2==0) true
Iterable[A] sameElements [B] that: Iterable[B] Boolean 要素が（順番も含めて）等しいときtrue。 Array(1,2,3) sameElements List(1L,2L,3L) true

要素同士の演算

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] sum [B] 　 B 全ての要素を足す。
→合算方法		 List(1,2,3).sum 6
Traversable[A] product [B] 　 B 全ての要素を掛ける。 List(2,3,4).product 24
Traversable[A] min [B] 　 B 最小要素を返す。 List(2,3,1,5,4).min 1
Traversable[A] max [B] 　 B 最大要素を返す。 List(2,3,1,5,4).max 5
Traversable[A]
（2.9.0〜）		 minBy [B] f: A => B A Bに変換して比較した最小要素を返す。[2011-09-18] List("z","aaa", "cc").minBy(_.length) z
Traversable[A]
（2.9.0〜）		 maxBy [B] f: A => B A Bに変換して比較した最大要素を返す。[2011-09-18] List("z","aaa", "cc").maxBy(_.length) aaa
Traversable[A] foldLeft [B] z: B
op: (B, A) => B		 B zと要素（左（先頭）から順番）に演算opを行う。
zには「0」を渡す。[2014-08-23]
zにタプル等を渡せば、複数の出力を得ることも出来る。[2016-10-10]		 List(1,2,3).foldLeft(0)((z, n) => z - n) -6
((0-1)-2)-3
(1 to 10).foldLeft((Seq.empty[Int], Seq.empty[Int], Seq.empty[Int]))((t, n) => n % 3 match {
  case 0 => (t._1 :+ n, t._2, t._3)
  case 1 => (t._1, t._2 :+ n, t._3)
  case _ => (t._1, t._2, t._3 :+ n)
})		 (List(3, 6, 9),List(1, 4, 7, 10),List(2, 5, 8))
Traversable[A] foldRight [B] z: B
op: (A, B) => B		 B 要素（右（末尾）から順番）とzに演算opを行う。 List(1,2,3).foldRight(0)((n, z) => n - z) 2
1-(2-(3-0))
Traversable[A]
（2.9.0〜）		 fold [A1] z: A1
op: (A1, A1) => A1		 A1 直列コレクションでは（引数の型以外は）foldLeftと同じ。[2011-09-18]
並列コレクションの場合は各スレッドでopを使って畳み込む。[2014-08-23]
zはスレッド数分使われる。		 List(1,2,3).fold(0)((z, n) => z + n) 6
Traversable[A]
（2.9.0〜）		 aggregate [B] z: B
seqop: (B, A) => B
combop: (B, B) => B		 B 直列コレクションではfoldLeft(z)(seqop)と同じ。[2011-09-18]
並列コレクションの場合は各スレッドでseqopを使って集約し、それらの結果をcombopで集約する。[2014-08-23]
zはスレッド数分使われる。		 List(1,2,3).aggregate(BigDecimal(0))((d, n) => d + n, (d1, d2) => d1 + d2) BigDecimal(6)
Traversable[A] reduceLeft [B] op: (B, A) => B B 要素同士を左（先頭）から順に演算する。
要素が1個しかない場合はその値を返し、
要素が無い場合は例外が発生する。		 List(1,2,3).reduceLeft((z, n) => z - n) -4
1-2-3
Traversable[A] reduceLeftOption [B] op: (B, A) => B B 要素同士を左（先頭）から順に演算する。
要素が無い場合はNoneを返す。		 List(1,2,3).reduceLeftOption((z, n) => z - n) Some(-4)
Traversable[A] reduceRight [B] op: (A, B) => B B 要素同士を右（末尾）から順に演算する。 　 　
Traversable[A] reduceRightOption [B] op: (A, B) => B B 要素同士を右（末尾）から順に演算する。 　 　
Traversable[A]
（2.9.0〜）		 reduce [A1] op: (A1, A1) => A1 A1 並列コレクションでない場合は（引数の型以外は）reduceLeftと同じ。[2011-09-18] List(1,2,3).reduce((z, n) => z + n) 6
Traversable[A]
（2.9.0〜）		 reduceOption [A1] op: (A1, A1) => A1 A1 並列コレクションでない場合はreduceLeftOptionと同じ。[2011-09-18] List(1,2,3).reduceOption((z, n) => z + n) Some(6)
Traversable[A] scanLeft [B, T] z: B
op: (B, A) => B		 T foldLeftを行い、途中結果を格納したコレクションを返す。 List(1,2,3).scanLeft(100)((z, n) => z - n) List(100, 99, 97, 94)
Traversable[A] scanRight [B, T] z: B
op: (A, B) => B		 T foldRightを行い、途中結果を格納したコレクションを返す。
（Scala2.8の実行結果（並び順）はバグだそうです。[2016-10-10]）		 List(1,2,3).scanRight(100)((n, z) => n - z) Scala2.8
List(100, -97, 99, -98)
Scala2.9
List(-98, 99, -97, 100)
Traversable[A]
（2.9.0〜）		 scan [B, T] z: B
op: (B, B) => B		 T 並列コレクションでない場合はscanLeftと同じ。[2011-09-18] List(1,2,3).scan(100)((z, n) => z + n) List(100, 101, 103, 106)
Traversable[A] /: [B] z: B
op: (B, A) => B		 B foldLeftと同じ。
（→末尾が「:」で終わる演算子の順序）		 List(1,2,3)./:(100){(n, z) => n - z}
(100 /: List(1,2,3)){(n, z) => n - z}		 94
Traversable[A] :\ [B] z: B
op: (A, B) => B		 B foldRightと同じ。 List(1,2,3).:\(100){(n, z) => n - z}
(List(1,2,3) :\ 100){(n, z) => n - z}		 -98
Traversable[A]
（2.9.0〜）		 /:\ [A1] z: A1
op: (A1, A1) => A1		 A1 foldと同じ。[2011-09-18] List(1,2,3)./:\(100)((z, n) => z + n) 106

要素の追加・更新

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] ++ [B, T] that: TraversableOnce[B] T 他のコレクションを末尾に結合したコレクションを返す。
→++=
（Scalaでは++はインクリメントではない）		 List(1,2,3) ++ Seq(4,5,6) List(1, 2, 3, 4, 5, 6)
Traversable[A]
（2.9.0〜）		 ++: [B, T] that: TraversableOnce[B] T 他のコレクションを先頭に結合したコレクションを返す。[2011-09-18] Seq(1,2,3) ++: List(4,5,6) List(1, 2, 3, 4, 5, 6)
Seq[A] +: 　 elem: A Seq[A] 先頭に要素を追加したコレクションを返す。 9 +: List(1,2,3) List(9, 1, 2, 3)
Seq[A] :+ 　 elem: A Seq[A] 末尾に要素を追加したコレクションを返す。 List(1,2,3) :+ 9 List(1, 2, 3, 9)
Seq[A] padTo 　 len: Int
elem: A		 Seq[A] 長さがlenになるまで末尾にelemを追加したコレクションを返す。 "abc".padTo(5,'z') abczz
Seq[A] updated 　 n: Int
elem: A		 Seq[A] 位置nの要素を置き換えたコレクションを返す。 List('a,'b,'c).updated(1,'z) List('a, 'z, 'c)
Map[K, V] updated 　 key: K
value: V		 Map[K, V] +と同じ。 Map(1->2).updated(3,4) Map((1,2), (3,4))
Seq[A] patch 　 from: Int
that: Seq[A]
replaced: Int		 Seq[A] 位置fromからreplaced個の要素をthatに置き換えたコレクションを返す。 List('a,'b,'c,'d).patch(1,List('z),2) List('a, 'z, 'd)
Set[A] + 　 elem: A* Set[A] 要素を追加したコレクションを返す。
（Seqで要素を追加するのは:+）		 Set(1,2,3) + 4
Set(1,2,3) + (4,5)		 Set(1, 2, 3, 4)
Set(4, 5, 1, 2, 3)
Map[K, V] + 　 kvs: (K, V)* Map[K, V] Map(1->2) + (3->4) Map((1,2), (3,4))
Set[A] - 　 elem: A* Set[A] 要素を削除したコレクションを返す。 Set(1,2,3) - 2
Set(1,2,3,4) - (2,3)		 Set(1, 3)
Set(1, 4)
Map[K, V] - 　 key: K* Map[K, V] キーを削除したコレクションを返す。 Map(1->2,3->4,5->6) - 3 Map((1,2), (5,6))
Map[K, V] -- 　 xs: TraversableOnce[A] Map[K, V] キーを削除したコレクションを返す。
（Scalaでは--はデクリメントではない）		 Map(1->2,3->4,5->6,7->8) -- Set(3,5) Map((1,2), (7,8))
Set[A] empty 　 　 Set[A] 自分と同じ型の空のコレクションを返す。 Set(1,2,3).empty Set[Int]()

要素の追加・更新・削除（可変コレクションのみ）

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
可変Seq[A] update 　 n: Int
elem: A		 Seq[A] 位置nの要素を置き換える。 val b = ArrayBuffer('a,'b,'c)
b(1) = 'z
b		 ArrayBuffer('a, 'z, 'c)
可変Map[K, V] update 　 key: K
value: V		 Unit キーの値を置き換える。
→put		 val m = Map('a->1,'b->2,'c->3)
m('b) = 9
m		 Map(('c,3), ('b,9), ('a,1))
可変Set[A] update 　 elem: A
include: Boolean		 Unit includeがtrueの場合、要素を追加する。
→+=, add
includeがfalseの場合、要素を削除する。
→-=, remove		 val s = Set(1,2,3)
s(4) = true
s(2) = false
s		 Set(1, 4, 3)
Buffer[A]
可変Set[A]
可変Map[K, V]		 += 　 elem: A* 自分 末尾に要素を追加する。 val b = ArrayBuffer(1,2,3)
b += 4
b += (5,6)		 ArrayBuffer(1, 2, 3, 4, 5, 6)
Buffer[A] +=: 　 elem: A 自分 先頭に要素を追加する。 val b = ArrayBuffer(1,2,3)
4 +=: b		 ArrayBuffer(4, 1, 2, 3)
Buffer[A]
可変Set[A]
可変Map[K, V]		 ++= 　 xs: TraversableOnce[A] 自分 末尾にコレクションの全要素を追加する。
→++		 val b = ArrayBuffer(1,2,3)
b ++= ArrayBuffer(4,5)		  ArrayBuffer(1, 2, 3, 4, 5)
Buffer[A] ++=: 　 xs: TraversableOnce[A] 自分 先頭にコレクションの全要素を追加する。 val b = ArrayBuffer(1,2,3)
ArrayBuffer(4,5) ++=: b		 ArrayBuffer(4, 5, 1, 2, 3)
可変Map[K, V] put 　 key: K
value: V		 Option[V] キーの値を置き換える。
以前の値をOptionに入れて返す。
→update		 val m = Map('a->1,'b->2,'c->3)
m.put('b, 99)
m		 Some(2)
Map(('c,3), ('b,99), ('a,1))
可変Set[A] add 　 elem: A Boolean 要素を追加する。
初めての要素だった場合はtrue、既にあった場合はfalseを返す。
（Seqで要素を追加するのは:+）		 val s = Set(1,3)
s.add(2)
s.add(2)
s		 true
false
Set(1, 2, 3)
Buffer[A] insert 　 n: Int
elems: A*		 Unit 位置nに要素を追加する。 val b = ArrayBuffer('a,'b,'c)
b.insert(1, 'x, 'y)
b		 ArrayBuffer('a, 'x, 'y, 'b, 'c)
Buffer[A] insertAll 　 n: Int
elems: Traversable[A]		 Unit 位置nにコレクションの全要素を追加する。 val b = ArrayBuffer('a,'b,'c)
b.insertAll(1, List('x, 'y))
b		 ArrayBuffer('a, 'x, 'y, 'b, 'c)
Buffer[A]
可変Map[K, V]		 -= 　 elem: A* 自分 要素を削除する。 val b = ArrayBuffer('a,'c,'e)
b -= 'c		 ArrayBuffer('a, 'e)
Buffer[A]
可変Map[K, V]		 --= 　 xs: TraversableOnce[A] 自分 コレクションの要素を削除する。 val b = ArrayBuffer(1,2,3)
b --= List(3,4)
b		 ArrayBuffer(1, 2)
Buffer[A] remove 　 n: Int A 位置nの要素を削除する。
削除された要素が返る。		 val b = ArrayBuffer('a,'b,'c)
b.remove(1)
b		 'b
ArrayBuffer('a, 'c)
　 n: Int
count: Int		 Unit 位置nの要素をcount個削除する。 val b = ArrayBuffer('a,'b,'c,'d)
b.remove(1, 2)
b		 ArrayBuffer('a, 'd)
可変Map[K, V] remove 　 key: K Option[B] キーを削除し、元の値をOptionに入れて返す。 　 　
可変Set[A] remove 　 elem: A Boolean 要素を削除する。
要素が存在していた場合はtrue、無かった場合はfalseを返す。		 val s = Set(1,2,3)
s.remove(2)
s.remove(2)
s		 true
false
Set(1, 3)
Buffer[A] trimStart 　 n: Int Unit 先頭n個の要素を削除する。
→drop		 val b = ArrayBuffer('a,'b,'c,'d)
b.trimStart(2)
b		 ArrayBuffer('c, 'd)
Buffer[A] trimEnd 　 n: Int Unit 末尾n個の要素を削除する。
→dropRight		 val b = ArrayBuffer('a,'b,'c,'d)
b.trimEnd(2)
b		 ArrayBuffer('a, 'b)
Buffer[A]
可変Set[A]
可変Map[K, V]		 clear 　 　 Unit 要素を全て削除する。 val b = ArrayBuffer(1,2,3)
b.clear()
b		 ArrayBuffer()

別のコレクションへの変換

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Parallelizable[A]
（2.9.0〜）		 par 　 　 ParIterable[A] 並列コレクションに変換する。[2011-09-18]
→seq		 List(1,2,3).par ParVector(1, 2, 3)
Traversable[A]
（2.9.0〜）		 seq 　 　 自分[A] 並列でないコレクションに変換する。[2011-09-18]
→par		 List(1,2,3).par.seq Vector(1, 2, 3)
Traversable[A]
（2.10〜）		 to [C] 　 C[A] 型引数で指定されたコレクションに変換する。[2013-06-08] Seq(1,2,3).to[List] List(1, 2, 3)
Traversable[A] toArray [B] 　 Array[B] 配列に変換する。 List(1,2,3).toArray Array(1, 2, 3)
Traversable[A] toBuffer [B] 　 Buffer[B] Bufferに変換する。 List(1,2,3).toBuffer ArrayBuffer(1, 2, 3)
Traversable[A] toIndexedSeq [B] 　 IndexedSeq[B] IndexedSeqに変換する。 List(1,2,3).toIndexedSeq Vector(1, 2, 3)
Traversable[A] toIterable 　 　 Iterable[A] Iterableに変換する。 List(1,2,3).toIterable List(1, 2, 3)
Traversable[A] toIterator 　 　 Iterator[A] Iteratorを返す。 　 　
Traversable[A] toList 　 　 List[A] Listに変換する。 Set(1,2,3).toList List(1, 2, 3)
Traversable[A] toMap [T, U] 　 Map[T, U] Mapに変換する。
値がTuple2でないと変換できない。		 Seq(1->2,3->4).toMap Map(1 -> 2, 3 -> 4)
Traversable[A] toSeq 　 　 Seq[A] Seqに変換する。
Setでは、Scala2.8ではListを返していたが、2.9ではArrayBufferになった。[/2011-09-18]		 Set(1,2,3).toSeq List(1, 2, 3)
ArrayBuffer(1, 2, 3)
Traversable[A] toSet [B] 　 Set[B] Setに変換する。 List(1,2,3).toSet Set(1, 2, 3)
Traversable[A] toStream 　 　 Stream[A] Streamに変換する。 List(1,2,3).toStream Stream(1, ?)
Traversable[A] toString 　 　 String Stringに変換する。（文字列を返す） 　 　
Traversable[A] toTraversable 　 　 Traversable[A] Traversableに変換する。（自分自身を返す） 　 　
Traversable[A]
（2.10〜）		 toVector 　 　 Vector[A] Vectorに変換する。[2013-06-08] Seq(1,2,3).toVector Vector(1, 2, 3)
Traversable[A] companion 　 　 GenericCompanion[Traversable] コンパニオンオブジェクトを取得する。[2011-03-20] val co = List("A", "B", "C").companion
co.empty		 　
Traversable[A] view 　 from: Int
until: Int		 TraversableView ビューを返す。 val v = List(1,2,3,4,5).view(1,4)
v.head
v.last		 2
4

イテレーター取得

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Iterable[A] iterator 　 　 Iterator[A] Iteratorを返す。 val i = List(1,2,3).iterator
while(i.hasNext) println(i.next)		 1
2
3
Seq[A] reverseIterator 　 　 Iterator[A] 逆順のIteratorを返す。 　 　
Iterable[A] grouped [B] size: Int GroupedIterator[B] size個ずつのコレクションを返すイテレーター。 val i = List(1,2,3,4,5).grouped(2)
while(i.hasNext) println(i.next)		 List(1, 2)
List(3, 4)
List(5)
Iterable[A] sliding [B] size: Int
step: Int = 1		 GroupedIterator[B] size個ずつのコレクションをstepずつずらして返すイテレーター。 val i = List(1,2,3,4,5).sliding(2)
while(i.hasNext) println(i.next)		 List(1, 2)
List(2, 3)
List(3, 4)
List(4, 5)
Map[K, V] keysIterator 　 　 Iterator[K] キーのイテレーター。 　 　
Map[K, V] valuesIterator 　 　 Iterator[V] 値のイテレーター。 　 　

コピー

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] copyToArray [B] xs: Array[B]
start: Int
len: Int		 Unit 配列に要素をコピーする。 val a = Array(1,2,3)
List(4,5).copyToArray(a)		 Array(4, 5, 3)
Traversable[A] copyToBuffer [B] dest: Buffer[B] Unit Bufferに要素をコピーする。 　 　
Buffer[A]
可変Set[A]
可変Map[K, V]		 clone 　 　 Buffer[A] 自分のコピーを作成する。 val a = ArrayBuffer(1,2,3)
val b = a.clone()
a eq b		 false

文字列取得

クラス・
トレイト		 メソッド 備考 例
名称 型 引数 戻り型 演算 結果
Traversable[A] addString 　 b: StringBuilder
start: String
sep: String
end: String		 StringBuilder StringBuilderに出力する。 　 　
Traversable[A] mkString 　 start: String
sep: String
end: String		 String Stringを生成する。 List(1,2,3).mkString("[", "-", "]") [1-2-3]
Traversable[A] stringPrefix 　 　 String クラス名の文字列。
toStringで使われる。		 　 　
コレクションへ戻る / Scala目次へ戻る / 技術メモへ戻る
メールの送信先：ひしだま