Struct alloc::vec::Vec

pub struct Vec<T> { /* fields omitted */ }

連続する拡張可能な配列型。Vec<T>と書かれますが「ベクター」と発音されます。

Examples

let mut vec = Vec::new();
vec.push(1);
vec.push(2);

assert_eq!(vec.len(), 2);
assert_eq!(vec[0], 1);

assert_eq!(vec.pop(), Some(2));
assert_eq!(vec.len(), 1);

vec[0] = 7;
assert_eq!(vec[0], 7);

vec.extend([1, 2, 3].iter().cloned());

for x in &vec {
    println!("{}", x);
}
assert_eq!(vec, [7, 1, 2, 3]);

初期化を便利にするためにvec!マクロが提供されています:

let mut vec = vec![1, 2, 3];
vec.push(4);
assert_eq!(vec, [1, 2, 3, 4]);

vec!マクロによって、与えられた値からVec<T>の各要素を初期化することもできます:

let vec = vec![0; 5];
assert_eq!(vec, [0, 0, 0, 0, 0]);

Vec<T>を効率的なスタックとして使ってください:

let mut stack = Vec::new();

stack.push(1);
stack.push(2);
stack.push(3);

while let Some(top) = stack.pop() {
    // 3, 2, 1をプリントします
    println!("{}", top);
}

インデクシング

Vec型はIndexトレイトを実装しているので、インデックスを使って値にアクセスすることができます。次の例はより明白でしょう:

let v = vec![0, 2, 4, 6];
println!("{}", v[1]); // 「2」を表示します

しかし注意してください: Vecに含まれないインデックスにアクセスしようとすると、あなたのソフトウェアはパニックします！このようなことはできません:

let v = vec![0, 2, 4, 6];
println!("{}", v[6]); // パニックします！

結論: インデクシングの前にそのインデックスが本当に存在するかを常に確認してください。

スライシング

Vecはミュータブルになり得ます。一方、スライスは読み取り専用オブジェクトです。スライスを得るには、&を使ってください。例:

fn read_slice(slice: &[usize]) {
    // ...
}

let v = vec![0, 1];
read_slice(&v);

// ... そしてこれだけです！
// このようにもできます:
let x : &[usize] = &v;

Rustにおいて、単に読み取りアクセスできるようにしたいときはベクターよりもスライスを引数として渡すことが一般的です。Stringと&strについても同様です。

容量とメモリの再確保

ベクターの容量 (capacity) とは将来ベクターに追加される要素のためにアロケートされる領域の量のことです。これをベクターの長さ (length) と混同しないでください。ベクターの長さとはそのベクターに入っている実際の要素の個数のことです。ベクターの長さが容量を超えると、容量は自動的に増えますが、その要素は再確保されなければなりません。

例えば、容量10で長さ0のベクターは追加10要素分の領域をもった空のベクターです。10またはそれ以下の要素をベクターにプッシュしてもベクターの容量は変わりませんし、メモリの再確保も起きません。しかし、ベクターの長さが11まで増加すると、ベクターはメモリを再確保しなければならず、遅いです。このため、ベクターがどれだけ大きくなるかが予期できるときは常にVec::with_capacityを利用することが推奨されます。

保証

その信じられないほど基本的な性質のために、Vecはデザインについて多くのことを保証します。Vecは可能な限りロー・オーバーヘッドであり、アンセーフコードからプリミティブな方法で正しく操作することができます。これらの保証は制限のないVec<T>を指すことに注意してください。もし追加の型パラメータが追加されれば (例えばカスタムアロケータのサポートのために)、Vecのデフォルトを上書きすることで動作が変わるかもしれません。

最も基本的なこととして、Vecは (ポインタ, 容量, 長さ) の三つ組であり将来的にも常にそうです。それ以上でも以下でもありません。これらのフィールドの順序は完全に未規定であり、その値を変更するためには適切なメソッドを使うべきです。ポインタは決してヌルにはなりません。ですので、この型はヌルポインタ最適化されます。

しかし、ポインタは実際には確保されたメモリを指さないかもしれません。特に、空のベクターの作成をVec::newやvec![]やVec::with_capacity(0)により行ったり、shrink_to_fitの空のベクターでの呼び出しから行ったりするとき、メモリを確保しません。同様に、ゼロサイズ型をVecに格納するとき、それらのための領域を確保しません。この場合Vecはcapacityがゼロであると伝えないかもしれないことに注意してください。Vecはmem::size_of::<T>() * capacity() > 0のとき、またそのときに限りメモリを確保します。一般に、Vecのアロケーションの詳細はとても微妙です — もしVecを使ってメモリを確保し他の何か (アンセーフコードに渡す、またはメモリが背後にあるあなた自身のコレクションのいずれか) に使うつもりなら、必ずfrom_raw_partsを使ってVecを復元しドロップすることでそのメモリを解放してください。

Vecがメモリを確保しているとき、Vecが指すメモリはヒープにあり (Rustがデフォルトで使うよう設定されたアロケータによって定義されるように) 、ポインタはlen個の初期化された、連続する (スライスに強制したときと同じ) 順に並んだ要素を指し、capacity-len個の論理的な初期化がされていない、連続する要素が後続します。

Vecは要素を実際にはスタックに格納する"small optimization"を決して行いません。それは2つの理由のためです:

• アンセーフコードがVecを扱うことを難しくします。Vecが単にムーブされるときVecの中身は安定したアドレスを持たないでしょう。そしてVecが実際に確保されたメモリを持っているかを決定することが難しくなるでしょう。

• アクセス毎に追加の分岐を招くことで、一般的な状況で不利になるでしょう。

Vecは決して自動で縮みません。まったく空のときでさえもです。これによりメモリの不要な確保や解放が発生しないことが確実になります。Vecを空にし、それから同じlen以下まで埋め直すことがアロケータへの呼び出しを招くことは決してありません。もし使われていないメモリを解放したいなら、shrink_to_fitを使ってください。

通知された容量が十分なときpushとinsertは絶対にメモリを(再)確保しません。pushとinsertはlen==capacityのときメモリを(再)確保します。つまり、知らされる容量は完全に正確で、信頼することができます。必要に応じてVecによって確保されたメモリを手動で解放することもできます。バラバラに挿入するメソッドは必要がない場合もメモリの再確保をしてしまうかもしれません。

Vecは満杯になったときやreserveが呼び出されたときにメモリの再確保をする際の特定の拡張戦略をまったく保証しません。現在の戦略は基本的であり、定数でない増大係数が望ましいことが証明されるかもしれません。どのような戦略を使うとしても当然pushが償却O(1)であることは保証されます。

vec![x; n]とvec![a, b, c, d]とVec::with_capacity(n)は全て正確に要求した容量を持つVecを提供します。(vecマクロの場合のように) len==capacityならば、Vec<T>はメモリの再確保や要素の移動なしにBox<[T]>と相互に変換できます。

Vecは特に取り除かれたデータを上書きするとは限りませんが、特に取っておくとも限りません。未初期化メモリは必要ならばいつでもVecが使ってよい一時領域です。Vecは一般に最も効率がいいような、または実装しやすいような動作をします。セキュリティ目的で取り除かれたデータが消去されることを頼ってはいけません。Vecをドロップしたとしても、そのVecのバッファは他のVecに再利用されるかもしれません。Vecのメモリを最初にゼロにしたとしても、オプティマイザが保護すべき副作用だと考えないためにそれが実際には起こらないかもしれません。しかしながら、私達が破壊しないであろうケースが一つあります: unsafeコードを使って過剰分の容量に書き込んでから、それに合うように長さを増加させることは常に正当です.

Vecは現在、要素をドロップする順序を保証しません。過去に順序を変更したことがあり、また変更するかもしれません。

Methods

impl<T> Vec<T>

pub const fn new() -> Vec<T>

新しい空のVec<T>を作成します。

ベクターは要素をプッシュされるまでメモリを確保しません。

Examples

let mut vec: Vec<i32> = Vec::new();

pub fn with_capacity(capacity: usize) -> Vec<T>

新しい空のVec<T>を指定された容量で作成します。

返されたベクターはメモリの再確保なしにちょうどcapacity個の要素を格納することができます。capacityが0ならばメモリを確保しません。

返されたベクターは指定された容量を持ちますが、長さが0であることに注意することが大切です。長さと容量の違いの説明については*容量とメモリの再確保*を参照してください。

Examples

let mut vec = Vec::with_capacity(10);

// 0より大きい容量を持ちますが、要素は持ちません。
assert_eq!(vec.len(), 0);

これらは全てメモリの再確保なしに行われます...
for i in 0..10 {
    vec.push(i)
}

// ...しかしこれはメモリを再確保するかもしれません
vec.push(11);

pub unsafe fn from_raw_parts(     ptr: *mut T,     length: usize,     capacity: usize ) -> Vec<T>

Vec<T>を他のベクターの生の構成要素から直接作成します。

Safety

このメソッドは非常にアンセーフです。いくつものチェックされない不変量があるためです:

• ptrは以前にString/Vec<T>で確保されいる必要があります (少なくともそうでなければ非常に不適切です)。
• ptrのTはアロケートされたときと同じサイズ、同じアラインメントである必要があります。
• lengthはcapacity以下である必要があります。
• capacityはポインタがアロケートされたときの容量である必要があります。

これらに違反すると、アロケータの内部データ構造を破壊することになるかもしれません。例えばVec<u8>をCのchar配列とsize_tから作成することは安全ではありません。

ptrの所有権は有効にVec<T>に移り、そのVec<T>は思うままにメモリの破棄や再確保やポインタの指すメモリの内容の変更する権利を得ます。この関数を呼んだ後にポインタを使うことがないことを確実にしてください。

Examples

use std::ptr;
use std::mem;

fn main() {
    let mut v = vec![1, 2, 3];

    // さまざまな`v`の情報の重要な断片を抜き出します
    let p = v.as_mut_ptr();
    let len = v.len();
    let cap = v.capacity();

    unsafe {
        // `v`をvoidにキャストします: デストラクタは走りません。
        // よって`p`が指す確保されたメモリを完全に管理することになります。
        mem::forget(v);

        // メモリを4, 5, 6で上書きします
        for i in 0..len as isize {
            ptr::write(p.offset(i), 4 + i);
        }

        // 全てを合わせてVecに戻します
        let rebuilt = Vec::from_raw_parts(p, len, cap);
        assert_eq!(rebuilt, [4, 5, 6]);
    }
}

pub fn capacity(&self) -> usize

ベクターがメモリの再確保なしに保持することのできる要素の数を返します。

Examples

let vec: Vec<i32> = Vec::with_capacity(10);
assert_eq!(vec.capacity(), 10);

pub fn reserve(&mut self, additional: usize)

少なくともadditional個の要素与えられたVec<T>に挿入できるように容量を確保します。コレクションは頻繁なメモリの再確保を避けるために領域を多めに確保するかもしれません。reserveを呼び出した後、容量はself.len() + addtional以上になります。容量が既に十分なときは何もしません。

Panics

新たな容量がusizeに収まらないときパニックします。

Examples

let mut vec = vec![1];
vec.reserve(10);
assert!(vec.capacity() >= 11);

pub fn reserve_exact(&mut self, additional: usize)

ちょうどadditional個の要素を与えられたVec<T>に挿入できるように最低限の容量を確保します。reserve_exactを呼び出した後、容量はself.len() + additional以上になります。容量が既に十分なときは何もしません。

アロケータは要求したより多くの領域を確保するかもしれないことに注意してください。そのためキャパシティが正確に最低限であることに依存することはできません。将来の挿入が予期される場合reserveのほうが好ましいです。

Panics

新たな容量がusizeに収まらないときパニックします。

Examples

let mut vec = vec![1];
vec.reserve_exact(10);
assert!(vec.capacity() >= 11);

pub fn try_reserve(     &mut self,     additional: usize ) -> Result<(), CollectionAllocErr>

🔬 This is a nightly-only experimental API. (try_reserve #48043)

new API

少なくともadditional個の要素を与えられたVec<T>に挿入できるように容量を確保することを試みます。コレクションは頻繁なリメモリの再確保を避けるために領域を多めに確保するかもしれません。reserveを呼び出した後、容量はself.len() + addtional以上になります。容量が既に十分なときは何もしません。

Errors

容量がオーバーフローする、またはアロケータが失敗を通知するときエラーを返します。

Examples

#![feature(try_reserve)]
use std::collections::CollectionAllocErr;

fn process_data(data: &[u32]) -> Result<Vec<u32>, CollectionAllocErr> {
    let mut output = Vec::new();

    // 予めメモリを確保し、できなければ脱出する
    output.try_reserve(data.len())?;

    // 今、これが複雑な作業の途中でOOMし得ないことがわかっています
    // Now we know this can't OOM in the middle of our complex work
    output.extend(data.iter().map(|&val| {
        val * 2 + 5 // すごく複雑
    }));

    Ok(output)
}

pub fn try_reserve_exact(     &mut self,     additional: usize ) -> Result<(), CollectionAllocErr>

🔬 This is a nightly-only experimental API. (try_reserve #48043)

new API

ちょうどadditional個の要素与えられたVec<T>に挿入できるように最低限の容量を確保することを試みます。コレクションは頻繁なメモリの再確保を避けるために領域を多めに確保するかもしれません。reserve_exactを呼び出した後、容量はself.len() + addtional以上になります。容量が既に十分なときは何もしません。

アロケータは要求したより多くの領域を確保するかもしれないことに注意してください。そのためキャパシティが正確に最小であることに依存することはできません。将来の挿入が予期される場合reserveのほうが好ましいです。

Errors

容量がオーバーフローする、またはアロケータが失敗を通知するときエラーを返します。

Examples

#![feature(try_reserve)]
use std::collections::CollectionAllocErr;

fn process_data(data: &[u32]) -> Result<Vec<u32>, CollectionAllocErr> {
    let mut output = Vec::new();

    // 予めメモリを確保し、できなければ脱出する
    output.try_reserve(data.len())?;

    // 今、これが複雑な作業の途中でOOMし得ないことがわかっています
    // Now we know this can't OOM in the middle of our complex work
    output.extend(data.iter().map(|&val| {
        val * 2 + 5 // すごく複雑
    }));

    Ok(output)
}

pub fn shrink_to_fit(&mut self)

ベクターの容量を可能な限り縮小します。

可能な限り長さの近くまで領域を破棄しますが、アロケータはまだ少し要素を格納できる領域があるとベクターに通知するかもしれません。

Examples

let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3].iter().cloned());
assert_eq!(vec.capacity(), 10);
vec.shrink_to_fit();
assert!(vec.capacity() >= 3);

pub fn shrink_to(&mut self, min_capacity: usize)

🔬 This is a nightly-only experimental API. (shrink_to)

new API

下限付きでベクターを縮小します。

容量は最低でも長さと与えられた値以上になります。

現在の容量が与えられた値より小さい場合パニックします。

Examples

#![feature(shrink_to)]
let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3].iter().cloned());
assert_eq!(vec.capacity(), 10);
vec.shrink_to(4);
assert!(vec.capacity() >= 4);
vec.shrink_to(0);
assert!(vec.capacity() >= 3);

Important traits for Box<I>

impl<I: Iterator + ?Sized> Iterator for Box<I> type Item = I::Item;

pub fn into_boxed_slice(self) -> Box<[T]>

ベクターをBox<[T]>に変換します。

このメソッドが余剰の容量を落とすことに注意してください。

Examples

let v = vec![1, 2, 3];

let slice = v.into_boxed_slice();

余剰の容量は取り除かれます:

let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3].iter().cloned());

assert_eq!(vec.capacity(), 10);
let slice = vec.into_boxed_slice();
assert_eq!(slice.into_vec().capacity(), 3);

pub fn truncate(&mut self, len: usize)

初めのlen個の要素を残し、残りを捨てることでベクターを短くします。

lenがベクターの現在の長さより大きいときは何の効果もありません。

drainメソッドはtruncateをエミュレートできますが、余剰の要素を捨てる代わりに返すことになります。

このメソッドはベクターの確保された容量に影響しないことに注意してください。

Examples

五要素のベクターの二要素への切り詰め:

let mut vec = vec![1, 2, 3, 4, 5];
vec.truncate(2);
assert_eq!(vec, [1, 2]);

lenがベクターの現在の長さより大きいときは切り詰めが起きません:

let mut vec = vec![1, 2, 3];
vec.truncate(8);
assert_eq!(vec, [1, 2, 3]);

len == 0のときの切り詰めはclearの呼び出しと同値です。

let mut vec = vec![1, 2, 3];
vec.truncate(0);
assert_eq!(vec, []);

pub fn as_slice(&self) -> &[T]

ベクター全体を含むスライスを抜き出します。

&s[..]と同値です。

Examples

use std::io::{self, Write};
let buffer = vec![1, 2, 3, 5, 8];
io::sink().write(buffer.as_slice()).unwrap();

pub fn as_mut_slice(&mut self) -> &mut [T]

ベクター全体のミュータブルなスライスを抜き出します。

&mut s[..]と同値です。

Examples

use std::io::{self, Read};
let mut buffer = vec![0; 3];
io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();

pub unsafe fn set_len(&mut self, len: usize)

ベクターの長さを設定します。

このメソッドは明示的にベクターの大きさを設定し、実際にはバッファを変更しません。 よって呼び出し元はベクターが実際に指定された大きさを持つことを保証する義務があります。

Examples

use std::ptr;

let mut vec = vec!['r', 'u', 's', 't'];

unsafe {
    ptr::drop_in_place(&mut vec[3]);
    vec.set_len(3);
}
assert_eq!(vec, ['r', 'u', 's']);

この例ではメモリリークがあります。内部のベクターが所有するメモリ上の位置がset_lenの呼び出しの前に解放されていないからです:

let mut vec = vec![vec![1, 0, 0],
                   vec![0, 1, 0],
                   vec![0, 0, 1]];
unsafe {
    vec.set_len(0);
}

この例ではまったくメモリ確保を起こさずにゼロ個から四個にベクターを拡張することによって、確保されていないメモリがベクターの値になっています:

let mut vec: Vec<char> = Vec::new();

unsafe {
    vec.set_len(4);
}

pub fn swap_remove(&mut self, index: usize) -> T

ベクターから要素を取り除き、その要素を返します。

取り除かれた要素はベクターの最後の要素に置き換えられます。

このメソッドは順序を保ちませんが、O(1)です。

Panics

indexが境界の外にあるときパニックします。

Examples

let mut v = vec!["foo", "bar", "baz", "qux"];

assert_eq!(v.swap_remove(1), "bar");
assert_eq!(v, ["foo", "qux", "baz"]);

assert_eq!(v.swap_remove(0), "foo");
assert_eq!(v, ["baz", "qux"]);

pub fn insert(&mut self, index: usize, element: T)

後続する全ての要素を右側に移動して、要素をベクターのindexの位置に挿入します。

Panics

index > lenのときパニックします。

Examples

let mut vec = vec![1, 2, 3];
vec.insert(1, 4);
assert_eq!(vec, [1, 4, 2, 3]);
vec.insert(4, 5);
assert_eq!(vec, [1, 4, 2, 3, 5]);

pub fn remove(&mut self, index: usize) -> T

ベクターのindexの位置にある要素を取り除き、返します。後続するすべての要素は左に移動します。

Panics

indexが教会の外にあるときパニックします。

Examples

let mut v = vec![1, 2, 3];
assert_eq!(v.remove(1), 2);
assert_eq!(v, [1, 3]);

pub fn retain<F>(&mut self, f: F) where     F: FnMut(&T) -> bool,

命題で指定された要素だけを残します。

言い換えると、f(&e)がfalseを返すような全てのeを取り除きます。このメソッドはインプレースで動作し、残った要素の順序を保ちます。

Examples

let mut vec = vec![1, 2, 3, 4];
vec.retain(|&x| x%2 == 0);
assert_eq!(vec, [2, 4]);

pub fn dedup_by_key<F, K>(&mut self, key: F) where     F: FnMut(&mut T) -> K,     K: PartialEq,

ベクター内の同じキーが解決される連続した要素から先頭以外全てを取り除きます。

ベクターがソートされているとき、このメソッドは全ての重複を取り除きます。

Examples

let mut vec = vec![10, 20, 21, 30, 20];

vec.dedup_by_key(|i| *i / 10);

assert_eq!(vec, [10, 20, 30, 20]);

pub fn dedup_by<F>(&mut self, same_bucket: F) where     F: FnMut(&mut T, &mut T) -> bool,

ベクター内の与えられた等価関係を満たす連続する要素から先頭以外全てを取り除きます。

same_bucket関数はベクターから二つの要素を渡され、その要素を比較して等しいときtrueを返し、そうでないときfalseを返します。 要素はベクター内での順と逆の順で渡されるので、same_bucket(a, b)がtrueを返すとき、aが取り除かれます。

ベクターがソートされているとき、このメソッドは全ての重複を取り除きます。

Examples

let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];

vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));

assert_eq!(vec, ["foo", "bar", "baz", "bar"]);

pub fn push(&mut self, value: T)

要素をコレクションの後方に加えます。

Panics

ベクター内の要素の数がusizeに収まらない場合パニックします。

Examples

let mut vec = vec![1, 2];
vec.push(3);
assert_eq!(vec, [1, 2, 3]);

pub fn pop(&mut self) -> Option<T>

Removes the last element from a vector and returns it, or None if it is empty.

Examples

let mut vec = vec![1, 2, 3];
assert_eq!(vec.pop(), Some(3));
assert_eq!(vec, [1, 2]);

pub fn append(&mut self, other: &mut Self)

otherの要素を全てSelfに移動し、otherを空にします。

Panics

ベクターの要素の数がusizeに収まらない場合パニックします。

Examples

let mut vec = vec![1, 2, 3];
let mut vec2 = vec![4, 5, 6];
vec.append(&mut vec2);
assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
assert_eq!(vec2, []);

Important traits for Drain<'a, T>

impl<'a, T> Iterator for Drain<'a, T> type Item = T;

pub fn drain<R>(&mut self, range: R) -> Drain<T> where     R: RangeBounds<usize>,

ベクター内の指定された区間を取り除き、取り除かれた要素を与える排出イテレータを作成します。

注1: イテレータが部分的にだけ消費される、またはまったく消費されない場合も区間内の要素は取り除かれます。

注2: Drainの値がリークしたとき、ベクターから要素がいくつ取り除かれるかは未規定です。

Panics

始点が終点より大きい、または終了位置がベクターの長さより大きいときパニックします。

Examples

let mut v = vec![1, 2, 3];
let u: Vec<_> = v.drain(1..).collect();
assert_eq!(v, &[1]);
assert_eq!(u, &[2, 3]);

// 全区間でベクターをクリアします
v.drain(..);
assert_eq!(v, &[]);

pub fn clear(&mut self)

全ての値を取り除き、ベクターを空にします。

このメソッドは確保された容量に影響を持たないことに注意してください。

Examples

let mut v = vec![1, 2, 3];

v.clear();

assert!(v.is_empty());

pub fn len(&self) -> usize

ベクター内の要素の数を返します。ベクターの長さとも呼ばれるものです。

Examples

let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);

pub fn is_empty(&self) -> bool

ベクターが要素を持たないときtrueを返します。

Examples

let mut v = Vec::new();
assert!(v.is_empty());

v.push(1);
assert!(!v.is_empty());

pub fn split_off(&mut self, at: usize) -> Self

コレクションを与えられたインデックスで二つに分割します。

新たにアロケートされたSelfを返します。selfは[0, at)の要素を含み、返されたSelfは[at, len)の要素を含みます。

selfの容量は変わらないことに注意してください。

Panics

at > lenのときパニックします。

Examples

let mut vec = vec![1,2,3];
let vec2 = vec.split_off(1);
assert_eq!(vec, [1]);
assert_eq!(vec2, [2, 3]);

pub fn resize_with<F>(&mut self, new_len: usize, f: F) where     F: FnMut() -> T,

🔬 This is a nightly-only experimental API. (vec_resize_with #41758)

Vecをlenとnew_lenが等しくなるようにインプレースでリサイズします。

new_lenがlenよりも大きいときVecは差の分だけ拡張され、追加された場所はクロージャfを呼び出した結果で埋められます。fの戻り値は生成された順にVecに入ります。

new_lenがlenより小さいときVecは単に切り詰められます。

このメソッドはプッシュ毎にクロージャを使用して新しい値を作成します。与えられた値をCloneするほうが望ましい場合はresizeを使用してください。値を生成するのにDefaultを使いたい場合はDefault::default()を第二引数として渡すことができます。

Examples

#![feature(vec_resize_with)]

let mut vec = vec![1, 2, 3];
vec.resize_with(5, Default::default);
assert_eq!(vec, [1, 2, 3, 0, 0]);

let mut vec = vec![];
let mut p = 1;
vec.resize_with(4, || { p *= 2; p });
assert_eq!(vec, [2, 4, 8, 16]);

impl<T: Clone> Vec<T>

pub fn resize(&mut self, new_len: usize, value: T)

Vecをlenとnew_lenが等しくなるようにインプレースでリサイズします。

new_lenがlenよりも大きいときVecは差の分だけ拡張され、追加分の位置はvalueで埋められます。new_lenがlenより小さいときVecは単に切り詰められます。

このメソッドは与えられた値を複製するためにCloneを要求します。もっと柔軟であることを求めるなら (またはCloneの代わりにDefaultに依存したいなら)、resize_withを使用してください。

Examples

let mut vec = vec!["hello"];
vec.resize(3, "world");
assert_eq!(vec, ["hello", "world", "world"]);

let mut vec = vec![1, 2, 3, 4];
vec.resize(2, 0);
assert_eq!(vec, [1, 2]);

pub fn extend_from_slice(&mut self, other: &[T])

スライスのすべての要素を複製しVecに追加します。

スライスotherの各要素を複製し、そしてそれをVecに追加します。otherは順番に反復されます。

この関数はスライスと共に動作することに特殊化していることを除いてextendと同じであることに注意してください。 もしRustが特殊化 (訳注: specialization) を得た場合、この関数は恐らく非推奨になります (しかしそれでも利用は可能です)。

Examples

let mut vec = vec![1];
vec.extend_from_slice(&[2, 3, 4]);
assert_eq!(vec, [1, 2, 3, 4]);

impl<T: Default> Vec<T>

pub fn resize_default(&mut self, new_len: usize)

🔬 This is a nightly-only experimental API. (vec_resize_default #41758)

Vecをlenとnew_lenが等しくなるようにインプレースでリサイズします。

new_lenがlenよりも大きいときVecは差の分だけ拡張され、追加分の位置はDefault::default()で埋められます。new_lenがlenより小さいときVecは単に切り詰められます。

このメソッドはプッシュ毎にDefaultを使用して新しい値を作成します。Cloneのほうが好ましい場合はresizeを使用してください。

Examples

#![feature(vec_resize_default)]

let mut vec = vec![1, 2, 3];
vec.resize_default(5);
assert_eq!(vec, [1, 2, 3, 0, 0]);

let mut vec = vec![1, 2, 3, 4];
vec.resize_default(2);
assert_eq!(vec, [1, 2]);

impl<T: PartialEq> Vec<T>

pub fn dedup(&mut self)

連続して繰り返される要素を取り除きます。

ベクターがソートされているときこのメソッドは全ての重複を取り除きます。

Examples

let mut vec = vec![1, 2, 2, 3, 2];

vec.dedup();

assert_eq!(vec, [1, 2, 3, 2]);

pub fn remove_item(&mut self, item: &T) -> Option<T>

🔬 This is a nightly-only experimental API. (vec_remove_item #40062)

recently added

ベクターから最初のitemのインスタンスをもし存在するなら取り除きます。

Examples

let mut vec = vec![1, 2, 3, 1];

vec.remove_item(&1);

assert_eq!(vec, vec![2, 3, 1]);

impl<T> Vec<T>

Important traits for Splice<'a, I>

impl<'a, I: Iterator> Iterator for Splice<'a, I> type Item = I::Item;

pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<I::IntoIter> where     R: RangeBounds<usize>,     I: IntoIterator<Item = T>,

ベクター内の指定された区間を与えられたreplace_withイテレータで置き換え、取り除かれた要素を与える置換イテレータを作成します。replace_withはrangeと同じ長さでなくてもかまいません。

注1: イテレータが最後まで消費されないとしても区間内の要素は取り除かれます。

Spliceの値がリークした場合、いくつの要素がベクターから取り除かれるかは未規定です。

注3: Spliceがドロップされたとき、入力イテレータreplace_withは消費だけされます。

注4: このメソッドは次の場合最適です:

• 後部 (ベクター内のrangeの後の要素) が空のとき
• またはreplace_withがrangeの長さ以下の個数の要素を与えるとき
• またはsize_hint()の下限が正確であるとき。

Panics

始点が終点より大きい場合、または終点がベクターの長さより大きい場合パニックします。

Examples

let mut v = vec![1, 2, 3];
let new = [7, 8];
let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect();
assert_eq!(v, &[7, 8, 3]);
assert_eq!(u, &[1, 2]);

Important traits for DrainFilter<'a, T, F>

impl<'a, T, F> Iterator for DrainFilter<'a, T, F> where
    F: FnMut(&mut T) -> bool,  type Item = T;

pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F> where     F: FnMut(&mut T) -> bool,

🔬 This is a nightly-only experimental API. (drain_filter #43244)

recently added

要素を取り除くべきかの判定にクロージャを利用するイテレータを作成します。

クロージャがtrueを返すとき、要素は取り除かれ、イテレータによって与えられます。 クロージャがfalseを返すとき、要素はベクターに残り、イテレータによって与えられません。

このメソッドを使うことは次のコードと同値です:

let mut i = 0;
while i != vec.len() {
    if some_predicate(&mut vec[i]) {
        let val = vec.remove(i);
        // ここにあなたのコード
    } else {
        i += 1;
    }
}

しかしdrain_filterはより簡単に使えます。drain_filterは配列の要素をまとめて移動できるので、効率的でもあります。

drain_filterでは保持か除外かの選択に関わらず、filterクロージャの中で各要素を変化させることもできるので注意してください。

Examples

配列を偶数と奇数に分割し、元の確保されたメモリを再利用します:

#![feature(drain_filter)]
let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];

let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
let odds = numbers;

assert_eq!(evens, vec![2, 4, 6, 8, 14]);
assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);

Trait Implementations

impl<T> From<Vec<T>> for Arc<[T]>

fn from(v: Vec<T>) -> Arc<[T]>

Performs the conversion.

impl<T> From<Vec<T>> for Rc<[T]>

fn from(v: Vec<T>) -> Rc<[T]>

Performs the conversion.

impl<T: Ord> From<Vec<T>> for BinaryHeap<T>

fn from(vec: Vec<T>) -> BinaryHeap<T>

Performs the conversion.

impl<T> From<BinaryHeap<T>> for Vec<T>

fn from(heap: BinaryHeap<T>) -> Vec<T>

Performs the conversion.

impl<T> Borrow<[T]> for Vec<T>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T> BorrowMut<[T]> for Vec<T>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl From<String> for Vec<u8>

fn from(string: String) -> Vec<u8>

Performs the conversion.

impl<T: Clone> Clone for Vec<T>

fn clone(&self) -> Vec<T>

Returns a copy of the value.

fn clone_from(&mut self, other: &Vec<T>)

Performs copy-assignment from source.

impl<T: Hash> Hash for Vec<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<T, I> Index<I> for Vec<T> where     I: SliceIndex<[T]>,

type Output = I::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, I> IndexMut<I> for Vec<T> where     I: SliceIndex<[T]>,

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> Deref for Vec<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<T> DerefMut for Vec<T>

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<T> FromIterator<T> for Vec<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T>

Creates a value from an iterator.

impl<T> IntoIterator for Vec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

Important traits for IntoIter<T>

impl<T> Iterator for IntoIter<T> type Item = T;

fn into_iter(self) -> IntoIter<T>

Vec<T>を消費するイテレータを作成します。すなわちベクターの各値を (最初から最後まで) ムーブします。このメソッドを呼び出した後、ベクターは使用できません。

Examples

let v = vec!["a".to_string(), "b".to_string()];
for s in v.into_iter() {
    // sはString型であって、&Stringではない
    println!("{}", s);
}

impl<'a, T> IntoIterator for &'a Vec<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

Important traits for Iter<'a, T>

impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Vec<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

Important traits for IterMut<'a, T>

impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<T> Extend<T> for Vec<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<'a, T: 'a + Copy> Extend<&'a T> for Vec<T>

Vecに要素をプッシュする前に参照からコピーするExtendの実装です。

この実装はスライスイテレータに特化していて、一度に要素全体を追加するためにcopy_from_sliceを使います。

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<'a, 'b, A: Sized, B> PartialEq<Vec<B>> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &Vec<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vec<B>) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b mut [B]) -> bool

This method tests for !=.

impl<'a, 'b, A: Clone, B> PartialEq<Vec<B>> for Cow<'a, [A]> where     A: PartialEq<B>,

fn eq(&self, other: &Vec<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vec<B>) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 0]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 0]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 0]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 0]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 0]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 0]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 1]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 1]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 1]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 1]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 2]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 2]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 2]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 2]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 2]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 2]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 3]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 3]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 3]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 3]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 3]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 3]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 4]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 4]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 4]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 4]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 4]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 4]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 5]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 5]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 5]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 5]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 5]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 5]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 6]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 6]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 6]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 6]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 6]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 6]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 7]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 7]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 7]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 7]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 7]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 7]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 8]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 8]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 8]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 8]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 9]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 9]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 9]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 9]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 9]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 9]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 10]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 10]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 10]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 10]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 10]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 10]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 11]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 11]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 11]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 11]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 11]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 11]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 12]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 12]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 12]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 12]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 12]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 12]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 13]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 13]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 13]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 13]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 13]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 13]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 14]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 14]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 14]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 14]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 14]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 14]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 15]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 15]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 15]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 15]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 15]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 15]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 16]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 16]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 16]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 16]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 16]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 16]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 17]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 17]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 17]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 17]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 17]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 17]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 18]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 18]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 18]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 18]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 18]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 18]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 19]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 19]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 19]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 19]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 19]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 19]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 20]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 20]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 20]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 20]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 20]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 20]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 21]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 21]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 21]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 21]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 21]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 21]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 22]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 22]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 22]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 22]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 22]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 22]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 23]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 23]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 23]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 23]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 23]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 23]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 24]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 24]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 24]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 24]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 24]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 24]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 25]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 25]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 25]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 25]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 25]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 25]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 26]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 26]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 26]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 26]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 26]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 26]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 27]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 27]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 27]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 27]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 27]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 27]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 28]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 28]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 28]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 28]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 28]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 28]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 29]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 29]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 29]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 29]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 29]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 29]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 30]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 30]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 30]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 30]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 30]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 30]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 31]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 31]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 31]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 31]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 31]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 31]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 32]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &[B; 32]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 32]) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 32]> for Vec<A> where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 32]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'b [B; 32]) -> bool

This method tests for !=.

impl<T: PartialOrd> PartialOrd for Vec<T>

辞書式にベクターの比較を実装します。

fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq> Eq for Vec<T>

impl<T: Ord> Ord for Vec<T>

辞書式順序でベクターの順序を実装します。

fn cmp(&self, other: &Vec<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<T> Drop for Vec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Default for Vec<T>

fn default() -> Vec<T>

空のVec<T>を作成します。

impl<T: Debug> Debug for Vec<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T> AsRef<Vec<T>> for Vec<T>

fn as_ref(&self) -> &Vec<T>

Performs the conversion.

impl<T> AsMut<Vec<T>> for Vec<T>

fn as_mut(&mut self) -> &mut Vec<T>

Performs the conversion.

impl<T> AsRef<[T]> for Vec<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> AsMut<[T]> for Vec<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<'a, T: Clone> From<&'a [T]> for Vec<T>

fn from(s: &'a [T]) -> Vec<T>

Performs the conversion.

impl<'a, T: Clone> From<&'a mut [T]> for Vec<T>

fn from(s: &'a mut [T]) -> Vec<T>

Performs the conversion.

impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where     [T]: ToOwned<Owned = Vec<T>>,

fn from(s: Cow<'a, [T]>) -> Vec<T>

Performs the conversion.

impl<T> From<Box<[T]>> for Vec<T>

fn from(s: Box<[T]>) -> Vec<T>

Performs the conversion.

impl<T> From<Vec<T>> for Box<[T]>

Important traits for Box<I>

impl<I: Iterator + ?Sized> Iterator for Box<I> type Item = I::Item;

fn from(v: Vec<T>) -> Box<[T]>

Performs the conversion.

impl<'a> From<&'a str> for Vec<u8>

fn from(s: &'a str) -> Vec<u8>

Performs the conversion.

impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]>

fn from(v: Vec<T>) -> Cow<'a, [T]>

Performs the conversion.

impl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]>

fn from(v: &'a Vec<T>) -> Cow<'a, [T]>

Performs the conversion.

impl<'a, 'b, A: Sized, B> PartialEq<Vec<B>> for VecDeque<A> where     A: PartialEq<B>,

fn eq(&self, other: &Vec<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> From<Vec<T>> for VecDeque<T>

fn from(other: Vec<T>) -> Self

Performs the conversion.

impl<T> From<VecDeque<T>> for Vec<T>

fn from(other: VecDeque<T>) -> Self

Performs the conversion.