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 filtermapを合わせたようなもの。[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] ソートされたコレクションを返す。 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でソートされたコレクションを返す。 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]
後にforeachmapが続くときに使う。
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目次へ戻る / 技術メモへ戻る
メールの送信先:ひしだま