Rustのcollectメソッドの使い方を整理：Iteratorからコレクションへの変換手法まとめ

Rustプログラミングにおいて、イテレータの操作は避けては通れない非常に重要な要素です。

特に、加工したデータを最終的なデータ構造へと変換するcollectメソッドは、Rustの表現力を支える中核的な機能を備えています。

この記事では、初心者から中級者までを対象に、collectメソッドの基本的な仕組みから実践的な活用パターンまでを詳しく解説します。

2026年現在のRust開発においても、このメソッドの仕様を正しく理解しておくことは、効率的なコーディングを行うための必須スキルといえるでしょう。

collectメソッドの役割と基本的な仕組み

Rustのcollectメソッドは、イテレータを具体的なコレクション（VecやHashMapなど）へと変換するためのメソッドです。

イテレータそのものは「遅延評価」される性質を持っており、そのままではデータとして保持したりランダムアクセスしたりすることができません。

そこで、collectを呼び出すことでイテレータの要素をすべて消費し、目的のデータ構造に格納し直す必要があるのです。

このメソッドの最大の特徴は、「戻り値の型に基づいて、自動的に変換先のデータ構造を決定する」という非常に柔軟な汎用性にあります。

内部的には、標準ライブラリのstd::iter::FromIteratorトレイトを実装している型であれば、どのような型へも変換が可能となっています。

型推論とターボフィッシュ演算子

collectは極めて強力ですが、その汎用性の高さゆえに、コンパイラがどの型に変換すべきか判断できない場合があります。

例えば、数値をフィルタリングした後にcollectを呼ぶ際、それがVec<i32>なのかHashSet<i32>なのかを指定しなければなりません。

型を明示する方法には、主に「変数に型注釈を付ける方法」と「ターボフィッシュ（::<>）を使う方法」の2種類が存在します。

// 変数の型注釈で指定する方法
let numbers = vec![1, 2, 3, 4, 5];
let doubled: Vec<i32> = numbers.into_iter().map(|x| x * 2).collect();

// ターボフィッシュ演算子を使用して指定する方法
let doubled_alt = numbers.into_iter().map(|x| x * 2).collect::<Vec<i32>>();

どちらの方法を使用しても動作に違いはありませんが、メソッドチェーンの途中で型を確定させたい場合にはターボフィッシュが便利です。

主要なコレクションへの変換パターン

ここでは、実務で頻繁に利用される具体的なコレクションへの変換手法を紹介します。

collectが対応しているのはVecだけではないという点に注目してください。

Vec（ベクタ）への変換

もっとも一般的なパターンは、動的配列であるVecへの変換です。

データの順序を維持したまま、効率的に値を格納したい場合に最適です。

fn main() {
    let source = vec!["Rust", "Python", "Go"];
    
    // 文字列の長さを取得して新しいVecを作成
    let lengths: Vec<usize> = source.iter().map(|s| s.len()).collect();
    
    println!("{:?}", lengths);
}

[4, 6, 2]

HashMap（ハッシュマップ）への変換

キーと値のペア（タプル）を持つイテレータからは、HashMapを生成することができます。

これは、設定ファイルやデータのマッピングを行う際に非常に強力な手法です。

use std::collections::HashMap;

fn main() {
    let keys = vec!["id", "name", "role"];
    let values = vec!["1", "Alice", "Admin"];
    
    // zipを使用してペアのイテレータを作成し、HashMapへ変換
    let user_map: HashMap<&str, &str> = keys.into_iter().zip(values).collect();
    
    println!("{:?}", user_map);
}

{"id": "1", "name": "Alice", "role": "Admin"}

HashSet（ハッシュセット）への変換

重複を除去したい場合は、HashSetへの変換が有効です。

Vecから直接変換するのではなく、一度イテレータを経由することで、宣言的にユニークな集合を作成できます。

use std::collections::HashSet;

fn main() {
    let raw_data = vec![1, 2, 2, 3, 4, 4, 5];
    
    // 重複を排除した集合を作成
    let unique_data: HashSet<i32> = raw_data.into_iter().collect();
    
    println!("{:?}", unique_data);
}

{1, 2, 3, 4, 5}

String（文字列）への変換

意外と知られていないのが、文字（char型）のイテレータをStringにまとめられるという点です。

これにより、文字列のフィルタリングや置換を非常にスムーズに行うことができます。

fn main() {
    let sentence = "Hello, Rust 2026!";
    
    // 数字以外の文字だけを抽出して新しい文字列を作成
    let filtered: String = sentence.chars().filter(|c| !c.is_numeric()).collect();
    
    println!("{}", filtered);
}

Hello, Rust !

ResultやOptionを含む高度な変換手法

Rustにおけるcollectの真骨頂は、エラーハンドリングを伴う変換にあります。

通常、エラーが発生する可能性のある操作（Resultを返す操作）をマップすると、Iterator<Item = Result<T, E>>という型になります。

これをそのまま扱うのは面倒ですが、collectを使うと一気に変換が可能です。

Resultのリストを単一のResultに変換する

もしイテレータの中に一つでもErrが含まれていれば全体をErrとし、すべて成功していればVec<T>を返すという処理が一行で記述できます。

これは「ショートサーキット」と呼ばれ、失敗した時点で処理を中断する効率的な仕組みです。

fn main() {
    let strings = vec!["10", "20", "invalid", "40"];
    
    // 数値変換を試みる（一つ失敗が含まれる）
    let results: Result<Vec<i32>, _> = strings
        .into_iter()
        .map(|s| s.parse::<i32>())
        .collect();
    
    match results {
        Ok(vec) => println!("Success: {:?}", vec),
        Err(e) => println!("Error occurred: {}", e),
    }
}

Error occurred: invalid digit found in string

このパターンは、バッチ処理やファイル読み込みなどで、一つでもエラーがあれば全体を失敗させたい場合に非常に重宝します。

Optionのリストを単一のOptionに変換する

Resultと同様に、Option<T>のイテレータもOption<Vec<T>>に変換できます。

一つでもNoneがあれば結果はNoneとなり、すべて値が存在すればその中身を抽出したVecが手に入ります。

fn main() {
    let values = vec![Some(10), Some(20), None, Some(40)];
    
    // Noneが含まれているため、全体がNoneになる
    let combined: Option<Vec<i32>> = values.into_iter().collect();
    
    println!("{:?}", combined);
}

None

パフォーマンスと最適化に関する考慮事項

collectは便利ですが、内部的な動作を理解しておくことで、より効率的なコードを書くことができます。

特に大量のデータを扱う場合、メモリ割り当てのコストを最小限に抑える工夫が求められます。

サイズ予知（Size Hint）の活用

collectはイテレータのsize_hintメソッドを利用して、あらかじめ必要なメモリ領域を確保しようと試みます。

変換元のイテレータが正確な要素数（ExactSizeIteratorなど）を持っている場合、Vecへの変換は非常に高速です。

一方で、filterなどを使って要素数が不確定になると、メモリの再割り当てが発生し、若干のオーバーヘッドが生じる可能性があります。

collectを避けるべきケース

単に要素をループで回したいだけであれば、collectを呼ぶ必要はありません。

collectは新しいコレクションをメモリ上に生成するため、メモリ消費量が増加します。

結果を再利用せず、その場で処理を完結させる場合は、for_eachメソッドや通常のforループを使用する方が効率的です。

// 非効率：一度新しいVecを作ってしまう
let list = vec![1, 2, 3];
let _ : Vec<()> = list.iter().map(|x| println!("{}", x)).collect();

// 効率的：コレクションを作らずに処理する
list.iter().for_each(|x| println!("{}", x));

よく使われる変換の早見表

collectでどのような型が生成できるかを把握しておくために、代表的な変換先をまとめました。

この表を参考に、自身の用途に最適なデータ構造を選択してください。

まとめ

Rustのcollectメソッドは、単なる変換機能を超えた、関数型プログラミング的な美しさと実用性を兼ね備えたツールです。

イテレータによって柔軟にデータを加工し、最後にcollectで整えるという流れは、Rustらしい安全で効率的なコードの定石といえます。

特にResultやOptionを扱う際の挙動をマスターすることで、エラーハンドリングの記述を大幅に簡略化できるでしょう。

ただし、利便性の裏にあるメモリ確保のコストを意識し、不必要な変換は避けるといったバランス感覚も重要です。

今回紹介した手法を活用して、より洗練されたRustコードの記述に役立ててください。