Movatterモバイル変換

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

Scalaコレクションメソッド

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

全要素の順次処理（foreach・map等）[/2011-09-18]
存在の判定・位置の探索（isEmpty・indexOf等）
サイズ取得（size・count等）[/2011-03-05]
位置（添字）による要素の取得（apply・get・head・last等）[/2013-06-08]
位置によるサブコレクションの取得（init・tail・take・drop等）[/2011-09-18]
条件判定による要素やサブコレクションの取得（find・filter等）[/2016-10-10]
要素の条件判定（exists等）
要素同士の演算（fold・reduce・sum・max等）[/2016-10-10]
要素の追加・更新（++・:+等）[/2011-09-18]
- 追加・更新・削除（可変コレクション）（update等）
別のコレクションへの変換（par・to等）[/2013-06-08]
イテレーター取得（iterator等）
コピー（copyToArray・copyToBuffer等）
文字列取得（addString・mkString等）

全要素の順次処理

クラス・トレイト	メソッド				備考	例
クラス・トレイト	名称	型	引数	戻り型	備考	演算	結果
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)`
Traversable[A]	`collect`	`[B, T]`	`pf:PartialFunction[A, B]`	`T`		`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)`
Seq[A] （2.9.0〜）	`combinations`		`r: Int`	`Iterator[Seq[A]]`	指定された個数ずつの全ての組み合わせ（nCr）を返す。[2011-09-18]	`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: Bend: 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`
Seq[A]	`lengthCompare`		`len: Int`	`Int`	長さ（要素数）がlenより大きいとき正、等しいとき0、小さいとき負の数を返す。[/2011-03-05]	`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)`
Traversable[A]	`filter`		`p: A => Boolean`	`Traversable[A]`		`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 => Booleanend: 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`
Traversable[A]	`foldLeft`	`[B]`	`z: B op: (B, A) => B`	`B`		`(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)`	`21-(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)`	`-41-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)`
Traversable[A]	`scanRight`	`[B, T]`	`z: B op: (A, B) => B`	`T`		`List(1,2,3).scanRight(100)((n, z) => n - z)`	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]`	要素を追加したコレクションを返す。（Seqで要素を追加するのは`:+`）	`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)`
Buffer[A]	`remove`		`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目次へ戻る /技術メモへ戻る

メールの送信先：ひしだま

[8]ページ先頭