2016-01-30T00:58:43の更新内容

programming/netfx/collections/2_generic_1_list/index.wiki.txt

current previous
13,8 13,6
 
-[[programming/netfx/arrays]]
-[[programming/netfx/arrays]]
 
--[[programming/netfx/arrays/0_abstract]]
--[[programming/netfx/arrays/0_abstract]]
 
--[[programming/netfx/arrays/2_operations]]
--[[programming/netfx/arrays/2_operations]]
+
-[[programming/netfx/enumerator]]
+
--[[programming/netfx/enumerator/1_modify_collection]]
 

        

        
 
#relevantdocs-end
#relevantdocs-end
 

        

        
25,12 23,22
 

        

        
 
Listクラスは[[System.Collections.ArrayList>programming/netfx/collections/1_nongeneric_1_arraylist#ArrayList]]に相当するジェネリックコレクションですが、ただ単にジェネリックなArrayListというわけではなく、ArrayListと比べるとより高度な操作が可能になっています。
Listクラスは[[System.Collections.ArrayList>programming/netfx/collections/1_nongeneric_1_arraylist#ArrayList]]に相当するジェネリックコレクションですが、ただ単にジェネリックなArrayListというわけではなく、ArrayListと比べるとより高度な操作が可能になっています。
 

        

        
+
以下、まずはListクラスを使った基本的な操作について見ていきます。
 

        

        
~
**Listの作成、要素の取得・設定・追加
*基本操作
~
List内の要素を参照するには、配列の場合と同様にインデックスを指定します。 これにより、List内に格納されている値を取得したり、値の設定(上書き)をすることができます。 Listを作成する場合、初期状態で要素が格納された状態で作成することも、また空のListを作成しておいて後から要素を追加することもできます。
早速、Listクラスを使った基本的な操作について見ていきます。
 

        

        
~
#tabpage(codelang=cs,container-title=Listを作成する・List内の要素を取得・設定する)
**Listの作成、要素の取得・設定・列挙
-
Listを使う場合には、最初に格納する要素を指定する([[#collection_initializer]])ことも、空のListを作成しておいて後から要素を追加することも出来ます。 追加する方法については後述するとして、以下の例ではあらかじめ要素が格納されているListを使うことにします。
-

          
-
List内の要素を取得(参照)するには、配列と同様にインデックスを指定します。 取得だけでなく、インデックスを指定することで特定の要素を設定(値の上書き)をすることも出来ます。
-

          
-
#remarks
-
C#では''インデクサ''によって、VB.NETでは既定のプロパティItemによって、配列と同様にインデックスによる取得・設定ができるようになっています。 インデクサについては[[programming/netfx/property#indexer]]を参照してください。
-
#remarks-end
-

          
-
List内の全ての要素を列挙するには、配列同様にfor/foreach文を使うことが出来ます。 配列の場合とは異なり、現在List内に含まれている要素の数を取得するにはLengthプロパティではなく&msdn(netfx,member,System.Collections.Generic.List`1.Count){Countプロパティ};を参照します。
-

          
-
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
42,14 50,25
 
    // 初期状態で5つの要素があるstring型のListを作成
    // 初期状態で5つの要素があるstring型のListを作成
 
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // インデックス0と3の要素を参照して表示
    // 要素の数を取得
-
    Console.WriteLine("Count = {0}", list.Count);
-

          
-
    // 要素を参照して表示
 
    Console.WriteLine("list[0] -> {0}", list[0]);
    Console.WriteLine("list[0] -> {0}", list[0]);
 
    Console.WriteLine("list[3] -> {0}", list[3]);
    Console.WriteLine("list[3] -> {0}", list[3]);
-
    Console.WriteLine();
 

        

        
~
    // インデックス1の要素に値を設定
    // for文でList内の要素を列挙して表示
~
    list[1] = "Frank";
    for (int i = 0; i < list.Count; i++)
-
    {
-
      Console.WriteLine("list[{0}] = {1}", i, list[i]);
-
    }
 

        

        
~
    Console.WriteLine("list[1] -> {0}", list[1]);
    // foreach文でList内の要素を列挙して表示
-
    foreach (string e in list)
-
    {
-
      Console.WriteLine(e);
-
    }
 
  }
  }
 
}
}
 
}}
}}
63,32 82,48
 
    ' 初期状態で5つの要素があるstring型のListを作成
    ' 初期状態で5つの要素があるstring型のListを作成
 
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' インデックス0と3の要素を参照して表示
    ' 要素の数を取得
-
    Console.WriteLine("Count = {0}", list.Count)
-

          
-
    ' 要素を参照して表示
 
    Console.WriteLine("list(0) -> {0}", list(0))
    Console.WriteLine("list(0) -> {0}", list(0))
 
    Console.WriteLine("list(3) -> {0}", list(3))
    Console.WriteLine("list(3) -> {0}", list(3))
-
    Console.WriteLine()
 

        

        
~
    ' インデックス1の要素に値を設定
    ' ForステートメントでList内の要素を列挙して表示
~
    list(1) = "Frank"
    For i As Integer = 0 To list.Count - 1
-
      Console.WriteLine("list({0}) = {1}", i, list(i))
-
    Next
 

        

        
~
    Console.WriteLine("list(1) -> {0}", list(1))
    ' For EachステートメントでList内の要素を列挙して表示
-
    For Each e As String In list
-
      Console.WriteLine(e)
-
    Next
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
-
Count = 5
 
list[0] -> Alice
list[0] -> Alice
 
list[3] -> Dave
list[3] -> Dave
~
list[1] -> Frank

          
-
list[0] = Alice
-
list[1] = Bob
-
list[2] = Charlie
-
list[3] = Dave
-
list[4] = Eve
-
Alice
-
Bob
-
Charlie
-
Dave
-
Eve
 
}}
}}
 

        

        
~
#remarks
Listは要素の数は可変ですが、現在の要素数を超えるインデックスを指定した場合は例外ArgumentOutOfRangeExceptionがスローされます。 現在の要素数よりも大きなインデックスを指定してもその分の領域が''自動的に確保されるわけではない''点に注意してください。
+
C#では''インデクサ''によって、VB.NETでは既定のプロパティItemによって、配列と同様にインデックスによる取得・設定ができるようになっています。 インデクサについては[[programming/netfx/property#indexer]]を参照してください。
+
#remarks-end
+

          
+
Listに要素を追加するには、[[Addメソッド>#List_Insertion]]などを使用します。 インスタンスを作成した後でも任意に要素を追加できる点がListと配列の大きく異なる点です。
 

        

        
~
#tabpage(codelang=cs,container-title=空のListを作成する・Listに要素を追加する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
97,17 132,16
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // int型を格納する空のListを作成
    // 要素数が3(=インデックスの上限が2)のList
~
    List<int> list = new List<int>();
    List<int> list = new List<int>() {0, 1, 2};
 

        

        
~
    // Listに要素を3つ追加する
    // インデックス0の要素に値を設定する
~
    list.Add(1);
    // (インデックスは全要素数の範囲内なので例外はスローされない)
~
    list.Add(3);
    list[0] = 3;
+
    list.Add(5);
 

        

        
~
    Console.WriteLine("list[0] -> {0}", list[0]);
    // インデックス99の要素に値を設定する
~
    Console.WriteLine("list[1] -> {0}", list[1]);
    // (インデックスは全要素数の範囲を超えるため例外がスローされる)
~
    Console.WriteLine("list[2] -> {0}", list[2]);
    list[99] = 1000000;
 
  }
  }
 
}
}
 
}}
}}
118,37 152,31
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' Integer型を格納する空のListを作成
    ' 要素数が3(=インデックスの上限が2)のList
~
    Dim list As New List(Of Integer)()
    Dim list As New List(Of Integer)(New Integer() {0, 1, 2})
 

        

        
~
    ' Listに要素を3つ追加する
    ' インデックス0の要素に値を設定する
~
    list.Add(1)
    ' (インデックスは全要素数の範囲内なので例外はスローされない)
~
    list.Add(3)
    list(0) = 3
+
    list.Add(5)
 

        

        
~
    Console.WriteLine("list(0) -> {0}", list(0))
    ' インデックス99の要素に値を設定する
~
    Console.WriteLine("list(1) -> {0}", list(1))
    ' (インデックスは全要素数の範囲を超えるため例外がスローされる)
~
    Console.WriteLine("list(2) -> {0}", list(2))
    list(99) = 1000000
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
list[0] -> 1
ハンドルされていない例外: System.ArgumentOutOfRangeException: インデックスが範囲を超えています。負でない値で、コレクションのサイズよりも小さくなければなりません。
~
list[1] -> 3
パラメーター名: index
~
list[2] -> 5
   場所 System.Collections.Generic.List`1.set_Item(Int32 index, T value)
-
   場所 Sample.Main()
 
}}
}}
 

        

        
~
#remarks
なお、このような操作を行いたい場合は、Addメソッドで必要な要素数になるまで追加を繰り返すか、あらかじめ必要な要素数を確保した配列を用意してからListを作成する、といった方法を取ることができます。 次の例では、全要素数が100の配列を用意してからListを作成しています。
+
Listの作成方法のバリエーションについては後述の[[#List..ctor]]で解説しています。
+
#remarks-end
+

          
+

          
+
**List内の要素の列挙
+
List内の全ての要素を列挙するには、配列同様に``for``/``foreach``文を使うことが出来ます。 配列の場合とは異なり、現在List内に含まれている要素の数を取得するにはLengthプロパティではなく&msdn(netfx,member,System.Collections.Generic.List`1.Count){Countプロパティ};を参照します。
 

        

        
~
#tabpage(codelang=cs,container-title=for文/foreach文でList内の全要素を列挙する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
157,26 185,15
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 初期状態で5つの要素があるstring型のListを作成
    // 全要素数が100の配列を作成する
~
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    int[] arr = new int[100];
 

        

        
~
    // for文でList内の要素を列挙して表示
    // 配列からListを作成する
~
    Console.WriteLine("[for]");
    List<int> list = new List<int>(arr);
 

        

        
~
    for (int i = 0; i < list.Count; i++)
    // インデックス99の要素に値を設定する
~
    {
    // (インデックスはListの元になった配列の全要素数の範囲内なので例外はスローされない)
~
      Console.WriteLine("list[{0}] = {1}", i, list[i]);
    list[99] = 1000000;
+
    }
+

          
+
    Console.WriteLine();
+

          
+
    // foreach文でList内の要素を列挙して表示
+
    Console.WriteLine("[foreach]");
+

          
+
    foreach (string e in list)
+
    {
+
      Console.WriteLine(e);
+
    }
 
  }
  }
 
}
}
 
}}
}}
187,50 204,29
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 初期状態で5つの要素があるstring型のListを作成
    ' 全要素数が100の配列を作成する
~
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim arr(99) As Integer
 

        

        
~
    ' ForステートメントでList内の要素を列挙して表示
    ' 配列からListを作成する
~
    Console.WriteLine("[For]")
    Dim list As New List(Of Integer)(arr)
 

        

        
~
    For i As Integer = 0 To list.Count - 1
    ' インデックス99の要素に値を設定する
~
      Console.WriteLine("list({0}) = {1}", i, list(i))
    ' (インデックスはListの元になった配列の全要素数の範囲内なので例外はスローされない)
~
    Next
    list(99) = 1000000
+

          
+
    Console.WriteLine()
+

          
+
    ' For EachステートメントでList内の要素を列挙して表示
+
    Console.WriteLine("[For Each]")
+

          
+
    For Each e As String In list
+
      Console.WriteLine(e)
+
    Next
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
~
#prompt(実行結果){{
上記の例では、元になる配列arrと、それをもとに作成するlistの二つで個別に領域が確保されることになる点に注意してください。 (関連:[[#List_Capacity]])
+
[for]
+
list[0] = Alice
+
list[1] = Bob
+
list[2] = Charlie
+
list[3] = Dave
+
list[4] = Eve
 

        

        
+
[foreach]
+
Alice
+
Bob
+
Charlie
+
Dave
+
Eve
+
}}
 

        

        
-
**要素の追加・挿入
-
Listは格納できる要素の数は可変であるため、任意の時点で要素を追加することが出来ます。 要素を追加するには、&msdn(netfx,member,System.Collections.Generic.List`1.Add){Addメソッド};を使います。 このメソッドを使うと、Listの一番最後に値が追加されます。 位置を指定して要素を挿入したい場合は&msdn(netfx,member,System.Collections.Generic.List`1.Insert){Insertメソッド};を使います。
 

        

        
~
**配列への変換
複数の要素を一度にまとめて追加したい場合は、&msdn(netfx,member,System.Collections.Generic.List`1.AddRange){AddRangeメソッド};を使います。 他の配列やListの内容をコピーするにはfor/foreach文を使って要素を一つずつコピーすることもできますが、このメソッドを使うとfor/foreach文を使わなくても1度の呼び出しで追加したい内容をまとめて追加することが出来ます。 なお、AddRangeメソッドではAddメソッド同様Listの末尾に要素が追加されていきます。 挿入する位置を指定したい場合には&msdn(netfx,member,System.Collections.Generic.List`1.InsertRange){InsertRangeメソッド};を使うことが出来ます。
+
Listを配列に変換する必要性が生じた場合は、[[ToArrayメソッド>#List.ToArray]]を使うことができます。 ToArrayメソッドを呼び出すと、Listの内容と同じ内容をもつ配列を取得することができます。
 

        

        
~
#tabpage(codelang=cs,container-title=Listを配列に変換する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
239,18 235,37
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 空のListを作成
    // 要素が格納されていない空のListを作成
 
    List<string> list = new List<string>();
    List<string> list = new List<string>();
 

        

        
~
    // Listに要素を追加
    // 要素を追加する
 
    list.Add("Alice");
    list.Add("Alice");
+
    list.Add("Bob");
 
    list.Add("Charlie");
    list.Add("Charlie");
 

        

        
~
    // Listの内容を配列に変換
    Print(list);
~
    string[] arr = list.ToArray();

          
-
    // インデックス1の位置に要素を挿入する
-
    list.Insert(1, "Bob");
-

          
-
    Print(list);
-

          
-
    // 追加したい要素を含む配列
-
    string[] arr = new string[] {"Dave", "Eve", "Frank"};
-

          
-
    // 複数の要素を追加する (配列に含まれている内容をすべて追加する)
-
    list.AddRange(arr);
-

          
-
    Print(list);
-
  }
-

          
-
  static void Print(List<string> list)
-
  {
-
    foreach (string e in list)
-
    {
-
      Console.Write("{0}, ", e);
-
    }
 

        

        
~
    Console.WriteLine(string.Join(", ", arr));
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
261,49 276,54
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 空のListを作成
    ' 要素が格納されていない空のListを作成
 
    Dim list As New List(Of String)()
    Dim list As New List(Of String)()
 

        

        
~
    ' Listに要素を追加
    ' 要素を追加する
 
    list.Add("Alice")
    list.Add("Alice")
+
    list.Add("Bob")
 
    list.Add("Charlie")
    list.Add("Charlie")
 

        

        
~
    ' Listの内容を配列に変換
    Print(list)
~
    Dim arr() As String = list.ToArray()

          
-
    ' インデックス1の位置に要素を挿入する
-
    list.Insert(1, "Bob")
-

          
-
    Print(list)
-

          
-
    ' 追加したい要素を含む配列
-
    Dim arr As String() = {"Dave", "Eve", "Frank"}
-

          
-
    ' 複数の要素を追加する (配列に含まれている内容をすべて追加する)
-
    list.AddRange(arr)
-

          
-
    Print(list)
-
  End Sub
-

          
-
  Shared Sub Print(ByVal list As List(Of String))
-
    For Each e As String In list
-
      Console.Write("{0}, ", e)
-
    Next
 

        

        
~
    Console.WriteLine(String.Join(", ", arr))
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Alice, Bob, Charlie
Alice, Charlie, 
-
Alice, Bob, Charlie, 
-
Alice, Bob, Charlie, Dave, Eve, Frank, 
 
}}
}}
 

        

        
~
引数の型が配列となっているメソッドにListの内容を渡したい場合などにはToArrayメソッドを使う必要があります。 一方、引数の型が&msdn(netfx,type,System.Collections.Generic.IEnumerable`1){IEnumerable<T>};となっている場合は配列と同様にListをそのまま渡すことができるため、この場合はToArrayメソッドによって配列に変換する必要はありません。
***列挙操作中の要素の追加
-
Listをforeach文で列挙している最中に要素の追加や削除などの変更を行おうとすると、例外InvalidOperationExceptionがスローされます。 これを回避するにはforeachの代わりにfor文を使うなどします。 詳しくは[[programming/netfx/enumerator/1_modify_collection]]でも解説していますので適宜参照してください。
 

        

        
+
例えば上記の例で使用している&msdn(netfx,member,System.String.Join){String.Join};メソッドも、.NET Framework 4以降では``IEnumerable<T>``を引数にとることができるようになっているので、わざわざ配列に変換することなく直接Listを渡すことができます。
 

        

        
~
#remarks
**コレクション初期化子 [#collection_initializer]
~
String.Joinメソッドについては[[programming/netfx/string/1_operations#String.Join]]を参照してください。
Listを使用する場合、あらかじめ決められた内容を含むリストを用意したい場合が多々あります。 こういった場合、まず空のリストを作成してから要素を追加していくこともできますが、''コレクション初期化子''を使うとインスタンスの作成と要素の追加を同時に行うことができ、あらかじめ決められた内容を含むリストを作成できます。 コレクション初期化子はC# 3.0(Visual C# 2008)以降、VB 10(Visual Basic 2010)以降でサポートされます。
+
#remarks-end
+

          
+

          
+
**Listの要素数の拡張
+
Listは要素の数は可変ですが、現在の要素数(Count)を超えるインデックスを指定した場合は例外&msdn(netfx,type,System.ArgumentOutOfRangeException){ArgumentOutOfRangeException};がスローされます。 例えば、次のコードのように現在の要素数よりも大きなインデックスを指定しても、その分の容量が''自動的に確保されるわけではない''点に注意してください。
+

          
+
#code(js,JavaScript等では認められているこのような操作は、Listクラスでは行うことはできない){{
+
var arr = new Array();
+

          
+
arr[0] = 0;
+
arr[1] = 1;
+
arr[2] = 2;
+
arr[99] = 99; // arr.length = 100
+
}}
 

        

        
~
#tabpage(codelang=cs,container-title=Listではインデックスで指定した分の要素数が自動的に確保されるわけではない)
#tabpage(codelang=cs,container-title=コレクション初期化子を使ったインスタンスの初期化)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
312,17 332,13
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 要素数が3(=インデックスの上限が2)のList
    // コレクション初期化子を使ってインスタンスの作成と要素の追加を行う
~
    List<int> list = new List<int>() {0, 1, 2};
    List<string> list = new List<string>() {
-
      "Alice", "Bob", "Charlie", "Dave", "Eve"
-
    };
 

        

        
~
    // インデックス0の要素に値を設定する
    Console.WriteLine("list[2] = {0}", list[2]);
~
    list[0] = 0;
    Console.WriteLine("Count = {0}", list.Count);
+
    // (インデックス0は全要素数3の範囲内なので例外はスローされない)
+

          
+
    // インデックス99の要素に値を設定する
+
    list[99] = 99;
+
    // (インデックスは全要素数の範囲を超えるため例外がスローされる)
+
    // (→インデックス99に値を格納するために容量が拡張されるわけではない)
 
  }
  }
 
}
}
 
}}
}}
333,32 349,26
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 要素数が3(=インデックスの上限が2)のList
    ' コレクション初期化子を使ってインスタンスの作成と要素の追加を行う
~
    Dim list As New List(Of Integer)(New Integer() {0, 1, 2})
    Dim list As New List(Of String)() From {
-
      "Alice", "Bob", "Charlie", "Dave", "Eve"
-
    }
 

        

        
~
    ' インデックス0の要素に値を設定する
    Console.WriteLine("list(2) = {0}", list(2))
~
    list(0) = 0
    Console.WriteLine("Count = {0}", list.Count)
+
    ' (インデックス0は全要素数3の範囲内なので例外はスローされない)
+

          
+
    ' インデックス99の要素に値を設定する
+
    list(99) = 99
+
    ' (インデックスは全要素数の範囲を超えるため例外がスローされる)
+
    ' (→インデックス99に値を格納するために容量が拡張されるわけではない)
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
ハンドルされていない例外: System.ArgumentOutOfRangeException: インデックスが範囲を超えています。負でない値で、コレクションのサイズよりも小さくなければなりません。
list(2) = Charlie
~
パラメーター名: index
Count = 5
+
   場所 System.Collections.Generic.List`1.set_Item(Int32 index, T value)
+
   場所 Sample.Main()
 
}}
}}
 

        

        
~
Listにおける容量の自動的な拡張は、[[Addメソッド>#List_Insertion]]などによって''要素が追加・挿入される場合にのみ''行われます。 従って、上記のように現在の要素数よりも大きいインデックスに要素を格納したい場合は、[[Addメソッド>#List.Add]]を使って必要な要素数になるまで適当な値の追加を繰り返す必要があります。
コレクション初期化子を使用できない場合は、コンストラクタに配列を渡すことで同様の初期化を行うことができます。
 

        

        
~
#tabpage(codelang=cs,container-title=Addメソッドを使ってListの容量を拡張する)
#tabpage(codelang=cs,container-title=配列を使ったインスタンスの初期化)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
367,18 377,13
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 要素数が3(=インデックスの上限が2)のList
    // コレクション初期化子を使ってインスタンスの作成と要素の追加を行う
~
    List<int> list = new List<int>() {0, 1, 2};
    List<string> list = new List<string>(new string[] {
-
      "Alice", "Bob", "Charlie", "Dave", "Eve"
-
    });
 

        

        
~
    // インデックス99に値を設定するために、
    Console.WriteLine("list[2] = {0}", list[2]);
~
    // 要素数が100になるまでListに適当な値を追加する
    Console.WriteLine("Count = {0}", list.Count);
+
    while (list.Count < 100)
+
    {
+
      list.Add(-1);
+
    }
+

          
+
    // インデックス99に値を設定する
+
    list[99] = 99;
 
  }
  }
 
}
}
 
}}
}}
389,25 394,26
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 要素数が3(=インデックスの上限が2)のList
    ' コレクション初期化子を使ってインスタンスの作成と要素の追加を行う
~
    Dim list As New List(Of Integer)(New Integer() {0, 1, 2})
    Dim list As New List(Of String)(New String() { _
-
      "Alice", "Bob", "Charlie", "Dave", "Eve" _
-
    })
 

        

        
~
    ' インデックス99に値を設定するために、
    Console.WriteLine("list(2) = {0}", list(2))
~
    ' 要素数が100になるまでListに適当な値を追加する
    Console.WriteLine("Count = {0}", list.Count)
+
    While list.Count < 100
+
      list.Add(-1)
+
    End While
+

          
+
    ' インデックス99に値を設定する
+
    list(99) = 99
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
~
あるいは、あらかじめ必要な要素数を確保した配列を用意してからそれをもとにListを作成する、といった方法を取ることもできます。 次の例では、全要素数が100の配列を用意してからListを作成しています。
#remarks
-
関連: [[programming/netfx/arrays/0_abstract#declaration_and_initialization]]
-
#remarks-end
-

          
-
**要素の変更
-
要素を入れ替えて値を変更するには、変更したい要素のインデックスを指定して値を代入します。
 

        

        
~
#tabpage(codelang=cs,container-title=配列を使ってListに指定した要素数を確保する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
416,15 422,30
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 全要素数が100の配列を作成する
    // 要素が格納されていない空のListを作成
~
    int[] arr = new int[100];
    List<string> list = new List<string>();
-

          
-
    // 要素を追加する
-
    list.Add("Alice");
-
    list.Add("Bob");
-
    list.Add("Charlie");
-

          
-
    Print(list);
 

        

        
~
    // 配列からListを作成する
    // インデックス1の要素に格納されている値を変更する
~
    List<int> list = new List<int>(arr);
    list[1] = "Dave";
 

        

        
~
    // インデックス99の要素に値を設定する
    Print(list);
~
    // (インデックスはListの元になった配列の全要素数の範囲内なので例外はスローされない)
  }
~
    list[99] = 99;

          
-
  static void Print(List<string> list)
-
  {
-
    foreach (string e in list)
-
    {
-
      Console.Write("{0}, ", e);
-
    }
-

          
-
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
435,90 456,70
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 全要素数が100の配列を作成する
    ' 要素が格納されていない空のListを作成
~
    Dim arr(99) As Integer
    Dim list As New List(Of String)()
-

          
-
    ' 要素を追加する
-
    list.Add("Alice")
-
    list.Add("Bob")
-
    list.Add("Charlie")
-

          
-
    Print(list)
-

          
-
    ' インデックス1の要素に格納されている値を変更する
-
    list(1) = "Dave"
-

          
-
    Print(list)
-
  End Sub
 

        

        
~
    ' 配列からListを作成する
  Shared Sub Print(ByVal list As List(Of String))
~
    Dim list As New List(Of Integer)(arr)
    For Each e As String In list
-
      Console.Write("{0}, ", e)
-
    Next
 

        

        
~
    ' インデックス99の要素に値を設定する
    Console.WriteLine()
+
    ' (インデックスはListの元になった配列の全要素数の範囲内なので例外はスローされない)
+
    list(99) = 99
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
~
#remarks
#prompt(実行結果){{
~
上記の例では、元になる配列arrと、それをもとに作成するlistの二つで''個別にインスタンスが確保されている''点に注意してください。
Alice, Bob, Charlie, 
~
#remarks-end
Alice, Dave, Charlie, 
-
}}
 

        

        
~
#remarks
***構造体要素の変更 [#modify_valuetype_element]
~
Listの要素数・容量に関して、後述の[[#List_Capacity]]も合わせて参照してください。
要素に構造体を格納するようにしたListで構造体のプロパティやフィールドだけを変更しようとする場合は注意が必要です。 例えば、次のようなコードはコンパイルエラーとなります。
+
#remarks-end
 

        

        
~
**Listクラスのメソッド
#tabpage(codelang=cs,container-title=Listに格納されている構造体のフィールドを直接変更しようとした場合)
+
ここまでで解説した基本的な操作以外にも、Listクラスでは次のようなメソッドを使った操作を行うことができます。
+

          
+
|*Listクラスのメソッド
+
|>|~操作|~対応するListクラスのメソッド|h
+
|>|~操作|~対応するListクラスのメソッド|f
+
|~要素の追加・挿入|要素を追加する|[[Add>#List.Add]]|
+
|~|~|[[AddRange>#List.AddRange]]|
+
|~|要素を指定した位置に挿入する|[[Insert>#List.Insert]]|
+
|~|~|[[InsertRange>#List.InsertRange]]|
+
|~要素の削除|値を指定して削除する|[[Remove>#List.Remove]]|
+
|~|インデックスを指定して削除する|[[RemoveAt>#List.RemoveAt]]|
+
|~|~|[[RemoveRange>#List.RemoveRange]]|
+
|~|条件に合致するものを削除する|[[RemoveAll>#List.RemoveAll]]|
+
|~|すべての要素を削除する|[[Clear>#List.Clear]]
+
|~要素の位置(インデックス)の検索|値を指定して検索する|[[IndexOf>#List.IndexOf]]|
+
|~|~|[[LastIndexOf>#List.IndexOf]]|
+
|~|条件に合致するものの位置を検索する|[[FindIndex>#List.FindIndex]]|
+
|~|~|[[FindLastIndex>#List.FindIndex]]|
+
|~|二分探索によって検索する|[[BinarySearch>#List.BinarySearch]]|
+
|~要素の有無のテスト|値を指定して有無を調べる|[[Contains>#List.Contains]]
+
|~|条件に合致する要素がひとつでもあるか調べる|[[Exists>#List.Exists]]
+
|~|すべての要素が条件に合致するか調べる|[[TrueForAll>#List.Exists]]
+
|~要素の抽出|条件に合致する要素を取得する|[[Find>#List.Find]]
+
|~|~|[[FindLast>#List.Find]]
+
|~|条件に合致するすべての要素を取得する|[[FindAll>#List.Find]]
+
|~|指定した範囲にある要素を抽出する&br;(Listのサブセットを取得する)|[[GetRange>#List.GetRange]]
+
|~変換|全要素を別の型・値に変換する|[[ConvertAll>#List.ConvertAll]]|
+
|~|配列に変換する|[[ToArray>#List.ToArray]]|
+
|~|配列からListを作成する|[[Listコンストラクタ>#List..ctor]]|
+
|~|配列にコピーする|[[CopyTo>#List.CopyTo]]|
+
|~並べ替え|ソートする|[[Sort>#List.Sort]]|
+
|~|リバースする|[[Reverse>#List.Reverse]]|
+
|~ユーティリティ|容量を縮小する|[[TrimExcess>#List_TrimExcess]]|
+
|~|読み取り専用のビューを作成する|[[AsReadOnly>#List.AsReadOnly]]|
+

          
+
以降でListクラスの使い方に関してより詳しく解説します。
+

          
+

          
+
*インスタンスの作成 [#List..ctor]
+
コンストラクタに特に何も指定しないでListを作成した場合は、空のListが作成されます。 配列やコレクションを指定して作成した場合は、それと同じ内容のListを持つListが作成されます。 どちらの場合でも、インスタンス作成後に要素を追加したり削除したりすることができます。
+

          
+
#tabpage(codelang=cs,container-title=空のListを作成して後から要素を追加する)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
 

        

        
-
// Listに格納する構造体
-
struct S
-
{
-
  public int F;
-

          
-
  public S(int f)
-
  {
-
    F = f;
-
  }
-
}
-

          
 
class Sample
class Sample
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 空のListを作成する
    List<S> list = new List<S>();
+
    List<string> list = new List<string>();
 

        

        
~
    // 作成したListに要素を追加する
    // フィールドFに値3を設定した構造体を格納
~
    list.Add("Alice");
    list.Add(new S(3));
 

        

        
~
    list.Add("Charlie");
    // インデックス0の構造体フィールドの値を変更したいが、コンパイルエラーとなる
~

          
    list[0].F = 16;
~
    list.Insert(1, "Bob");
    // error CS1612: 変数ではないため、'System.Collections.Generic.List<S>.this[int]'の戻り値を変更できません。
 

        

        
+
    // listの内容は{"Alice", "Bob", "Charlie"}となる
 
  }
  }
 
}
}
 
}}
}}
527,43 528,71
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
 

        

        
-
' Listに格納する構造体
-
Structure S
-
  Public F As Integer
-

          
-
  Public Sub New(ByVal val As Integer)
-
    F = val
-
  End Sub
-
End Structure
-

          
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 空のListを作成する
    Dim list As New List(Of S)()
+
    Dim list As New List(Of String)()
 

        

        
~
    ' 作成したListに要素を追加する
    ' フィールドFに値3を設定した構造体を格納
~
    list.Add("Alice")
    list.Add(new S(3))
 

        

        
~
    list.Add("Charlie")
    ' インデックス0の構造体フィールドの値を変更したいが、コンパイルエラーとなる
~

          
    list(0).F = 16
~
    list.Insert(1, "Bob")
    ' error BC30068: Expression は値であるため、代入式のターゲットにすることはできません。
+

          
+
    ' listの内容は{"Alice", "Bob", "Charlie"}となる
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
~
#tabpage(codelang=cs,container-title=初期状態で配列と同じ内容をもったListを作成する)
このような操作を行いたい場合は、いったんListから一時変数に構造体をコピーし、値を変更してから再度Listに格納するようにします。
-

          
-
#tabpage(codelang=cs,container-title=Listに格納されている構造体のフィールドを変更する方法)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
 

        

        
-
// Listに格納する構造体
-
struct S
-
{
-
  public int F;
-

          
-
  public S(int f)
-
  {
-
    F = f;
-
  }
-
}
-

          
 
class Sample
class Sample
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 初期状態でListに格納しておきたい要素を含む配列
    List<S> list = new List<S>();
~
    string[] arr = new string[] {"Alice", "Bob"};

          
-
    // フィールドFに値3を設定した構造体を格納
-
    list.Add(new S(3));
-

          
-
    // Listに格納した構造体フィールドの値を参照
-
    Console.WriteLine("list[0].F = {0}", list[0].F);
-

          
-
    // フィールドの値を変更したい構造体を一時変数にコピーする
-
    S tmp = list[0];
 

        

        
~
    // 初期状態で上記の配列と同じ内容をもつListを作成する
    // 一時変数に代入した構造体のフィールドの値を変更する
~
    List<string> list = new List<string>(arr);
    tmp.F = 16;
 

        

        
~
    // 作成したListに要素を追加する
    // 変更した構造体を再度Listに格納する
~
    list.Add("Charlie");
    list[0] = tmp;
 

        

        
~
    // listの内容は{"Alice", "Bob", "Charlie"}となる
    // Listに格納した構造体フィールドの値を参照
-
    Console.WriteLine("list[0].F = {0}", list[0].F);
 
  }
  }
 
}
}
 
}}
}}
572,32 601,56
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
 

        

        
-
' Listに格納する構造体
-
Structure S
-
  Public F As Integer
-

          
-
  Public Sub New(ByVal val As Integer)
-
    F = val
-
  End Sub
-
End Structure
-

          
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 初期状態でListに格納しておきたい要素を含む配列
    Dim list As New List(Of S)()
~
    Dim arr() As String = New String() {"Alice", "Bob"}

          
-
    ' フィールドFに値3を設定した構造体を格納
-
    list.Add(new S(3))
 

        

        
~
    ' 初期状態で上記の配列と同じ内容をもつListを作成する
    ' Listに格納した構造体フィールドの値を参照
~
    Dim list As New List(Of String)(arr)
    Console.WriteLine("list(0).F = {0}", list(0).F)
-

          
-
    ' フィールドの値を変更したい構造体を一時変数にコピーする
-
    Dim tmp As S = list(0)
-

          
-
    ' 一時変数に代入した構造体のフィールドの値を変更する
-
    tmp.F = 16
 

        

        
~
    ' 作成したListに要素を追加する
    ' 変更した構造体を再度Listに格納する
~
    list.Add("Dave")
    list(0) = tmp
 

        

        
~
    ' listの内容は{"Alice", "Bob", "Charlie"}となる
    ' Listに格納した構造体フィールドの値を参照
-
    Console.WriteLine("list(0).F = {0}", list(0).F)
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
~
初期値をもったList(あらかじめ要素が格納された状態のList)を作成したい場合は、上記のように配列やコレクションをコンストラクタに指定してインスタンスを作成するか、後述の[[コレクション初期化子>#collection_initializer]]を使用してインスタンスを作成します。
#prompt(実行結果){{
-
list[0].F = 3
-
list[0].F = 16
-
}}
 

        

        
~
また、コンストラクタに他のListを指定すれば、そのListの複製を作ることができます。(詳細:[[#List_Cloning]]) このほか、初期容量を指定してListインスタンスを作成することもできます。(詳細:[[#List_InitialCapacity]])
#remarks
-
構造体ではなくクラスのインスタンスを格納する場合はこのような操作を行う必要はありません。 この違いは型が値型か参照型かによって決まります。 詳しくは[[programming/netfx/valuetype_referencetype#value_type_property]]を参照してください。
-
#remarks-end
 

        

        
-
**要素の削除
-
要素を削除するには&msdn(netfx,member,System.Collections.Generic.List`1.Remove){Removeメソッド};や&msdn(netfx,member,System.Collections.Generic.List`1.RemoveAt){RemoveAtメソッド};を使います。 Removeメソッドでは''削除したい値''を指定し、RemoveAtメソッドでは''削除したい要素のインデックス''を指定します。 Removeメソッドでは、同じ値を持つ要素が複数ある場合、最初に見つかったものが削除されます。
 

        

        
~
**コレクション初期化子 [#collection_initializer]
''削除する範囲をインデックスで指定''して要素を削除するには&msdn(netfx,member,System.Collections.Generic.List`1.RemoveRange){RemoveRangeメソッド};を使うことが出来ます。 また、&msdn(netfx,member,System.Collections.Generic.List`1.Clear){Clearメソッド};を使うことでList内の全ての要素を削除することも出来ます。
+
Listを使用する場合、あらかじめ決められた内容を含むリストを用意したい場合が多々あります。 こういった場合、まず空のリストを作成してから要素を追加していくこともできますが、''コレクション初期化子''を使うとインスタンスの作成と要素の追加を同時に行うことができ、あらかじめ決められた内容を含むリストを作成できます。 コレクション初期化子はC# 3.0(Visual C# 2008)以降、VB 10(Visual Basic 2010)以降でサポートされます。
 

        

        
~
#tabpage(codelang=cs,container-title=コレクション初期化子を使ってあらかじめ要素を格納した状態のListを作成する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
606,58 659,38
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // コレクション初期化子を使ってインスタンスの作成と要素の追加を行う
    List<int> list = new List<int>() {0, 1, 1, 1, 2, 2, 2, 3, 3};
~
    List<string> list = new List<string>() {

          
~
      "Alice", "Bob", "Charlie", "Dave", "Eve"
    // 値1を持つ要素を削除する
~
    };
    list.Remove(1);
-

          
-
    Print(list);
 

        

        
~
    Console.WriteLine("list[2] = {0}", list[2]);
    // インデックス2から要素3個を削除する
~
    Console.WriteLine("Count = {0}", list.Count);
    list.RemoveRange(2, 3);
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
 

        

        
~
Class Sample
    Print(list);
+
  Shared Sub Main()
+
    ' コレクション初期化子を使ってインスタンスの作成と要素の追加を行う
+
    Dim list As New List(Of String)() From {
+
      "Alice", "Bob", "Charlie", "Dave", "Eve"
+
    }
 

        

        
~
    Console.WriteLine("list(2) = {0}", list(2))
    // インデックス4の要素を削除する
~
    Console.WriteLine("Count = {0}", list.Count)
    list.RemoveAt(4);
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
 

        

        
~
#prompt(実行結果){{
    Print(list);
+
list[2] = Charlie
+
Count = 5
+
}}
 

        

        
~
コレクション初期化子を使用できない場合は、コンストラクタに配列を渡すことで同様の初期化を行うことができます。
    // すべての要素をクリアして、要素を追加し直す
-
    list.Clear();
-
    list.AddRange(new int[] {4, 5, 6, 7});
 

        

        
~
#tabpage(codelang=cs,container-title=コンストラクタに配列を指定してあらかじめ要素を格納した状態のListを作成する)
    Print(list);
~
#code{{
  }
+
using System;
+
using System.Collections.Generic;
 

        

        
~
class Sample
  static void Print(List<int> list)
+
{
+
  static void Main()
 
  {
  {
~
    // 配列を使ってインスタンスの作成と要素の追加を行う
    foreach (int e in list)
~
    List<string> list = new List<string>(new string[] {
    {
~
      "Alice", "Bob", "Charlie", "Dave", "Eve"
      Console.Write("{0}, ", e);
~
    });
    }
 

        

        
~
    Console.WriteLine("list[2] = {0}", list[2]);
    Console.WriteLine();
+
    Console.WriteLine("Count = {0}", list.Count);
 
  }
  }
 
}
}
 
}}
}}
668,39 701,61
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 配列を使ってインスタンスの作成と要素の追加を行う
    Dim list As New List(Of Integer)(New Integer() {0, 1, 1, 1, 2, 2, 2, 3, 3})
~
    Dim list As New List(Of String)(New String() { _

          
~
      "Alice", "Bob", "Charlie", "Dave", "Eve" _
    ' 値1を持つ最初の要素を削除する
~
    })
    list.Remove(1)
-

          
-
    Print(list)
-

          
-
    ' インデックス2から要素3個を削除する
-
    list.RemoveRange(2, 3)
-

          
-
    Print(list)
-

          
-
    ' インデックス4の要素を削除する
-
    list.RemoveAt(4)
-

          
-
    Print(list)
-

          
-
    ' すべての要素をクリアして、要素を追加し直す
-
    list.Clear()
-
    list.AddRange(New Integer() {4, 5, 6, 7})
-

          
-
    Print(list)
-
  End Sub
-

          
-
  Shared Sub Print(ByVal list As List(Of Integer))
-
    For Each e As Integer In list
-
      Console.Write("{0}, ", e)
-
    Next
 

        

        
~
    Console.WriteLine("list(2) = {0}", list(2))
    Console.WriteLine()
+
    Console.WriteLine("Count = {0}", list.Count)
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
list[2] = Charlie
0, 1, 1, 2, 2, 2, 3, 3, 
~
Count = 5
0, 1, 2, 3, 3, 
-
0, 1, 2, 3, 
-
4, 5, 6, 7,
 
}}
}}
 

        

        
 
#remarks
#remarks
~
関連: [[programming/netfx/arrays/0_abstract#declaration_and_initialization]]
[[RemoveAllメソッド>#List_Predicate]]を使うと条件を指定して要素を削除することが出来ます。
 
#remarks-end
#remarks-end
 

        

        
-
#remarks
-
削除を行ったのちに[[TrimExcessメソッド>#List_TrimExcess]]を使うことにより、不要になった容量を削減することもできます。
-
#remarks-end
 

        

        
 

        

        
-
**要素の検索 [#List_Contains]
-
List内に特定の要素が含まれているかどうかを調べるには&msdn(netfx,member,System.Collections.Generic.List`1.Contains){Containsメソッド};を使うことが出来ます。 また、List内のどこに含まれているかどうかを調べるには&msdn(netfx,member,System.Collections.Generic.List`1.IndexOf){IndexOfメソッド};を使うことが出来ます。 IndexOfメソッドでは、要素が見つかった場合はその要素のインデックスを返します。 もし見つからなければ-1が返されます。 IndexOfメソッドはListの先頭から調べて最初に見つかった要素のインデックスを返しますが、&msdn(netfx,member,System.Collections.Generic.List`1.LastIndexOf){LastIndexOfメソッド};を使うとListの末尾から調べて最初に見つかったインデックス(List内の一番最後にあるインデックス)を取得することが出来ます。
 

        

        
~

          
#tabpage(codelang=cs)
+

          
+
*要素の追加・挿入 [#List_Insertion]
+
Listは格納できる要素の数は可変であるため、任意の時点で任意の数の要素を追加することができます。
+

          
+
**要素の追加 (Add) [#List.Add]
+
Listに要素を追加するには、&msdn(netfx,member,System.Collections.Generic.List`1.Add){Addメソッド};を使います。 このメソッドを使うと、Listの末尾(一番最後)に要素が追加されます。
+

          
+
#tabpage(codelang=cs,container-title=Addメソッドを使ってListの末尾に要素を追加する)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
709,30 764,22
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 要素が格納されていない空のListを作成
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Bob", "Alice"};
+
    List<string> list = new List<string>();
 

        

        
~
    // 要素を追加する
    // 値"Bob"を持つ要素があるかどうか
~
    list.Add("Alice");
    Console.WriteLine("Contains(Bob) : {0}", list.Contains("Bob"));
+
    list.Add("Bob");
 

        

        
~
    Print(list);
    // 値"Dave"を持つ要素があるかどうか
-
    Console.WriteLine("Contains(Dave) : {0}", list.Contains("Dave"));
 

        

        
~
    // 要素を追加する
    // 値"Bob"を持つ最初の要素の位置を取得する
~
    list.Add("Charlie");
    Console.WriteLine("IndexOf(Bob) = {0}", list.IndexOf("Bob"));
 

        

        
~
    Print(list);
    // 値"Eve"を持つ最初の要素の位置を取得する
~
  }
    Console.WriteLine("IndexOf(Eve) = {0}", list.IndexOf("Eve"));
 

        

        
~
  // Listの内容を列挙して表示する
    // 値"Alice"を持つ最後の要素の位置を取得する
~
  static void Print(List<string> list)
    Console.WriteLine("LastIndexOf(Alice) = {0}", list.LastIndexOf("Alice"));
+
  {
+
    foreach (string e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
743,116 790,42
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 要素が格納されていない空のListを作成
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Bob", "Alice"})
+
    Dim list As New List(Of String)()
 

        

        
~
    ' 要素を追加する
    ' 値"Bob"を持つ要素があるかどうか
~
    list.Add("Alice")
    Console.WriteLine("Contains(Bob) : {0}", list.Contains("Bob"))
+
    list.Add("Bob")
 

        

        
~
    Print(list)
    ' 値"Dave"を持つ要素があるかどうか
-
    Console.WriteLine("Contains(Dave) : {0}", list.Contains("Dave"))
 

        

        
~
    ' 要素を追加する
    ' 値"Bob"を持つ最初の要素の位置を取得する
~
    list.Add("Charlie")
    Console.WriteLine("IndexOf(Bob) = {0}", list.IndexOf("Bob"))
 

        

        
~
    Print(list)
    ' 値"Eve"を持つ最初の要素の位置を取得する
~
  End Sub
    Console.WriteLine("IndexOf(Eve) = {0}", list.IndexOf("Eve"))
 

        

        
~
  ' Listの内容を列挙して表示する
    ' 値"Alice"を持つ最後の要素の位置を取得する
~
  Shared Sub Print(ByVal list As List(Of String))
    Console.WriteLine("LastIndexOf(Alice) = {0}", list.LastIndexOf("Alice"))
+
    For Each e As String In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Alice, Bob, 
Contains(Bob) : True
~
Alice, Bob, Charlie, 
Contains(Dave) : False
~
}}
IndexOf(Bob) = 1
~

          
IndexOf(Eve) = -1
~
#remarks
LastIndexOf(Alice) = 4
+
追加する位置を指定して要素を挿入したい場合は[[Insertメソッド>#List.Insert]]を使うことができます。
+
#remarks-end
+

          
+
**要素の挿入 (Insert) [#List.Insert]
+
追加する位置を指定して要素を挿入したい場合は&msdn(netfx,member,System.Collections.Generic.List`1.Insert){Insertメソッド};を使います。 Insertメソッドでは挿入する''位置''(``0``から始まるインデックス)、挿入したい''要素''の順で引数を指定します。
+

          
+
#tabpage(codelang=cs,container-title=Insertメソッドを使ってListに要素を挿入する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // 初期状態で2つの要素があるListを作成
+
    List<string> list = new List<string>() {"Alice", "Charlie"};
+

          
+
    Print(list);
+

          
+
    // インデックス1の位置に要素を挿入する
+
    list.Insert(1, "Bob");
+

          
+
    Print(list);
+
  }
+

          
+
  // Listの内容を列挙して表示する
+
  static void Print(List<string> list)
+
  {
+
    foreach (string e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
 
}}
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' 初期状態で2つの要素があるListを作成
+
    Dim list As New List(Of String)(New String() {"Alice", "Charlie"})
+

          
+
    Print(list)
+

          
+
    ' インデックス1の位置に要素を挿入する
+
    list.Insert(1, "Bob")
+

          
+
    Print(list)
+
  End Sub
+

          
+
  ' Listの内容を列挙して表示する
+
  Shared Sub Print(ByVal list As List(Of String))
+
    For Each e As String In list
+
      Console.Write("{0}, ", e)
+
    Next
 

        

        
~
    Console.WriteLine()
なお、[[Find等のメソッド>#List_Predicate]]を使うと、条件を指定して要素を検索することが出来ます。 また、文字列を格納するリストで大文字小文字を無視した検索をしたい場合などはこれらのメソッドを使う必要があります。
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
 

        

        
+
#prompt(実行結果){{
+
Alice, Charlie, 
+
Alice, Bob, Charlie, 
+
}}
 

        

        
~
**複数の要素・コレクションの追加 (AddRange) [#List.AddRange]
***二分探索 [#List_BinarySearch]
~
複数の要素を一度にまとめて追加したい場合は、&msdn(netfx,member,System.Collections.Generic.List`1.AddRange){AddRangeメソッド};を使います。 配列や他のListなどの''コレクション''に格納されている内容をまとめてListに追加したい場合にAddRangeメソッドを使うことができます。
IndexOfメソッドやContainsメソッドではList内の要素を先頭から走査して一致する要素を検索します。 &msdn(netfx,member,System.Collections.Generic.List`1.BinarySearch){BinarySearchメソッド};を使うと''二分探索''によって要素を検索することができます。 二分探索による検索では、あらかじめList内の要素がソートされていないと結果が不正となる一方、IndexOfメソッドよりも高速に検索を行うことができるという特徴があります(IndexOfやContainsはO(&var{n};)、BinarySearchはO(log &var{n};))。 格納されている要素が多数となる場合には二分探索による検索がより効果的です。
 

        

        
~
#tabpage(codelang=cs,container-title=AddRangeメソッドを使って複数の要素を一度にListへ追加する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
861,26 834,19
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 初期状態でいくつか要素が格納されているListを作成
    List<string> list = new List<string>() {"Bob", "Alice", "Eve", "Charlie", "Dave"};
+
    List<string> list = new List<string>() {"Dave", "Eve"};
 

        

        
~
    // 追加したい要素を含む配列
    // 二分探索を行う前にlistをソートされた状態にしておく
~
    string[] arr = new string[] {"Alice", "Bob", "Charlie"};
    list.Sort();
 

        

        
~
    // Listの末尾に複数の要素を追加する (配列に含まれている内容をすべて追加する)
    // 値"Bob"を持つ要素の位置を取得する
~
    list.AddRange(arr);
    Console.WriteLine("BinarySearch(Bob) = {0}", list.BinarySearch("Bob"));
 

        

        
~
    Print(list);
    // 値"Eve"を持つ要素の位置を取得する
~
  }
    Console.WriteLine("BinarySearch(Eve) = {0}", list.BinarySearch("Eve"));
 

        

        
~
  static void Print(List<string> list)
    // 存在しない値"Adam"の位置を取得する(負の値が返される)
~
  {
    Console.WriteLine("BinarySearch(Adam) = {0}", list.BinarySearch("Adam"));
+
    foreach (string e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
891,151 857,53
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 初期状態でいくつか要素が格納されているListを作成
    Dim list As New List(Of String)(New String() {"Bob", "Alice", "Eve", "Charlie", "Dave"})
+
    Dim list As New List(Of String)(New String() {"Dave", "Eve"})
 

        

        
~
    ' 追加したい要素を含む配列
    ' 二分探索を行う前にlistをソートされた状態にしておく
~
    Dim arr As String() = {"Alice", "Bob", "Charlie"}
    list.Sort()
 

        

        
~
    ' Listの末尾に複数の要素を追加する (配列に含まれている内容をすべて追加する)
    ' 値"Bob"を最初の要素の位置を取得する
~
    list.AddRange(arr)
    Console.WriteLine("BinarySearch(Bob) = {0}", list.BinarySearch("Bob"))
 

        

        
~
    Print(list)
    ' 値"Eve"を最初の要素の位置を取得する
~
  End Sub
    Console.WriteLine("BinarySearch(Eve) = {0}", list.BinarySearch("Eve"))
 

        

        
~
  ' Listの内容を列挙して表示する
    ' 存在しない値"Adam"の位置を取得する(負の値が返される)
~
  Shared Sub Print(ByVal list As List(Of String))
    Console.WriteLine("BinarySearch(Adam) = {0}", list.BinarySearch("Adam"))
+
    For Each e As String In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Dave, Eve, Alice, Bob, Charlie, 
+
}}
+

          
+
#remarks
+
AddRangeメソッドでは、[[Addメソッド>#List.Add]]と同様Listの末尾に要素が追加されていきます。 挿入する位置を指定したい場合には[[InsertRangeメソッド>#List.InsertRange]]を使うことが出来ます。
+
#remarks-end
+

          
+
***Listの結合 [#List_Concat]
+
AddRangeメソッドでは他のListの内容をListへ追加することもできます。 これを使って複数のListを結合することができます。
+

          
+
#tabpage(codelang=cs,container-title=AddRangeメソッドをふたつのListを結合したListを作成する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // 結合したい内容を含むList
+
    List<string> l1 = new List<string>() {"Alice", "Bob", "Charlie"};
+
    List<string> l2 = new List<string>() {"Dave", "Eve"};
+

          
+
    // l1の内容を複製して新しいListを作成
+
    List<string> lc = new List<string>(l1);
+

          
+
    // l2の内容を追加することで結合する
+
    lc.AddRange(l2);
+

          
+
    // 結合した結果を表示
+
    Print(lc);
+
  }
+

          
+
  static void Print(List<string> list)
+
  {
+
    foreach (string e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' 結合したい内容を含むList
+
    Dim l1 As New List(Of String)(New String() {"Alice", "Bob", "Charlie"})
+
    Dim l2 As New List(Of String)(New String() {"Dave", "Eve"})
+

          
+
    ' l1の内容を複製して新しいListを作成
+
    Dim lc As New List(Of String)(l1)
+

          
+
    ' l2の内容を追加することで結合する
+
    lc.AddRange(l2)
+

          
+
    Print(lc)
+
  End Sub
+

          
+
  ' Listの内容を列挙して表示する
+
  Shared Sub Print(ByVal list As List(Of String))
+
    For Each e As String In list
+
      Console.Write("{0}, ", e)
+
    Next
 

        

        
+
    Console.WriteLine()
+
  End Sub
+
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Alice, Bob, Charlie, Dave, Eve, 
BinarySearch(Bob) = 1
-
BinarySearch(Eve) = 4
-
BinarySearch(Adam) = -1
 
}}
}}
 

        

        
~
#remarks
Listとソートについては[[#List_Sort]]で解説します。
+
この例ではコンストラクタを使って[[Listの複製>#List_Cloning]]を作成しています。
+
#remarks-end
 

        

        
+
***コレクションの一部の追加 [#List_AddPartialRange]
+
AddRangeメソッドでは、指定されたコレクションの''すべての内容''を追加します。 一部分だけを追加することができるオーバーロードは用意されていません。
 

        

        
~
LINQの&msdn(netfx,member,System.Linq.Enumerable.Skip){Skipメソッド};と&msdn(netfx,member,System.Linq.Enumerable.Take){Takeメソッド};を使ってコレクションの一部を取り出すことにより、一部分だけをListに追加することができます。 この方法はListだけでなく配列を含む任意のコレクションに対して用いることができます。
**最初の要素・最後の要素
-
ListにはFirstやLastといった最初の要素・最後の要素を参照するプロパティは用意されていません。 そのため、次のように直接インデックスを指定して要素を参照する必要があります。
 

        

        
~
#tabpage(codelang=cs,container-title=SkipメソッドとTakeメソッドを使ってコレクションの一部をListに追加する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
+
using System.Linq;
 

        

        
 
class Sample
class Sample
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // Listへ格納したい内容をもったコレクション
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+
    List<int> source = new List<int>() {0, 1, 2, 3, 4};
 

        

        
~
    // 追加先となるList
    // 最初の要素(インデックスが0の要素)を取得
~
    List<int> list = new List<int>();
    Console.WriteLine(list[0]);
 

        

        
~
    // sourceのインデックス1から3つ分の要素をlistに追加する
    // 最後の要素(インデックスがCount - 1の要素)を取得
~
    // (sourceの先頭から1つ分の要素はスキップし、それに続く3つの要素を取り出して追加する)
    Console.WriteLine(list[list.Count - 1]);
+
    list.AddRange(source.Skip(1).Take(3));
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
1043,1530 911,33
 
#code{{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
+
Imports System.Linq
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' Listへ格納したい内容をもったコレクション
+
    Dim source As New List(Of Integer)(New Integer() {0, 1, 2, 3, 4})
+

          
+
    ' 追加先となるList
+
    Dim list As New List(Of Integer)()
+

          
+
    ' sourceのインデックス1から3つ分の要素をlistに追加する
+
    ' (sourceの先頭から1つ分の要素はスキップし、それに続く3つの要素を取り出して追加する)
+
    list.AddRange(source.Skip(1).Take(3))
+

          
+
    Print(list)
+
  End Sub
+

          
+
  ' Listの内容を列挙して表示する
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
1, 2, 3,
+
}}
+

          
+
Listの一部を追加する場合は、[[GetRangeメソッド>#List.GetRange]]を使ってListの一部を切り出すことによって追加することができます。
+

          
+
#tabpage(codelang=cs,container-title=GetRangeメソッドを使ってListの一部を別のListに追加する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // Listへ格納したい内容をもったコレクション
+
    List<int> source = new List<int>() {0, 1, 2, 3, 4};
+

          
+
    // 追加先となるList
+
    List<int> list = new List<int>();
+

          
+
    // sourceのインデックス1から3つ分の要素を取り出してlistに追加する
+
    list.AddRange(source.GetRange(1, 3));
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' Listへ格納したい内容をもったコレクション
+
    Dim source As New List(Of Integer)(New Integer() {0, 1, 2, 3, 4})
+

          
+
    ' 追加先となるList
+
    Dim list As New List(Of Integer)()
+

          
+
    ' sourceのインデックス1から3つ分の要素を取り出してlistに追加する
+
    list.AddRange(source.GetRange(1, 3))
+

          
+
    Print(list)
+
  End Sub
+

          
+
  ' Listの内容を列挙して表示する
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
1, 2, 3,
+
}}
+

          
+
.NET Framework 4.5以降の場合は、&msdn(netfx,type,System.ArraySegment`1){ArraySegment構造体};を使うことによって配列の一部分をListに追加することができます。
+

          
+
#tabpage(codelang=cs,container-title=ArraySegment構造体を使って配列の一部をListに追加する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // Listへ格納したい内容をもった配列
+
    int[] source = new int[] {0, 1, 2, 3, 4};
+

          
+
    // 追加先となるList
+
    List<int> list = new List<int>();
+

          
+
    // sourceのインデックス1から3つ分の要素をlistに追加する
+
    // (sourceのインデックス1から3つ分の要素を参照するArraySegmentを作成して追加する)
+
    list.AddRange(new ArraySegment<int>(source, 1, 3));
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' Listへ格納したい内容をもった配列
+
    Dim source() As Integer = New Integer() {0, 1, 2, 3, 4}
+

          
+
    ' 追加先となるList
+
    Dim list As New List(Of Integer)()
+

          
+
    ' sourceのインデックス1から3つ分の要素をlistに追加する
+
    ' (sourceのインデックス1から3つ分の要素を参照するArraySegmentを作成して追加する)
+
    list.AddRange(New ArraySegment(Of Integer)(source, 1, 3))
+

          
+
    Print(list)
+
  End Sub
+

          
+
  ' Listの内容を列挙して表示する
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
1, 2, 3,
+
}}
+

          
+
#remarks
+
.NET Framework 4.5より前のバージョンでは、ArraySegment構造体が[[IEnumerable<T>インターフェイス>programming/netfx/enumerator/0_enumerable_enumerator]]を実装していないため、AddRangeメソッドでArraySegment構造体を追加することはできません。
+
#remarks-end
+

          
+
#remarks
+
ArraySegment構造体について詳しくは[[ArraySegment>programming/netfx/fcl/System.ArraySegment]]を参照してください。
+
#remarks-end
+

          
+

          
+
**複数の要素・コレクションの挿入 (InsertRange) [#List.InsertRange]
+
挿入する位置を指定して''コレクション''に格納されている内容をListへ挿入したい場合には&msdn(netfx,member,System.Collections.Generic.List`1.InsertRange){InsertRangeメソッド};を使うことが出来ます。
+

          
+
#tabpage(codelang=cs,container-title=InsertRangeメソッドを使って複数の要素を一度にListへ挿入する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // 初期状態でいくつか要素が格納されているListを作成
+
    List<string> list = new List<string>() {"Dave", "Eve"};
+

          
+
    // 挿入したい要素を含む配列
+
    string[] arr = new string[] {"Alice", "Bob", "Charlie"};
+

          
+
    // Listのインデックス1以降に複数の要素を挿入する (配列に含まれている内容をすべて挿入する)
+
    list.InsertRange(1, arr);
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<string> list)
+
  {
+
    foreach (string e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' 初期状態でいくつか要素が格納されているListを作成
+
    Dim list As New List(Of String)(New String() {"Dave", "Eve"})
+

          
+
    ' 挿入したい要素を含む配列
+
    Dim arr As String() = {"Alice", "Bob", "Charlie"}
+

          
+
    ' Listのインデックス1以降に複数の要素を挿入する (配列に含まれている内容をすべて挿入する)
+
    list.InsertRange(1, arr)
+

          
+
    Print(list)
+
  End Sub
+

          
+
  ' Listの内容を列挙して表示する
+
  Shared Sub Print(ByVal list As List(Of String))
+
    For Each e As String In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Dave, Alice, Bob, Charlie, Eve, 
+
}}
+

          
+
#remarks
+
InsertRangeメソッドでコレクションの一部分だけを挿入する方法については、AddRangeメソッドでの例([[#List_AddPartialRange]])を参照してください。
+
#remarks-end
+

          
+

          
+

          
+
**列挙操作中の要素の追加
+
Listをforeach文で列挙している最中に要素の追加などの変更を行おうとすると、「列挙操作は実行されない可能性があります。」というメッセージとともに例外&msdn(netfx,type,System.InvalidOperationException){InvalidOperationException};がスローされます。 これを回避する方法などについては[[programming/netfx/enumerator/1_modify_collection]]で詳しく解説しています。
+

          
+

          
+
*要素の変更
+
要素を入れ替えて値を変更するには、変更したい要素のインデックスを指定して値を代入します。
+

          
+
#tabpage(codelang=cs,container-title=List内の要素の値を変更する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // 要素が格納されていない空のListを作成
+
    List<string> list = new List<string>();
+

          
+
    // 要素を追加する
+
    list.Add("Alice");
+
    list.Add("Bob");
+
    list.Add("Charlie");
+

          
+
    Print(list);
+

          
+
    // インデックス1の要素に格納されている値を変更する
+
    list[1] = "Dave";
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<string> list)
+
  {
+
    foreach (string e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' 要素が格納されていない空のListを作成
+
    Dim list As New List(Of String)()
+

          
+
    ' 要素を追加する
+
    list.Add("Alice")
+
    list.Add("Bob")
+
    list.Add("Charlie")
+

          
+
    Print(list)
+

          
+
    ' インデックス1の要素に格納されている値を変更する
+
    list(1) = "Dave"
+

          
+
    Print(list)
+
  End Sub
+

          
+
  Shared Sub Print(ByVal list As List(Of String))
+
    For Each e As String In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Alice, Bob, Charlie, 
+
Alice, Dave, Charlie, 
+
}}
+

          
+
**構造体要素の変更 [#modify_valuetype_element]
+
要素に構造体を格納するようにしたListで構造体のプロパティやフィールドだけを変更しようとする場合は注意が必要です。 例えば、次のようなコードはコンパイルエラーとなります。
+

          
+
#tabpage(codelang=cs,container-title=Listに格納されている構造体のフィールドを直接変更しようとした場合)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
// Listに格納する構造体
+
struct S
+
{
+
  public int F;
+

          
+
  public S(int f)
+
  {
+
    F = f;
+
  }
+
}
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<S> list = new List<S>();
+

          
+
    // フィールドFに値3を設定した構造体を格納
+
    list.Add(new S(3));
+

          
+
    // インデックス0の構造体フィールドの値を変更したいが、コンパイルエラーとなる
+
    list[0].F = 16;
+
    // error CS1612: 変数ではないため、'System.Collections.Generic.List<S>.this[int]'の戻り値を変更できません。
+

          
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
' Listに格納する構造体
+
Structure S
+
  Public F As Integer
+

          
+
  Public Sub New(ByVal val As Integer)
+
    F = val
+
  End Sub
+
End Structure
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of S)()
+

          
+
    ' フィールドFに値3を設定した構造体を格納
+
    list.Add(new S(3))
+

          
+
    ' インデックス0の構造体フィールドの値を変更したいが、コンパイルエラーとなる
+
    list(0).F = 16
+
    ' error BC30068: Expression は値であるため、代入式のターゲットにすることはできません。
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
このような操作を行いたい場合は、いったんListから一時変数に構造体をコピーし、値を変更してから再度Listに格納するようにします。
+

          
+
#tabpage(codelang=cs,container-title=Listに格納されている構造体のフィールドを変更する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
// Listに格納する構造体
+
struct S
+
{
+
  public int F;
+

          
+
  public S(int f)
+
  {
+
    F = f;
+
  }
+
}
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<S> list = new List<S>();
+

          
+
    // フィールドFに値3を設定した構造体を格納
+
    list.Add(new S(3));
+

          
+
    // Listに格納した構造体フィールドの値を参照
+
    Console.WriteLine("list[0].F = {0}", list[0].F);
+

          
+
    // フィールドの値を変更したい構造体を一時変数にコピーする
+
    S tmp = list[0];
+

          
+
    // 一時変数に代入した構造体のフィールドの値を変更する
+
    tmp.F = 16;
+

          
+
    // 変更した構造体を再度Listに格納する
+
    list[0] = tmp;
+

          
+
    // Listに格納した構造体フィールドの値を参照
+
    Console.WriteLine("list[0].F = {0}", list[0].F);
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
' Listに格納する構造体
+
Structure S
+
  Public F As Integer
+

          
+
  Public Sub New(ByVal val As Integer)
+
    F = val
+
  End Sub
+
End Structure
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of S)()
+

          
+
    ' フィールドFに値3を設定した構造体を格納
+
    list.Add(new S(3))
+

          
+
    ' Listに格納した構造体フィールドの値を参照
+
    Console.WriteLine("list(0).F = {0}", list(0).F)
+

          
+
    ' フィールドの値を変更したい構造体を一時変数にコピーする
+
    Dim tmp As S = list(0)
+

          
+
    ' 一時変数に代入した構造体のフィールドの値を変更する
+
    tmp.F = 16
+

          
+
    ' 変更した構造体を再度Listに格納する
+
    list(0) = tmp
+

          
+
    ' Listに格納した構造体フィールドの値を参照
+
    Console.WriteLine("list(0).F = {0}", list(0).F)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
list[0].F = 3
+
list[0].F = 16
+
}}
+

          
+
#remarks
+
構造体ではなくクラスのインスタンスを格納する場合はこのような操作を行う必要はありません。 この違いは型が値型か参照型かによって決まります。 詳しくは[[programming/netfx/valuetype_referencetype#value_type_property]]を参照してください。
+
#remarks-end
+

          
+
*要素の削除
+
**値を指定した削除 (Remove) [#List.Remove]
+
削除したい値を指定してListに格納されている要素を削除するには&msdn(netfx,member,System.Collections.Generic.List`1.Remove){Removeメソッド};を使います。 List内に同じ値を持つ要素が複数ある場合、Removeメソッドは''最初に見つかった''ものを削除します。
+

          
+
Listから要素を削除した場合、Removeメソッドは``True``を返します。 削除しようとした値をもつ要素がList内に無かった場合、Removeメソッドは``False``を返します。
+

          
+
#tabpage(codelang=cs,container-title=Removeメソッドを使って指定された値を持つ要素をList内から削除する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<int> list = new List<int>() {0, 1, 2, 1, 0};
+

          
+
    Print(list);
+

          
+
    // 値1を持つ最初の要素を削除する
+
    // (最初に見つかった1が削除される)
+
    list.Remove(1);
+

          
+
    Print(list);
+

          
+
    // 値1を持つ最初の要素を削除する
+
    list.Remove(1);
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of Integer)(New Integer() {0, 1, 2, 1, 0})
+

          
+
    Print(list)
+

          
+
    ' 値1を持つ最初の要素を削除する
+
    ' (最初に見つかった1が削除される)
+
    list.Remove(1)
+

          
+
    Print(list)
+

          
+
    ' 値1を持つ最初の要素を削除する
+
    list.Remove(1)
+

          
+
    Print(list)
+
  End Sub
+

          
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
0, 1, 2, 1, 0, 
+
0, 2, 1, 0, 
+
0, 2, 0,
+
}}
+

          
+
#remarks
+
Removeメソッドでは''削除したい値''を指定します。 ''削除したい要素のインデックス''を指定して要素を削除したい場合は[[RemoveAtメソッド>#List.RemoveAt]]メソッドを使うことができます。
+
#remarks-end
+

          
+
**インデックスを指定した削除 (RemoveAt) [#List.RemoveAt]
+
削除したい要素のインデックスを指定してListに格納されている要素を削除するには&msdn(netfx,member,System.Collections.Generic.List`1.RemoveAt){RemoveAtメソッド};を使います。
+

          
+
#tabpage(codelang=cs,container-title=RemoveAtメソッドを使って指定された位置にあるList内の要素を削除する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<int> list = new List<int>() {0, 1, 2, 3, 4};
+

          
+
    Print(list);
+

          
+
    // インデックス1の要素を削除する
+
    // ({0, 1, 2, 3, 4}の1が削除される)
+
    list.RemoveAt(1);
+

          
+
    Print(list);
+

          
+
    // インデックス2の要素を削除する
+
    // ({0, 2, 3, 4}の3が削除される)
+
    list.RemoveAt(2);
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of Integer)(New Integer() {0, 1, 2, 3, 4})
+

          
+
    Print(list)
+

          
+
    ' インデックス1の要素を削除する
+
    ' ({0, 1, 2, 3, 4}の1が削除される)
+
    list.RemoveAt(1)
+

          
+
    Print(list)
+

          
+
    ' インデックス2の要素を削除する
+
    ' ({0, 2, 3, 4}の3が削除される)
+
    list.RemoveAt(2)
+

          
+
    Print(list)
+
  End Sub
+

          
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
0, 1, 2, 3, 4, 
+
0, 2, 3, 4, 
+
0, 2, 4, 
+
}}
+

          
+
#remarks
+
RemoveAtメソッドでは''削除したい要素のインデックス''を指定します。 ''削除したい値''を指定して要素を削除したい場合は[[Removeメソッド>#List.Remove]]メソッドを使うことができます。 また、''削除したい要素の範囲''を指定して要素を削除したい場合は[[RemoveRangeメソッド>#List.RemoveRange]]を使うことができます。
+
#remarks-end
+

          
+
**範囲を指定した削除 (RemoveRange) [#List.RemoveRange]
+
&msdn(netfx,member,System.Collections.Generic.List`1.RemoveRange){RemoveRangeメソッド};を使うとList内の指定した範囲にある複数の要素を削除することができます。
+

          
+
#tabpage(codelang=cs,container-title=RemoveRangeメソッドを使って指定した範囲にある要素をListから削除する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<int> list = new List<int>() {0, 1, 2, 3, 4};
+

          
+
    Print(list);
+

          
+
    // インデックス2から要素3個を削除する
+
    // ({0, 1, 2, 3, 4}の2, 3, 4が削除される)
+
    list.RemoveRange(2, 3);
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of Integer)(New Integer() {0, 1, 2, 3, 4})
+

          
+
    Print(list)
+

          
+
    ' インデックス2から要素3個を削除する
+
    ' ({0, 1, 2, 3, 4}の2, 3, 4が削除される)
+
    list.RemoveRange(2, 3)
+

          
+
    Print(list)
+
  End Sub
+

          
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
0, 1, 2, 3, 4, 
+
0, 1, 
+
}}
+

          
+
**全要素のクリア (Clear) [#List.Clear]
+
&msdn(netfx,member,System.Collections.Generic.List`1.Clear){Clearメソッド};を使うと、List内の全ての要素を削除することができます。 Clearメソッドを呼び出すと、Listは空になり長さ(Length)が``0``となります。
+

          
+
#tabpage(codelang=cs,container-title=Clearメソッドを使ってListを空にする)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<int> list = new List<int>() {0, 1, 2, 3, 4};
+

          
+
    Print(list);
+

          
+
    // List内の全要素を削除する
+
    list.Clear();
+

          
+
    Print(list);
+

          
+
    // 新たにListへ要素を追加する
+
    list.Add(5);
+
    list.Add(6);
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of Integer)(New Integer() {0, 1, 2, 3, 4})
+

          
+
    Print(list)
+

          
+
    ' List内の全要素を削除する
+
    list.Clear()
+

          
+
    Print(list)
+

          
+
    ' 新たにListへ要素を追加する
+
    list.Add(5)
+
    list.Add(6)
+

          
+
    Print(list)
+
  End Sub
+

          
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
0, 1, 2, 3, 4, 
+

          
+
5, 6, 
+
}}
+

          
+
**列挙操作中の要素の削除
+
Listをforeach文で列挙している最中に要素の削除などの変更を行おうとすると、「列挙操作は実行されない可能性があります。」というメッセージとともに例外&msdn(netfx,type,System.InvalidOperationException){InvalidOperationException};がスローされます。 これを回避する方法などについては[[programming/netfx/enumerator/1_modify_collection]]で詳しく解説しています。
+

          
+
**要素の削除に関するほかの操作
+
[[RemoveAllメソッド>#List.RemoveAll]]を使うと、''条件''を指定して要素を削除することが出来ます。 例えば「値が``5``以上の要素を削除する」、「値が``"Str"で始まる要素を削除する``」といった削除を行いたい場合は、RemoveAllメソッドを使うことができます。
+

          
+
要素の削除を行ったのちに[[TrimExcessメソッド>#List_TrimExcess]]を使うことにより、List内で確保されている領域のうち、不要になった分を削減することができます。
+

          
+

          
+

          
+
*要素の検索
+
**要素の有無 (Contains) [#List.Contains]
+
List内に特定の値をもつ要素が含まれているかどうかを調べるには&msdn(netfx,member,System.Collections.Generic.List`1.Contains){Containsメソッド};を使うことが出来ます。
+

          
+
#tabpage(codelang=cs,container-title=ContainsメソッドでList内に指定した要素が含まれているか調べる)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie"};
+

          
+
    // List内に値"Bob"を持つ要素があるかどうか
+
    Console.WriteLine("Contains(Bob) : {0}", list.Contains("Bob"));
+

          
+
    // List内に値"Dave"を持つ要素があるかどうか
+
    Console.WriteLine("Contains(Dave) : {0}", list.Contains("Dave"));
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie"})
+

          
+
    ' 値"Bob"を持つ要素があるかどうか
+
    Console.WriteLine("Contains(Bob) : {0}", list.Contains("Bob"))
+

          
+
    ' 値"Dave"を持つ要素があるかどうか
+
    Console.WriteLine("Contains(Dave) : {0}", list.Contains("Dave"))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Contains(Bob) : True
+
Contains(Dave) : False
+
}}
+

          
+
#remarks
+
[[Exists等のメソッド>#List_Predicate]]を使うと、より複雑な条件を指定して要素を検索することが出来ます。 また、文字列を格納するリストで大文字小文字を無視した検索をしたい場合などにはこれらのメソッドを使う必要があります。 詳しくは[[#List_Predicate]]で後述します。
+
#remarks-end
+

          
+
**要素の位置の検索 (IndexOf, LastIndexOf) [#List.IndexOf]
+
List内のどこに含まれているかを調べるには&msdn(netfx,member,System.Collections.Generic.List`1.IndexOf){IndexOfメソッド};を使うことが出来ます。 IndexOfメソッドでは、要素が見つかった場合はその要素のインデックスを返します。 もし見つからなければ``-1``が返されます。
+

          
+
IndexOfメソッドはListの''先頭から調べて最初に見つかった要素''のインデックスを返しますが、&msdn(netfx,member,System.Collections.Generic.List`1.LastIndexOf){LastIndexOfメソッド};を使うとListの''末尾から調べて最初に見つかった要素''のインデックス(List内で一番最後にあるインデックス)を取得することができます。 検索したい要素がListの後方にあることが想定される場合は、LastIndexOfメソッドを使った方が早く見つけることができます。
+

          
+
#tabpage(codelang=cs,container-title=IndexOfメソッド・LastIndexOfメソッドを使ってList内にある要素の位置を検索して取得する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Bob", "Alice"};
+

          
+
    // 値"Bob"を持つ最初の要素の位置を取得する
+
    Console.WriteLine("IndexOf(Bob) = {0}", list.IndexOf("Bob"));
+

          
+
    // 値"Eve"を持つ最初の要素の位置を取得する
+
    Console.WriteLine("IndexOf(Eve) = {0}", list.IndexOf("Eve"));
+

          
+
    // 値"Alice"を持つ最後の要素の位置を取得する
+
    Console.WriteLine("LastIndexOf(Alice) = {0}", list.LastIndexOf("Alice"));
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Bob", "Alice"})
+

          
+
    ' 値"Bob"を持つ最初の要素の位置を取得する
+
    Console.WriteLine("IndexOf(Bob) = {0}", list.IndexOf("Bob"))
+

          
+
    ' 値"Eve"を持つ最初の要素の位置を取得する
+
    Console.WriteLine("IndexOf(Eve) = {0}", list.IndexOf("Eve"))
+

          
+
    ' 値"Alice"を持つ最後の要素の位置を取得する
+
    Console.WriteLine("LastIndexOf(Alice) = {0}", list.LastIndexOf("Alice"))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
IndexOf(Bob) = 1
+
IndexOf(Eve) = -1
+
LastIndexOf(Alice) = 4
+
}}
+

          
+
#remarks
+
[[FindIndex・FindLastIndex等のメソッド>#List_Predicate]]を使うと、より複雑な条件を指定して要素を検索することが出来ます。 また、文字列を格納するリストで大文字小文字を無視した検索をしたい場合などにはこれらのメソッドを使う必要があります。 詳しくは[[#List_Predicate]]で後述します。
+
#remarks-end
+

          
+
**二分探索 (BinarySearch) [#List.BinarySearch]
+
[[Containsメソッド>#List.Contains]]や[[IndexOfメソッド>#List.IndexOf]]ではList内の要素を先頭から走査して一致する要素を検索します。 &msdn(netfx,member,System.Collections.Generic.List`1.BinarySearch){BinarySearchメソッド};を使うと''二分探索''によって要素を検索することができます。
+

          
+
二分探索による検索では、あらかじめList内の要素がソートされていないと結果が不正となる一方、IndexOfメソッドよりも高速に検索を行うことができるという特徴があります(IndexOfやContainsはO(&var{n};)、BinarySearchはO(log &var{n};))。 格納されている要素が多数となる場合には二分探索による検索がより効果的です。
+

          
+
#tabpage(codelang=cs,container-title=二分探索によってList内にある要素の位置を検索して取得する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Bob", "Alice", "Eve", "Charlie", "Dave"};
+

          
+
    // 二分探索を行う前にlistをソートされた状態にしておく
+
    list.Sort();
+

          
+
    // 値"Bob"を持つ要素の位置を取得する
+
    Console.WriteLine("BinarySearch(Bob) = {0}", list.BinarySearch("Bob"));
+

          
+
    // 値"Eve"を持つ要素の位置を取得する
+
    Console.WriteLine("BinarySearch(Eve) = {0}", list.BinarySearch("Eve"));
+

          
+
    // 存在しない値"Adam"の位置を取得する(負の値が返される)
+
    Console.WriteLine("BinarySearch(Adam) = {0}", list.BinarySearch("Adam"));
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Bob", "Alice", "Eve", "Charlie", "Dave"})
+

          
+
    ' 二分探索を行う前にlistをソートされた状態にしておく
+
    list.Sort()
+

          
+
    ' 値"Bob"を最初の要素の位置を取得する
+
    Console.WriteLine("BinarySearch(Bob) = {0}", list.BinarySearch("Bob"))
+

          
+
    ' 値"Eve"を最初の要素の位置を取得する
+
    Console.WriteLine("BinarySearch(Eve) = {0}", list.BinarySearch("Eve"))
+

          
+
    ' 存在しない値"Adam"の位置を取得する(負の値が返される)
+
    Console.WriteLine("BinarySearch(Adam) = {0}", list.BinarySearch("Adam"))
+
  End Sub
+
End Class
+

          
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
BinarySearch(Bob) = 1
+
BinarySearch(Eve) = 4
+
BinarySearch(Adam) = -1
+
}}
+

          
+
Listとソートについては[[#List.Sort]]で解説します。
+

          
+

          
+
**最初の要素・最後の要素 [#List_First_Last]
+
ListにはFirstやLastといった最初の要素・最後の要素を参照するプロパティは用意されていません。 そのため、次のように直接インデックスを指定して要素を参照する必要があります。
+

          
+
#tabpage(codelang=cs,container-title=直接インデックスを指定してListの最初の要素・最後の要素を参照する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 最初の要素(インデックスが0の要素)を参照
+
    Console.WriteLine(list[0]);
+

          
+
    // 最後の要素(インデックスがCount - 1の要素)を参照
+
    Console.WriteLine(list[list.Count - 1]);
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
+

          
+
    ' 最初の要素(インデックスが0の要素)を参照
+
    Console.WriteLine(list(0))
+

          
+
    ' 最後の要素(インデックスがCount - 1の要素)を参照
+
    Console.WriteLine(list(list.Count - 1))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Alice
+
Eve
+
}}
+

          
+
LINQの拡張メソッドである&msdn(netfx,member,System.Linq.Enumerable.First){Firstメソッド};と&msdn(netfx,member,System.Linq.Enumerable.Last){Lastメソッド};を使うことでも最初の要素・最後の要素を取得することができます。
+

          
+
#tabpage(codelang=cs,container-title=Firstメソッド・Lastメソッドを使ってListの最初の要素・最後の要素を参照する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+
using System.Linq;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 最初の要素を取得
+
    Console.WriteLine(list.First());
+

          
+
    // 最後の要素を取得
+
    Console.WriteLine(list.Last());
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+
Imports System.Linq
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
+

          
+
    ' 最初の要素を取得
+
    Console.WriteLine(list.First())
+

          
+
    ' 最後の要素を取得
+
    Console.WriteLine(list.Last())
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Alice
+
Eve
+
}}
+

          
+
#remarks
+
最初の要素・最後の要素を参照することが多くなる場合は、Listではなく[[Stack>programming/netfx/collections/2_generic_5_1_stack]]や[[Queue>programming/netfx/collections/2_generic_5_2_queue]]、[[LinkedList>programming/netfx/collections/2_generic_4_linkedlist]]などのコレクションを使う方がアルゴリズム上適切な可能性があります。
+
#remarks-end
+

          
+
#remarks
+
[[LinkedList>programming/netfx/collections/2_generic_4_linkedlist]]では最初の要素・最後の要素を表すFirstプロパティとLastプロパティが用意されています。
+
#remarks-end
+

          
+
#remarks
+
Listクラスでは先頭・末尾の要素の追加/取り出しを行う``push``/``pop``や``shift``/``unshift``のようなメソッドは提供されません。 ``push``/``pop``を行いたい場合は[[Stackクラス>programming/netfx/collections/2_generic_5_1_stack]]、``shift``/``unshift``を行いたい場合は[[Queueクラス>programming/netfx/collections/2_generic_5_2_queue]]を使うようにしてください。
+
#remarks-end
+

          
+
**最大の要素・最小の要素 [#List_Min_Max]
+
ListにはMinやMaxといったコレクション内での最大の値を持つ要素・最小の値を持つ要素を参照するプロパティは用意されていません。 そのため、Listのすべての要素を走査して最大・最小の要素を検索する必要があります。
+

          
+
#tabpage(codelang=cs,container-title=List内の最大の要素・最小の要素を検索する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<int> list = new List<int>() {0, 4, 2, 5, 3, 1};
+

          
+
    // 最大の要素を取得
+
    int max = 0;
+

          
+
    foreach (int e in list)
+
    {
+
      if (max < e) max = e;
+
    }
+

          
+
    Console.WriteLine("max = {0}", max);
+

          
+
    // 最小の要素を取得
+
    int min = int.MaxValue;
+

          
+
    foreach (int e in list)
+
    {
+
      if (e < min) min = e;
+
    }
+

          
+
    Console.WriteLine("min = {0}", min);
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of Integer)(New Integer() {0, 4, 2, 5, 3, 1})
+

          
+
    ' 最大の要素を取得
+
    Dim max As Integer = 0
+

          
+
    For Each e As Integer In list
+
      If max < e Then max = e
+
    Next
+

          
+
    Console.WriteLine("max = {0}", max)
+

          
+
    ' 最小の要素を取得
+
    Dim min As Integer = Integer.MaxValue
+

          
+
    For Each e As Integer In list
+
      If e < min Then min = e
+
    Next
+

          
+
    Console.WriteLine("min = {0}", min)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
max = 5
+
min = 0
+
}}
+

          
+
LINQの拡張メソッドである&msdn(netfx,member,System.Linq.Enumerable.Max){Maxメソッド};と&msdn(netfx,member,System.Linq.Enumerable.Min){Minメソッド};を使うことでも最大の要素・最小の要素を取得することができます。
+

          
+
#tabpage(codelang=cs,container-title=Maxメソッド・Minメソッドを使ってList内の最大の要素・最小の要素を取得する)
+
#code{{
+
using System;
+
using System.Collections.Generic;
+
using System.Linq;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<int> list = new List<int>() {0, 4, 2, 5, 3, 1};
+

          
+
    // 最大の要素を取得
+
    Console.WriteLine("max = {0}", list.Max());
+

          
+
    // 最小の要素を取得
+
    Console.WriteLine("min = {0}", list.Min());
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+
Imports System.Linq
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of Integer)(New Integer() {0, 4, 2, 5, 3, 1})
+

          
+
    ' 最大の要素を取得
+
    Console.WriteLine("max = {0}", list.Max())
+

          
+
    ' 最小の要素を取得
+
    Console.WriteLine("min = {0}", list.Min())
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
max = 5
+
min = 0
+
}}
+

          
+
#remarks
+
[[SortedSet>programming/netfx/collections/2_generic_6_hashset_sortedset]]では、Maxプロパティ・Minプロパティを参照することにより最大の要素・最小の要素を取得することができるようになっています。
+
#remarks-end
+

          
+

          
+

          
+
**述語(Predicate)を用いた検索 [#List_Predicate]
+
Listクラスでは、述語(&msdn(netfx,type,System.Predicate`1){Predicate<T>デリゲート};)を用いた検索・一致の検証が行えます。 条件式を記述したメソッドを一種の引数として渡すことで、その条件に合致する要素が存在するかどうか、といった操作が出来るようになります。
+

          
+
例えば、[[Containsメソッド>#List.Contains]]では引数に''具体的な値''を指定してその要素が含まれているかどうかは調べられますが、''どのような''要素が含まれているかという''条件''を指定することは出来ません。 対してExistsメソッドを使うと、「文字列の長さが5以上の」や「数値の大きさが16未満の」といった条件を指定した上で、それに合致する要素が含まれているかどうかを調べることができます。
+

          
+
#tabpage(codelang=cs,C# 2.0)
+
#code(cs,Existsメソッドを使って条件に合致する要素がListに含まれるかどうか調べる(匿名メソッド版、C# 2.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 長さが5以上の要素が存在するかどうか
+
    Console.WriteLine("Exists: {0}", list.Exists(delegate(string s) { return 5 <= s.Length; }));
+
  }
+
}
+
}}
+
#tabpage(codelang=cs,C# 3.0)
+
#code(cs,Existsメソッドを使って条件に合致する要素がListに含まれるかどうか調べる(ラムダ式版、C# 3.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 長さが5以上の要素が存在するかどうか
+
    Console.WriteLine("Exists: {0}", list.Exists(s => 5 <= s.Length));
+
  }
+
}
+
}}
+
#tabpage(codelang=vb,VB10)
+
#code(vb,Existsメソッドを使って条件に合致する要素がListに含まれるかどうか調べる(ラムダ式版、VB10以降)){{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
+

          
+
    ' 長さが5以上の要素が存在するかどうか
+
    Console.WriteLine("Exists: {0}", list.Exists(Function(s) 5 <= s.Length))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Exists: True
+
}}
+

          
+
#remarks
+
述語を用いた検索・一致の検証の場合、多くの場合既存のメソッドではなく匿名メソッドやラムダ式を使って''述語となるデリゲート''を記述することになります。 匿名メソッド・ラムダ式によるデリゲートの記述方法について詳しくは[[programming/netfx/delegate/0_abstract#delegate_syntax_anonymous-method]]および[[programming/netfx/delegate/0_abstract#delegate_syntax_lambda-expression]]を参照してください。
+
#remarks-end
+

          
+
このように、Predicateデリゲートをメソッドの引数として渡すことで、そのデリゲートによって記述された述語の条件にあう要素の検索などが行えます。
+

          
+
Existsメソッド以外にも、Listクラスには述語を使うことができるメソッドとして次のようなメソッドが用意されています。 なお、LINQのメソッドを使うことでも同様の操作ができるため、参考のため相当する操作を行えるLINQメソッドについても併記しています。
+

          
+
|*述語を使った検索・一致の検証を行うためのListクラスのメソッド
+
|>|~メソッド|~動作|~相当するLINQのメソッドの呼び出し|h
+
|~合致する要素の取得|&msdn(netfx,member,System.Collections.Generic.List`1.Find){Find};|述語で記述した条件に合致する''最初の要素を取得''する&br;(合致する要素がない場合は型のデフォルト値&sub{*1};が返される)|&msdn(netfx,member,System.Linq.Enumerable.FirstOrDefault){FirstOrDefault(Func<TSource, bool>)};|
+
|~|&msdn(netfx,member,System.Collections.Generic.List`1.FindLast){FindLast};|述語で記述した条件に合致する''最後の要素を取得''する&br;(合致する要素がない場合は型のデフォルト値&sub{*1};が返される)|&msdn(netfx,member,System.Linq.Enumerable.LastOrDefault){LastOrDefault(Func<TSource, bool>)};|
+
|~|&msdn(netfx,member,System.Collections.Generic.List`1.FindAll){FindAll};|述語で記述した条件に合致する''すべての要素をListで取得''する&br;(合致する要素がない場合は空のListが返される)|&msdn(netfx,member,System.Linq.Enumerable.Where){Where(Func<TSource, bool>)}; + &msdn(netfx,member,System.Linq.Enumerable.ToList){ToList()};|
+
|~合致する要素のインデックスの取得|&msdn(netfx,member,System.Collections.Generic.List`1.FindIndex){FindIndex};|述語で記述した条件に合致する''最初の要素のインデックスを取得''する&br;(合致する要素がない場合は``-1``が返される)|&msdn(netfx,member,System.Linq.Enumerable.Select){Select(Func<TSource, int, TResult>)}; + &msdn(netfx,member,System.Linq.Enumerable.First){First(Func<TSource, bool>)};|
+
|~|&msdn(netfx,member,System.Collections.Generic.List`1.FindLastIndex){FindLastIndex};|述語で記述した条件に合致する''最後の要素のインデックスを取得''する&br;(合致する要素がない場合は``-1``が返される)|&msdn(netfx,member,System.Linq.Enumerable.Select){Select(Func<TSource, int, TResult>)}; + &msdn(netfx,member,System.Linq.Enumerable.Last){Last(Func<TSource, bool>)};|
+
|~合致する要素の有無の検証|&msdn(netfx,member,System.Collections.Generic.List`1.Exists){Exists};|述語で記述した条件に合致する''要素が存在するかどうか''を調べる|&msdn(netfx,member,System.Linq.Enumerable.Any){Any(Func<TSource, bool>)};|
+
|~|&msdn(netfx,member,System.Collections.Generic.List`1.TrueForAll){TrueForAll};|述語で記述した条件に、''すべての要素が合致するかどうか''を調べる|&msdn(netfx,member,System.Linq.Enumerable.All){All(Func<TSource, bool>)};|
+
|~合致する要素の削除|&msdn(netfx,member,System.Collections.Generic.List`1.RemoveAll){RemoveAll};|述語で記述した条件に''合致する要素を削除''する|&msdn(netfx,member,System.Linq.Enumerable.Where){Where(Func<TSource, bool>)}; + &msdn(netfx,member,System.Linq.Enumerable.ToList){ToList()};&br;(FindAllの述語を否定(NOT)した述語を指定)|
+

          
+
:&sup{*1};型のデフォルト値|参照型のListでは``null``/``Nothing``、値型のListでは``0``や``0``に相当する値が返されます。 型とデフォルト値については[[programming/netfx/basic_types/0_characteristics#DefaultValue]]を参照してください。
+

          
+
以下は、これらのメソッドを使った例です。
+

          
+
***条件に合致する要素の検索 (Find・FindLast・FindAll) [#List.Find]
+
#tabpage(codelang=cs,C# 2.0)
+
#code(cs,Find・FindLast・FindAllメソッドを使って条件に合致するList内の要素を取得する(匿名メソッド版、C# 2.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 長さが3である最初の要素
+
    Console.WriteLine("Find: {0}", list.Find(delegate(string s) { return s.Length == 3; }));
+

          
+
    // 長さが3である最後の要素
+
    Console.WriteLine("FindLast: {0}", list.FindLast(delegate(string s) { return s.Length == 3; }));
+

          
+
    // "e"を含むすべての要素
+
    List<string> found = list.FindAll(delegate(string s) { return s.Contains("e"); });
+

          
+
    Console.Write("FindAll: ");
+
    foreach (string e in found)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=cs,C# 3.0)
+
#code(cs,Find・FindLast・FindAllメソッドを使って条件に合致するList内の要素を取得する(ラムダ式版、C# 3.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 長さが3である最初の要素
+
    Console.WriteLine("Find: {0}", list.Find(s => s.Length == 3));
+

          
+
    // 長さが3である最後の要素
+
    Console.WriteLine("FindLast: {0}", list.FindLast(s => s.Length == 3));
+

          
+
    // "e"を含むすべての要素
+
    List<string> found = list.FindAll(s => s.Contains("e"));
+

          
+
    Console.Write("FindAll: ");
+
    foreach (string e in found)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb,VB10)
+
#code(vb,Find・FindLast・FindAllメソッドを使って条件に合致するList内の要素を取得する(ラムダ式版、VB10以降)){{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
+

          
+
    ' 長さが3である最初の要素
+
    Console.WriteLine("Find: {0}", list.Find(Function(s) s.Length = 3))
+

          
+
    ' 長さが3である最後の要素
+
    Console.WriteLine("FindLast: {0}", list.FindLast(Function(s) s.Length = 3))
+

          
+
    ' "e"を含むすべての要素
+
    Dim found As List(Of String) = list.FindAll(Function(s) s.Contains("e"))
+

          
+
    Console.Write("FindAll: ")
+
    For Each e As String In found
+
      Console.Write("{0}, ", e)
+
    Next
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Find: Bob
+
FindLast: Eve
+
FindAll: Alice, Charlie, Dave, Eve, 
+
}}
+

          
+
***条件に合致する要素のインデックスの取得 (FindIndex・FindLastIndex) [#List.FindIndex]
+

          
+
#code(cs,FindIndex・FindLastIndexメソッドを使ってListから条件に合致する要素のインデックスを取得する(ラムダ式版、C# 3.0以降)){{
+
using System;
+
using System.Collections.Generic;
+
using System.Linq;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // "ve"で終わるもののうち、最初の要素のインデックス
+
    Console.WriteLine("FindIndex: {0}", list.FindIndex(s => s.EndsWith("ve")));
+

          
+
    // "ve"で終わるもののうち、最後の要素のインデックス
+
    Console.WriteLine("FindLastIndex: {0}", list.FindLastIndex(s => s.EndsWith("ve")));
+

          
+
    // "ve"で終わるもののうち、最初の要素のインデックス
+
    // (Select+Firstメソッドを使ったFindIndexとの比較)
+
    Console.WriteLine("Select+First: {0}", list.Select((s, index) => new {Element = s, Index = index}).First(e => e.Element.EndsWith("ve")).Index);
+

          
+
    // "ve"で終わるもののうち、最後の要素のインデックス
+
    // (Select+Lastメソッドを使ったFindLastIndexとの比較)
+
    Console.WriteLine("Select+Last: {0}", list.Select((s, index) => new {Element = s, Index = index}).Last(e => e.Element.EndsWith("ve")).Index);
+
  }
+
}
+
}}
+

          
+
#prompt(実行結果){{
+
FindIndex: 3
+
FindLastIndex: 4
+
Select+First: 3
+
Select+Last: 4
+
}}
+

          
+
#remarks
+
比較として、LINQの&msdn(netfx,member,System.Linq.Enumerable.Select){Selectメソッド};と&msdn(netfx,member,System.Linq.Enumerable.First){Firstメソッド};・&msdn(netfx,member,System.Linq.Enumerable.Last){Lastメソッド};を使った場合についても併記しています。 なお、要素が見つからなかった場合は例外&msdn(netfx,type,System.InvalidOperationException){InvalidOperationException};がスローされるため、必要に応じて実装を書き換える必要があります。
+
#remarks-end
+

          
+
***条件に合致する要素の有無 (Exists・TrueForAll) [#List.Exists]
+
#tabpage(codelang=cs,C# 2.0)
+
#code(cs,Exists・TrueForAllメソッドを使って条件に合致する要素がListに含まれるかどうか調べる(匿名メソッド版、C# 2.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 長さが5以上の要素が存在するかどうか
+
    Console.WriteLine("Exists: {0}", list.Exists(delegate(string s) { return 5 <= s.Length; }));
+

          
+
    // すべての要素が"e"で終わるかどうか
+
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(delegate(string s) { return s.EndsWith("e"); }));
+

          
+
    // すべての要素の長さが10未満かどうか
+
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(delegate(string s) { return s.Length < 10; }));
+
  }
+
}
+
}}
+
#tabpage(codelang=cs,C# 3.0)
+
#code(cs,Exists・TrueForAllメソッドを使って条件に合致する要素がListに含まれるかどうか調べる(ラムダ式版、C# 3.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // 長さが5以上の要素が存在するかどうか
+
    Console.WriteLine("Exists: {0}", list.Exists(s => 5 <= s.Length));
+

          
+
    // すべての要素が"e"で終わるかどうか
+
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(s => s.EndsWith("e")));
+

          
+
    // すべての要素の長さが10未満かどうか
+
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(s => s.Length < 10));
+
  }
+
}
+
}}
+
#tabpage(codelang=vb,VB10)
+
#code(vb,Exists・TrueForAllメソッドを使って条件に合致する要素がListに含まれるかどうか調べる(ラムダ式版、VB10以降)){{
+
Imports System
+
Imports System.Collections.Generic
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
 
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' 長さが5以上の要素が存在するかどうか
    ' 最初の要素(インデックスが0の要素)を取得
~
    Console.WriteLine("Exists: {0}", list.Exists(Function(s) 5 <= s.Length))
    Console.WriteLine(list(0))
 

        

        
~
    ' すべての要素が"e"で終わるかどうか
    ' 最後の要素(インデックスがCount - 1の要素)を取得
~
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(Function(s) s.EndsWith("e")))
    Console.WriteLine(list(list.Count - 1))
+

          
+
    ' すべての要素の長さが10未満かどうか
+
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(Function(s) s.Length < 10))
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
FindLast: Eve
Alice
~
TrueForAll: False
Eve
+
TrueForAll: True
 
}}
}}
 

        

        
-
LINQの拡張メソッドである&msdn(netfx,member,System.Linq.Enumerable.First){Firstメソッド};と&msdn(netfx,member,System.Linq.Enumerable.Last){Lastメソッド};を使うことでも最初の要素・最後の要素を取得することができます。
 

        

        
~
***条件に合致する要素の削除 (RemoveAll) [#List.RemoveAll]
#tabpage(codelang=cs)
~

          
#code{{
+
#tabpage(codelang=cs,C# 2.0)
+
#code(cs,RemoveAllメソッドを使って条件に合致するすべての要素をListから削除する(匿名メソッド版、C# 2.0以降)){{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
-
using System.Linq;
 

        

        
 
class Sample
class Sample
 
{
{
2574,70 945,45
 
  {
  {
 
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // "li"を含むすべての要素を削除する
    // 最初の要素を取得
~
    list.RemoveAll(delegate(string s) { return s.Contains("li"); });
    Console.WriteLine(list.First());
 

        

        
~
    foreach (string e in list)
    // 最後の要素を取得
~
    {
    Console.WriteLine(list.Last());
+
      Console.WriteLine(e);
+
    }
 
  }
  }
 
}
}
 
}}
}}
~
#tabpage(codelang=cs,C# 3.0)
#tabpage(codelang=vb)
~
#code(cs,RemoveAllメソッドを使って条件に合致するすべての要素をListから削除する(ラムダ式版、C# 3.0以降)){{
#code{{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // "li"を含むすべての要素を削除する
+
    list.RemoveAll(s => s.Contains("li"));
+

          
+
    foreach (string e in list)
+
    {
+
      Console.WriteLine(e);
+
    }
+
  }
+
}
+
}}
+
#tabpage(codelang=vb,VB10)
+
#code(vb,RemoveAllメソッドを使って条件に合致するすべての要素をListから削除する(ラムダ式版、VB10以降)){{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
-
Imports System.Linq
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
 
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' "li"を含むすべての要素を削除する
    ' 最初の要素を取得
~
    list.RemoveAll(Function(s) s.Contains("li"))
    Console.WriteLine(list.First())
 

        

        
~
    For Each e As String In list
    ' 最後の要素を取得
~
      Console.WriteLine(e)
    Console.WriteLine(list.Last())
+
    Next
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Bob
Alice
+
Dave
 
Eve
Eve
 
}}
}}
 

        

        
-
最初の要素・最後の要素を参照することが多くなる場合は、Listではなく[[Stack>programming/netfx/collections/2_generic_5_1_stack]]や[[Queue>programming/netfx/collections/2_generic_5_2_queue]]などのコレクションを使う方が適切な可能性があります。 また、[[LinkedList>programming/netfx/collections/2_generic_4_linkedlist]]では最初の要素・最後の要素を表すFirstプロパティとLastプロパティが用意されています。
 

        

        
-
**最大の要素・最小の要素
-
ListにはMinやMaxといったコレクション内での最大の値を持つ要素・最小の値を持つ要素を参照するプロパティは用意されていません。 そのため、Listのすべての要素を走査して最大・最小の要素を検索する必要があります。
 

        

        
~
*複写・複製
#tabpage(codelang=cs)
+
**配列への変換 (ToArray) [#List.ToArray]
+
&msdn(netfx,member,System.Collections.Generic.List`1.ToArray){ToArrayメソッド};を使うと、Listと同じ内容の配列を作成することができます。 このメソッドは、現在Listに格納されている内容をコピーした配列を返します。
+

          
+
#tabpage(codelang=cs,container-title=ToArrayメソッドを使ってListの内容を配列に変換する)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
2646,20 992,27
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave"};
    List<int> list = new List<int>() {0, 4, 2, 5, 3, 1};
-

          
-
    // 最大の要素を取得
-
    int max = 0;
 

        

        
~
    list.Add("Eve");
    foreach (int e in list)
-
    {
-
      if (max < e) max = e;
-
    }
 

        

        
~
    // Listの内容を配列に変換
    Console.WriteLine("max = {0}", max);
+
    string[] arr = list.ToArray();
 

        

        
~
    // 変換した配列の内容を表示
    // 最小の要素を取得
~
    Console.WriteLine("Length = {0}", arr.Length);
    int min = int.MaxValue;
 

        

        
~
    foreach (string e in arr)
    foreach (int e in list)
 
    {
    {
~
      Console.WriteLine(e);
      if (e < min) min = e;
 
    }
    }
-

          
-
    Console.WriteLine("min = {0}", min);
 
  }
  }
 
}
}
 
}}
}}
2670,77 1023,54
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave"})
    Dim list As New List(Of Integer)(New Integer() {0, 4, 2, 5, 3, 1})
-

          
-
    ' 最大の要素を取得
-
    Dim max As Integer = 0
 

        

        
~
    list.Add("Eve")
    For Each e As Integer In list
-
      If max < e Then max = e
-
    Next
 

        

        
~
    ' Listの内容を配列に変換
    Console.WriteLine("max = {0}", max)
+
    Dim arr As String() = list.ToArray()
 

        

        
~
    ' 変換した配列の内容を表示
    ' 最小の要素を取得
~
    Console.WriteLine("Length = {0}", arr.Length)
    Dim min As Integer = Integer.MaxValue
 

        

        
~
    For Each e As String In arr
    For Each e As Integer In list
~
      Console.WriteLine(e)
      If e < min Then min = e
 
    Next
    Next
-

          
-
    Console.WriteLine("min = {0}", min)
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Length = 5
max = 5
~
Alice
min = 0
+
Bob
+
Charlie
+
Dave
+
Eve
 
}}
}}
 

        

        
~
#remarks
LINQの拡張メソッドである&msdn(netfx,member,System.Linq.Enumerable.Max){Maxメソッド};と&msdn(netfx,member,System.Linq.Enumerable.Min){Minメソッド};を使うことでも最大の要素・最小の要素を取得することができます。
+
このメソッドでは''簡易コピー''が行われるため、参照型を要素に持つListの場合は参照のみがコピーされます。 簡易コピーについてより詳しくは[[programming/netfx/cloning]]で解説しています。
+
#remarks-end
+

          
+
#remarks
+
このメソッドでは[[AsReadOnlyメソッド>#List.AsReadOnly]]等とは異なり、Listに対する''ビュー''を返すのではなく、同じ内容を持つ配列を作成します。 そのため、作成元のListと作成後の配列のどちらかに変更を加えた場合でも、もう一方に影響することはありません。
+
#remarks-end
 

        

        
~
**配列への複写 (CopyTo) [#List.CopyTo]
#tabpage(codelang=cs)
+
Listの全部あるいは一部分だけを既存の配列にコピー(複写)したい場合は、&msdn(netfx,member,System.Collections.Generic.List`1.CopyTo){CopyToメソッド};を使うことができます。 [[ToArrayメソッド>#List.ToArray]]とは異なり、コピー先となる配列はあらかじめ用意しておく必要があります。
+

          
+
#tabpage(codelang=cs,container-title=CopyToメソッドを使ってListの一部を配列にコピーする)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
-
using System.Linq;
 

        

        
 
class Sample
class Sample
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<int> list = new List<int>() {0, 4, 2, 5, 3, 1};
 

        

        
~
    // コピー先の配列を用意
    // 最大の要素を取得
~
    string[] arr = new string[5];
    Console.WriteLine("max = {0}", list.Max());
 

        

        
~
    // Listのインデックス2から3要素分を配列のインデックス0以降にコピー
    // 最小の要素を取得
~
    list.CopyTo(2, arr, 0, 3);
    Console.WriteLine("min = {0}", list.Min());
+

          
+
    Print(arr);
+

          
+
    // Listのインデックス0から2要素分を配列のインデックス3以降にコピー
+
    list.CopyTo(0, arr, 3, 2);
+

          
+
    Print(arr);
+
  }
+

          
+
  static void Print(string[] arr)
+
  {
+
    foreach (string e in arr)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
2748,78 1078,58
 
#code{{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
-
Imports System.Linq
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of Integer)(New Integer() {0, 4, 2, 5, 3, 1})
 

        

        
~
    ' コピー先の配列を用意
    ' 最大の要素を取得
~
    Dim arr(4) As String
    Console.WriteLine("max = {0}", list.Max())
 

        

        
~
    ' Listのインデックス2から3要素分を配列のインデックス0以降にコピー
    ' 最小の要素を取得
~
    list.CopyTo(2, arr, 0, 3)
    Console.WriteLine("min = {0}", list.Min())
+

          
+
    Print(arr)
+

          
+
    ' Listのインデックス0から2要素分を配列のインデックス3以降にコピー
+
    list.CopyTo(0, arr, 3, 2)
+

          
+
    Print(arr)
+
  End Sub
+

          
+
  Shared Sub Print(ByVal arr As String())
+
    For Each e As String In arr
+
      Console.Write("{0}, ", e)
+
    Next
+
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Charlie, Dave, Eve, , , 
max = 5
~
Charlie, Dave, Eve, Alice, Bob, 
min = 0
 
}}
}}
 

        

        
 
#remarks
#remarks
~
このメソッドでは''簡易コピー''が行われるため、参照型を要素に持つListの場合は参照のみがコピーされます。 簡易コピーについてより詳しくは[[programming/netfx/cloning]]で解説しています。
[[SortedSet>programming/netfx/collections/2_generic_6_hashset_sortedset]]では、Maxプロパティ・Minプロパティを参照することにより最大の要素・最小の要素を取得することができるようになっています。
 
#remarks-end
#remarks-end
 

        

        
+
#remarks
+
Listの全要素を配列にして扱いたい場合は前述の[[ToArrayメソッド>#List.ToArray]]を使用することもできます。
+
#remarks-end
 

        

        
~
**Listの複製 [#List_Cloning]
**配列への変換・配列へのコピー
~
Listのコンストラクタに別のListを指定すると、それと全く同じ内容のListが作成されます。 これにより、Listの複製を作成することができます。
Listを配列に変換する必要がある場合は、&msdn(netfx,member,System.Collections.Generic.List`1.ToArray){ToArrayメソッド};が使えます。 このメソッドでは、現在Listに格納されている内容をコピーした配列を返します。
 

        

        
~
#tabpage(codelang=cs,container-title=Listのコンストラクタを使って既存のListの複製を作成する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
 

        

        
 
class Sample
class Sample
 
{
{
~
  public static void Main()
  static void Main()
 
  {
  {
~
    List<string> list1 = new List<string>() {"Alice", "Bob", "Charlie"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    Print(list1);
    string[] arr;
 

        

        
~
    // list1と同じの内容Listを作成する
    // Listの内容を配列に変換
~
    List<string> list2 = new List<string>(list1);
    arr = list.ToArray();
 

        

        
~
    Print(list2);
    // 変換した配列の内容を表示
~
  }
    Console.WriteLine("Length = {0}", arr.Length);
 

        

        
~
  static void Print(List<string> list)
    foreach (string e in arr)
+
  {
+
    foreach (string e in list)
 
    {
    {
~
      Console.Write("{0}, ", e);
      Console.WriteLine(e);
 
    }
    }
+

          
+
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
2830,59 1140,67
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    Dim list1 As New List(Of String)(New String() {"Alice", "Bob", "Charlie"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    Print(list1)
    Dim arr As String()
 

        

        
~
    ' list1と同じの内容Listを作成する
    ' Listの内容を配列に変換
~
    Dim list2 As New List(Of String)(list1)
    arr = list.ToArray()
 

        

        
~
    Print(list2)
    ' 変換した配列の内容を表示
~
  End Sub
    Console.WriteLine("Length = {0}", arr.Length)
 

        

        
~
  Shared Sub Print(ByVal list As List(Of String))
    For Each e As String In arr
~
    For Each e As String In list
      Console.WriteLine(e)
+
      Console.Write("{0}, ", e)
 
    Next
    Next
+

          
+
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Alice, Bob, Charlie, 
Length = 5
~
Alice, Bob, Charlie, 
Alice
-
Bob
-
Charlie
-
Dave
-
Eve
 
}}
}}
 

        

        
 
#remarks
#remarks
~
このコンストラクタによる複製では''簡易コピー''が行われるため、参照型を要素に持つListの場合は参照のみがコピーされます。 簡易コピーについてより詳しくは[[programming/netfx/cloning]]で解説しています。
なお、このメソッドでは''簡易コピー''が行われるため、参照型を要素に持つListの場合は参照のみがコピーされます。 簡易コピーについてより詳しくは[[programming/netfx/cloning]]で解説しています。
 
#remarks-end
#remarks-end
 

        

        
~
**Listの一部分の複製・サブセットの取得 (GetRange) [#List.GetRange]
また、Listの一部分だけを配列にコピーしたい場合は、&msdn(netfx,member,System.Collections.Generic.List`1.CopyTo){CopyToメソッド};を使うことが出来ます。 このメソッドではList全体を配列にコピーすることもできますが、ToArrayメソッドとは異なりあらかじめコピー先となる配列を用意しておく必要があります。
+
&msdn(netfx,member,System.Collections.Generic.List`1.GetRange){GetRangeメソッド};を使うと、Listの一部分のみを複製したList(Listのサブセット)を作成することができます。
 

        

        
~
#tabpage(codelang=cs,container-title=GetRangeメソッドを使ってListの一部分を切り出したListを作成する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
 

        

        
 
class Sample
class Sample
 
{
{
~
  public static void Main()
  static void Main()
 
  {
  {
 
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // listのインデックス2から3つ分を切り出したListを作成する
    // コピー先の配列を用意
~
    List<string> sublist = list.GetRange(2, 3);
    string[] arr = new string[5];
-

          
-
    // Listのインデックス2から3要素分を配列のインデックス0以降にコピー
-
    list.CopyTo(2, arr, 0, 3);
-

          
-
    Print(arr);
-

          
-
    // Listのインデックス0から2要素分を配列のインデックス3以降にコピー
-
    list.CopyTo(0, arr, 3, 2);
 

        

        
~
    Print(sublist);
    Print(arr);
 
  }
  }
 

        

        
~
  static void Print(List<string> list)
  static void Print(string[] arr)
 
  {
  {
~
    foreach (string e in list)
    foreach (string e in arr)
 
    {
    {
 
      Console.Write("{0}, ", e);
      Console.Write("{0}, ", e);
 
    }
    }
2900,17 1218,24
 
  Shared Sub Main()
  Shared Sub Main()
 
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' listのインデックス2から3つ分を切り出したListを作成する
    ' コピー先の配列を用意
~
    Dim sublist As List(Of String) = list.GetRange(2, 3)
    Dim arr(4) As String
-

          
-
    ' Listのインデックス2から3要素分を配列のインデックス0以降にコピー
-
    list.CopyTo(2, arr, 0, 3)
-

          
-
    Print(arr)
-

          
-
    ' Listのインデックス0から2要素分を配列のインデックス3以降にコピー
-
    list.CopyTo(0, arr, 3, 2)
 

        

        
~
    Print(sublist)
    Print(arr)
 
  End Sub
  End Sub
 

        

        
~
  Shared Sub Print(ByVal list As List(Of String))
  Shared Sub Print(ByVal arr As String())
~
    For Each e As String In list
    For Each e As String In arr
 
      Console.Write("{0}, ", e)
      Console.Write("{0}, ", e)
 
    Next
    Next
+

          
 
    Console.WriteLine()
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
2918,33 1243,31
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Charlie, Dave, Eve, 
Charlie, Dave, Eve, , , 
-
Charlie, Dave, Eve, Alice, Bob, 
 
}}
}}
 

        

        
+
#remarks
+
このメソッドによる複製では''簡易コピー''が行われるため、参照型を要素に持つListの場合は参照のみがコピーされます。 簡易コピーについてより詳しくは[[programming/netfx/cloning]]で解説しています。
+
#remarks-end
+

          
+
このメソッドは、部分配列を構成する[[ArraySegment構造体>programming/netfx/fcl/System.ArraySegment]]と似ていますが、元の配列に対する''ビュー''として動作するArraySegmentとは異なり、GetRangeメソッドが返すListは元のListを複製したものになります。 従って、元になったList・GetRangeメソッドによって取得したListに変更を加えても、もう一方に影響が及ぶことはありません。
 

        

        
~
参考までに、LINQの&msdn(netfx,member,System.Linq.Enumerable.Skip){Skipメソッド};・&msdn(netfx,member,System.Linq.Enumerable.Take){Takeメソッド};を使うことによってもコレクションの一部分を取得することができます。 これらのメソッドは、Listだけでなく配列を含む任意のコレクションに対して用いることができます。
**複製 [#List_Cloning]
-
ListのコンストラクタにListを指定すると、全く同じ内容のListが作成されます。 これにより、Listの複製を作成することができます。
 

        

        
~
#tabpage(codelang=cs,container-title=Skipメソッド・Takeメソッドを使ってコレクションの一部分を切り出したListを作成する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
+
using System.Linq;
 

        

        
 
class Sample
class Sample
 
{
{
 
  public static void Main()
  public static void Main()
 
  {
  {
~
    string[] arr = new string[] {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list1 = new List<string>() {"Alice", "Bob", "Charlie"};
 

        

        
~
    // arrの先頭2つを飛ばし、その後の3つ分を切り出したListを作成する
    Print(list1);
~
    List<string> sublist = arr.Skip(2).Take(3).ToList();

          
-
    // list1と同じの内容Listを作成する
-
    List<string> list2 = new List<string>(list1);
 

        

        
~
    Print(sublist);
    Print(list2);
 
  }
  }
 

        

        
 
  static void Print(List<string> list)
  static void Print(List<string> list)
2962,16 1285,17
 
#code{{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
+
Imports System.Linq
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    Dim arr() As String = New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"}
    Dim list1 As New List(Of String)(New String() {"Alice", "Bob", "Charlie"})
-

          
-
    Print(list1)
 

        

        
~
    ' arrの先頭2つを飛ばし、その後の3つ分を切り出したListを作成する
    ' list1と同じの内容Listを作成する
~
    Dim sublist As List(Of String) = arr.Skip(2).Take(3).ToList()
    Dim list2 As New List(Of String)(list1)
 

        

        
~
    Print(sublist)
    Print(list2)
 
  End Sub
  End Sub
 

        

        
 
  Shared Sub Print(ByVal list As List(Of String))
  Shared Sub Print(ByVal list As List(Of String))
2986,15 1310,19
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Charlie, Dave, Eve, 
Alice, Bob, Charlie, 
-
Alice, Bob, Charlie, 
 
}}
}}
 

        

        
-
#remarks
-
なお、このコンストラクタでは''簡易コピー''が行われるため、参照型を要素に持つListの場合は参照のみがコピーされます。 簡易コピーについてより詳しくは[[programming/netfx/cloning]]で解説しています。
-
#remarks-end
 

        

        
 

        

        
~
*型変換・全要素の変換 (ConvertAll) [#List.ConvertAll]
**並べ替え [#List_Sort]
~
&msdn(netfx,member,System.Collections.Generic.List`1.ConvertAll){ConvertAllメソッド};を使うと、要素のすべてを別の型に変換したListを作成できます。 ConvertAllメソッドでは、引数に変換関数となるメソッドをデリゲート(&msdn(netfx,type,System.Converter`2){Converterデリゲート};)として指定すると、List内の要素すべてに同じ変換関数を適用した結果を得ることができます。
&msdn(netfx,member,System.Collections.Generic.List`1.Sort){Sortメソッド};を使うことでList内の要素をソートすることが出来ます。 また、&msdn(netfx,member,System.Collections.Generic.List`1.Reverse){Reverseメソッド};を使うことでList内の要素の並びを逆順にすることが出来ます。 SortメソッドとReverseメソッドを組み合わせることでソートした結果を降順にすることが出来ます。
 

        

        
~
#tabpage(codelang=cs,container-title=ConvertAllメソッドを使って文字列型のListから数値型のListに変換する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3003,16 1331,29
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    // 文字列型のList
    List<int> list = new List<int>() {0, 2, 3, 1, 0, 1, 3, 1, 3};
~
    List<string> stringList = new List<string>() {"0", "1", "2", "3", "4"};

          
-
    Print(list);
-

          
-
    // List内の要素をソート (昇順に並べ替える)
-
    list.Sort();
-

          
-
    Print(list);
-

          
-
    // List内の要素の並びを逆にする (降順にする)
-
    list.Reverse();
 

        

        
~
    // stringList内のすべての要素をint.Parseメソッドで数値に変換する
    Print(list);
~
    List<int> intList = stringList.ConvertAll(int.Parse);
  }
 

        

        
~
    foreach (int e in intList)
  static void Print(List<int> list)
-
  {
-
    foreach (int e in list)
 
    {
    {
~
      Console.WriteLine(e);
      Console.Write("{0}, ", e);
 
    }
    }
-

          
-
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
3023,35 1364,47
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    ' 文字列型のList
    Dim list As New List(Of Integer)(New Integer() {0, 2, 3, 1, 0, 1, 3, 1, 3})
~
    Dim stringList As New List(Of String)(New String() {"0", "1", "2", "3", "4"})

          
-
    Print(list)
-

          
-
    ' List内の要素をソート (昇順に並べ替える)
-
    list.Sort()
-

          
-
    Print(list)
-

          
-
    ' List内の要素の並びを逆にする (降順にする)
-
    list.Reverse()
 

        

        
~
    ' stringList内のすべての要素をint.Parseメソッドで数値に変換する
    Print(list)
~
    Dim intList As List(Of Integer) = stringList.ConvertAll(AddressOf Integer.Parse)
  End Sub
 

        

        
~
    For Each e As Integer In intList
  Shared Sub Print(ByVal arr As List(Of Integer))
~
      Console.WriteLine(e)
    For Each e As Integer In arr
-
      Console.Write("{0}, ", e)
 
    Next
    Next
-
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
0
0, 2, 3, 1, 0, 1, 3, 1, 3, 
~
1
0, 0, 1, 1, 1, 2, 3, 3, 3, 
~
2
3, 3, 3, 2, 1, 1, 1, 0, 0, 
+
3
+
4
 
}}
}}
 

        

        
 
#remarks
#remarks
~
Integer.Parseなどの型変換のメソッドについては[[programming/netfx/conversion/0_basetype]]を参照してください。
大文字小文字を無視したソートや降順でのソートなど、Listクラスを使ったソートについては[[programming/netfx/sorting/0_basictypes]]や[[programming/netfx/sorting/1_compositetypes]]で詳しく解説しています。
 
#remarks-end
#remarks-end
 

        

        
~
またConvertAllメソッドは、型変換だけでなくすべての要素に同じ処理を施した結果を取得するといった方法にも使えます。
**読み取り専用 [#List.AsReadOnly]
-
&msdn(netfx,member,System.Collections.Generic.List`1.AsReadOnly){AsReadOnlyメソッド};を使うと、Listを読み取り専用にしたコレクション(&msdn(netfx,type,System.Collections.ObjectModel.ReadOnlyCollection`1){ReadOnlyCollection};)を取得することが出来ます。 このメソッドを使って作成した読み取り専用のコレクションに対しては要素の追加・削除・変更を行うことが出来ません(行おうとするとNotSupportedExceptionがスローされます)。
-

          
-
なお、このメソッドは''元のListを読み取り専用にするものではない''ので注意してください。 単に、元のListを参照する読み取り専用のコレクションを作成します。 元になったListは、依然として要素の追加・削除・変更が可能です。
 

        

        
~
#tabpage(codelang=cs,C# 2.0,container-title=ConvertAllメソッドを使ってList内のすべての文字列を長さを求めたListを作成する)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3060,57 1413,66
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    List<string> stringList = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // stringListのすべての要素に対して、その長さを求めたListを作成する
    // 読み取り専用にしたものをIListとして格納する
~
    List<int> lengthList = stringList.ConvertAll(delegate(string s) { return s.Length; });
    IList<string> readOnlyList = list.AsReadOnly();
 

        

        
~
    for (int index = 0; index < stringList.Count; index++)
    // IList.Addメソッドを使って要素の追加を試みる
~
    {
    readOnlyList.Add("Frank");
+
      Console.WriteLine("\"{0}\".Length = {1}", stringList[index], lengthList[index]);
+
    }
 
  }
  }
 
}
}
 
}}
}}
~
#tabpage(codelang=vb,VB10)
#tabpage(codelang=vb)
 
#code{{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    Dim stringList As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' stringListのすべての要素に対して、その長さを求めたListを作成する
    ' 読み取り専用にしたものをIListとして格納する
~
    Dim lengthList As List(Of Integer) = stringList.ConvertAll(Function(s) s.Length)
    Dim readOnlyList As IList(Of String) = list.AsReadOnly()
 

        

        
~
    For index As Integer = 0 To stringList.Count - 1
    ' IList.Addメソッドを使って要素の追加を試みる
~
      Console.WriteLine("""{0}"".Length = {1}", stringList(index), lengthList(index))
    readOnlyList.Add("Frank")
+
    Next
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
"Alice".Length = 5
ハンドルされていない例外: System.NotSupportedException: コレクションは読み取り専用です。
~
"Bob".Length = 3
   場所 System.Collections.ObjectModel.ReadOnlyCollection`1.System.Collections.Generic.ICollection<T>.Add(T value)
~
"Charlie".Length = 7
   場所 Sample.Main()
+
"Dave".Length = 4
+
"Eve".Length = 3
 
}}
}}
 

        

        
-
ReadOnlyCollectionについてより詳しくは[[programming/netfx/collections/3_objectmodel_1_collection#ReadOnlyCollection]]を参照してください。
 

        

        
 

        

        
-
*デリゲートを用いた操作
-
Listクラスでは、Listの要素に対する操作をメソッドとして記述しておき、それを[[デリゲート>programming/netfx/delegate]]の形で渡すことで高度な操作を行うことが出来るようになっています。
 

        

        
-
**述語(Predicate)を用いた検索 [#List_Predicate]
-
Listクラスでは、述語(Predicateデリゲート)を用いた検索・一致の検証が行えます。 条件式を記述したメソッドを一種の引数として渡すことで、その条件に合致する要素が存在するかどうか、といった操作が出来るようになります。 例えば、[[Containsメソッド>#List_Contains]]では引数に''具体的な値''を指定してその要素が含まれているかどうかは調べられますが、''どのような''要素が含まれているかという''条件''を指定することは出来ません。 対してExistsメソッドでは、「文字列の長さが5以上の」や「数値の大きさが16未満の」といった条件を指定した上で、それに合致する要素が含まれているかどうかを調べることが出来ます。
 

        

        
-
Listクラスの次のメソッドでは、Predicateデリゲートを引数として渡すことで、述語で記述した条件にあう要素の検索などが行えます。
 

        

        
-
|*Listクラスのメソッド
-
|~メソッド|~動作|h
-
|&msdn(netfx,member,System.Collections.Generic.List`1.Find){Find};|述語で記述した条件に合致する''最初の要素を取得''する|
-
|&msdn(netfx,member,System.Collections.Generic.List`1.FindLast){FindLast};|述語で記述した条件に合致する''最後の要素を取得''する|
-
|&msdn(netfx,member,System.Collections.Generic.List`1.FindAll){FindAll};|述語で記述した条件に合致する''すべての要素をListで取得''する|
-
|&msdn(netfx,member,System.Collections.Generic.List`1.FindIndex){FindIndex};|述語で記述した条件に合致する''最初の要素のインデックスを取得''する|
-
|&msdn(netfx,member,System.Collections.Generic.List`1.FindLastIndex){FindLastIndex};|述語で記述した条件に合致する''最後の要素のインデックスを取得''する|
-
|&msdn(netfx,member,System.Collections.Generic.List`1.Exists){Exists};|述語で記述した条件に合致する''要素が存在するかどうか''を調べる|
-
|&msdn(netfx,member,System.Collections.Generic.List`1.RemoveAll){RemoveAll};|述語で記述した条件に''合致する要素を削除''する|
-
|&msdn(netfx,member,System.Collections.Generic.List`1.TrueForAll){TrueForAll};|述語で記述した条件に、''すべての要素が合致するかどうか''を調べる|
 

        

        
-
以下は、これらのメソッドを使った例です。
 

        

        
~

          
#tabpage(codelang=cs,C# 2.0)
+

          
+

          
+
#tabpage(codelang=cs,C# 2.0,container-title=ConvertAllメソッドを使ってList内のすべての文字列をリバースしたListを作成する)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3121,66 1483,55
 
  {
  {
 
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // list内のすべての要素を変換する
    // 長さが5以上の要素が存在するかどうか
~
    List<string> reversedList = list.ConvertAll(delegate(string s)
    Console.WriteLine("Exists: {0}", list.Exists(delegate(string s)
-
    {
-
      return 5 <= s.Length;
-
    }));
-

          
-
    // 長さが3である最初の要素
-
    Console.WriteLine("Find: {0}", list.Find(delegate(string s)
-
    {
-
      return s.Length == 3;
-
    }));
-

          
-
    // 長さが3である最後の要素
-
    Console.WriteLine("FindLast: {0}", list.FindLast(delegate(string s)
-
    {
-
      return s.Length == 3;
-
    }));
-

          
-
    // すべての要素が"e"で終わるかどうか
-
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(delegate(string s)
 
    {
    {
~
      // 文字列(list内の各要素)をリバースする
      return s.EndsWith("e");
~
      char[] chars = s.ToCharArray();
    }));
 

        

        
~
      Array.Reverse(chars);
    // すべての要素の長さが10未満かどうか
-
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(delegate(string s)
-
    {
-
      return s.Length < 10;
-
    }));
 

        

        
~
      return new string(chars);
    // "li"を含む要素を削除
-
    list.RemoveAll(delegate(string s)
-
    {
-
      return s.Contains("li");
 
    });
    });
 

        

        
~
    foreach (string e in reversedList)
    Console.WriteLine("RemoveAll");
-

          
-
    foreach (string e in list)
 
    {
    {
 
      Console.WriteLine(e);
      Console.WriteLine(e);
 
    }
    }
 
  }
  }
 
}
}
 
}}
}}
~
#tabpage(codelang=vb,VB10)
#tabpage(codelang=cs,C# 3.0)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
+

          
+
    ' list内のすべての要素を変換する
+
    Dim reversedList As List(Of String) = list.ConvertAll(Function(s)
+
      ' 文字列(list内の各要素)をリバースする
+
      Dim chars() As Char = s.ToCharArray()
+

          
+
      Array.Reverse(chars)
+

          
+
      Return New String(chars)
+
    End Function)
+

          
+
    For Each e As String In reversedList
+
      Console.WriteLine(e)
+
    Next
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
ecilA
+
boB
+
eilrahC
+
evaD
+
evE
+
}}
+

          
+
ConvertAllメソッドではなく、LINQの&msdn(netfx,member,System.Linq.Enumerable.Select){Selectメソッド};を使うことでも同様のことを行えます。 Selectメソッドは、ConvertAllのようなメソッドをもたない他のコレクションに対しても使用することができます。 そのため、他のコレクションの内容を一度Listに移してからConvertAllメソッドを呼ぶ、といった手順を踏む必要がなくなります。
+

          
+
#tabpage(codelang=cs,C# 2.0,container-title=Selectメソッドを使ってList内のすべての要素を変換したListを作成する)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
+
using System.Linq;
 

        

        
 
class Sample
class Sample
 
{
{
3188,18 1539,27
 
  {
  {
 
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // list内のすべての要素を変換する
    // 長さが5以上の要素が存在するかどうか
~
    List<string> reversedList = list.Select(delegate(string s)
    Console.WriteLine("Exists: {0}", list.Exists(s => 5 <= s.Length));
~
    {

          
~
      // 文字列(list内の各要素)をリバースする
    // 長さが3である最初の要素
~
      char[] chars = s.ToCharArray();
    Console.WriteLine("Find: {0}", list.Find(s => s.Length == 3));
-

          
-
    // 長さが3である最後の要素
-
    Console.WriteLine("FindLast: {0}", list.FindLast(s => s.Length == 3));
-

          
-
    // すべての要素が"e"で終わるかどうか
-
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(s => s.EndsWith("e")));
-

          
-
    // すべての要素の長さが10未満かどうか
-
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(s => s.Length < 10));
 

        

        
~
      Array.Reverse(chars);
    // "li"を含む要素を削除
-
    list.RemoveAll(s => s.Contains("li"));
 

        

        
~
      return new string(chars);
    Console.WriteLine("RemoveAll");
+
    }).ToList();
 

        

        
~
    foreach (string e in reversedList)
    foreach (string e in list)
 
    {
    {
 
      Console.WriteLine(e);
      Console.WriteLine(e);
 
    }
    }
3210,23 1570,32
 
#code{{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
+
Imports System.Linq
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
 
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' list内のすべての要素を変換する
    ' 長さが5以上の要素が存在するかどうか
~
    Dim reversedList As List(Of String) = list.Select(Function(s)
    Console.WriteLine("Exists: {0}", list.Exists(Function(s) 5 <= s.Length))
~
      ' 文字列(list内の各要素)をリバースする

          
~
      Dim chars() As Char = s.ToCharArray()
    ' 長さが3である最初の要素
-
    Console.WriteLine("Find: {0}", list.Find(Function(s) s.Length = 3))
-

          
-
    ' 長さが3である最後の要素
-
    Console.WriteLine("FindLast: {0}", list.FindLast(Function(s) s.Length = 3))
-

          
-
    ' すべての要素が"e"で終わるかどうか
-
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(Function(s) s.EndsWith("e")))
-

          
-
    ' すべての要素の長さが10未満かどうか
-
    Console.WriteLine("TrueForAll: {0}", list.TrueForAll(Function(s) s.Length < 10))
 

        

        
~
      Array.Reverse(chars)
    ' "li"を含む要素を削除
-
    list.RemoveAll(Function(s) s.Contains("li"))
 

        

        
~
      Return New String(chars)
    Console.WriteLine("RemoveAll")
+
    End Function).ToList()
 

        

        
~
    For Each e As String In reversedList
    For Each e As String In list
 
      Console.WriteLine(e)
      Console.WriteLine(e)
 
    Next
    Next
 
  End Sub
  End Sub
3235,20 1604,21
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
ecilA
Exists: True
~
boB
Find: Bob
~
eilrahC
FindLast: Eve
~
evaD
TrueForAll: False
~
evE
TrueForAll: True
-
RemoveAll
-
Bob
-
Dave
-
Eve
 
}}
}}
 

        

        
-
**列挙操作 [#List_Enumeartion]
-
Listクラスでは、foreach文による列挙の他に、&msdn(netfx,member,System.Collections.Generic.List`1.ForEach){ForEachメソッド};による列挙が出来るようになっています。 このメソッドは、引数に列挙時に個々の要素に対して行う操作をデリゲートとして指定します。
 

        

        
~

          
#tabpage(codelang=cs,C# 2.0)
+
*要素の並べ替え [#List_Sort]
+
**ソート (Sort) [#List.Sort]
+
&msdn(netfx,member,System.Collections.Generic.List`1.Sort){Sortメソッド};を使うことでList内の要素をソートすることが出来ます。
+

          
+
#tabpage(codelang=cs,container-title=Sortメソッドを使ってList内の要素をソートする)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3257,69 1627,27
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    List<int> list = new List<int>() {2, 4, 0, 1, 3};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // List内の要素をソート (昇順に並べ替える)
    // foreach文による列挙
~
    list.Sort();
    Console.WriteLine("[foreach]");
+

          
+
    Print(list);
+
  }
+

          
+
  static void Print(List<int> list)
+
  {
+
    foreach (int e in list)
+
    {
+
      Console.Write("{0}, ", e);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(codelang=vb)
+
#code{{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of Integer)(New Integer() {2, 4, 0, 1, 3})
+

          
+
    ' List内の要素をソート (昇順に並べ替える)
+
    list.Sort()
+

          
+
    Print(list)
+
  End Sub
+

          
+
  Shared Sub Print(ByVal list As List(Of Integer))
+
    For Each e As Integer In list
+
      Console.Write("{0}, ", e)
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
0, 1, 2, 3, 4, 
+
}}
+

          
+
Sortメソッドでは、インスタンス自身をソートします(''破壊的変更'')。 ソートされたListが新たに作成され戻り値として返されることはありません。 そのため、ソート前の状態も維持しておきたい場合は、あらかじめ[[Listの複製>#List_Cloning]]を作っておき、その後で変更用のListをソートする必要があります。
+

          
+
#remarks
+
非破壊的なソートを行いたい場合は[[Enumerable.OrderByメソッド>programming/netfx/sorting/0_basictypes#Enumerable.OrderBy]]を使うことができます。
+
#remarks-end
 

        

        
~
#remarks
    foreach (string e in list)
~
大文字小文字を無視したソートや降順でのソートなど、Listクラスを使ったソートについては[[programming/netfx/sorting/0_basictypes]]や[[programming/netfx/sorting/1_compositetypes]]、デフォルトでどのような順序でソートされるかについては[[programming/netfx/sorting/0_basictypes_1_defaultsortorder]]で詳しく解説しています。
    {
~
#remarks-end
      Console.WriteLine(e);
-
    }
 

        

        
~
**リバース (Reverse) [#List.Reverse]
    // ForEachメソッドによる列挙
~
&msdn(netfx,member,System.Collections.Generic.List`1.Reverse){Reverseメソッド};を使うことでList内の要素の並びを逆順にする(リバースする)ことができます。
    Console.WriteLine("[ForEach]");
 

        

        
~
#tabpage(codelang=cs,container-title=Reverseメソッドを使ってList内の要素をリバースする)
    list.ForEach(delegate(string e)
-
    {
-
      Console.WriteLine(e);
-
    });
-
  }
-
}
-
}}
-
#tabpage(codelang=cs,C# 3.0)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3328,65 1656,73
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    List<string> list = new List<string>() {"Alice", "Charlie", "Dave", "Bob"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // List内の要素をリバース (逆順に並べ替える)
    // foreach文による列挙
~
    list.Reverse();
    Console.WriteLine("[foreach]");
+

          
+
    Print(list);
+
  }
 

        

        
+
  static void Print(List<string> list)
+
  {
 
    foreach (string e in list)
    foreach (string e in list)
 
    {
    {
~
      Console.Write("{0}, ", e);
      Console.WriteLine(e);
 
    }
    }
 

        

        
~
    Console.WriteLine();
    // ForEachメソッドによる列挙
-
    Console.WriteLine("[ForEach]");
-

          
-
    list.ForEach(e => Console.WriteLine(e));
 
  }
  }
 
}
}
 
}}
}}
~
#tabpage(codelang=vb)
#tabpage(codelang=vb,VB10)
 
#code{{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    Dim list As New List(Of String)(New String() {"Alice", "Charlie", "Dave", "Bob"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' List内の要素をリバース (逆順に並べ替える)
    ' For Eachステートメントによる列挙
~
    list.Reverse()
    Console.WriteLine("[For Each statement]")
+

          
+
    Print(list)
+
  End Sub
 

        

        
+
  Shared Sub Print(ByVal list As List(Of String))
 
    For Each e As String In list
    For Each e As String In list
~
      Console.Write("{0}, ", e)
      Console.WriteLine(e)
 
    Next
    Next
 

        

        
~
    Console.WriteLine()
    ' ForEachメソッドによる列挙
-
    Console.WriteLine("[ForEach]")
-

          
-
    list.ForEach(Sub(e) Console.WriteLine(e))
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Bob, Dave, Charlie, Alice, 
[foreach]
-
Alice
-
Bob
-
Charlie
-
Dave
-
Eve
-
[ForEach]
-
Alice
-
Bob
-
Charlie
-
Dave
-
Eve
 
}}
}}
 

        

        
~
Reverseメソッドでは、インスタンス自身を逆順にします(''破壊的変更'')。 リバースされたListが新たに作成され戻り値として返されることはありません。 そのため、リバース前の状態も維持しておきたい場合は、あらかじめ[[Listの複製>#List_Cloning]]を作っておき、その後で変更用のListをリバースする必要があります。
foreach文で列挙している途中にRemoveメソッドやAddメソッドを呼び出してListクラスの内容を変更することは無効な操作であるため、InvalidOperationExceptionがスローされます。
 

        

        
 
#remarks
#remarks
~
非破壊的なリバースを行いたい場合はLINQのReverseメソッド(&msdn(netfx,member,System.Linq.Enumerable.Reverse){Enumerable.Reverse};)を使うことができます。
ForEachメソッドを使った列挙の場合でも同様に無効な操作となりますが、.NET Framework 4.0以前ではInvalidOperationExceptionがスローされず、.NET Framework 4.5以降ではスローされるようになっています。 この点については[[programming/netfx/enumerator/1_modify_collection#List.ForEach]]で詳しく解説しています。
 
#remarks-end
#remarks-end
 

        

        
~
**降順でのソート (Sort+Reverse) [#List_SortDescending]
**型変換 [#List_Conversion]
~
[[Sortメソッド>#List.Sort]]はデフォルトでは昇順での並べ替えを行いますが、[[Reverseメソッド>#List.Reverse]]を組み合わせることによって降順でのソート結果を得ることが出来ます。
&msdn(netfx,member,System.Collections.Generic.List`1.ConvertAll){ConvertAllメソッド};を使うと、要素のすべてを別の型に変換出来ます。 ConvertAllメソッドの引数に変換関数となるメソッドをデリゲートとして指定すると、リスト内の要素すべてに同じ変換関数が適用されます。
 

        

        
~
#tabpage(codelang=cs,container-title=Sortメソッド+Reverseメソッドを使ってList内の要素を降順にソートする)
#tabpage(codelang=cs,container-title=文字列型のListから数値型のListに変換する例)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3395,23 1731,14
 
{
{
 
  static void Main()
  static void Main()
 
  {
  {
~
    List<string> list = new List<string>() {"Alice", "Charlie", "Dave", "Bob"};
    List<string> stringList = new List<string>() {"0", "1", "2", "3", "4"};
 

        

        
~
    // List内の要素をソートしてリバース (降順に並べ替える)
    List<int> intList = stringList.ConvertAll(int.Parse); // すべての要素をint.Parseメソッドで変換する
+
    list.Sort();
+
    list.Reverse();
 

        

        
~
    Print(list);
    foreach (int e in intList)
+
  }
+

          
+
  static void Print(List<string> list)
+
  {
+
    foreach (string e in list)
 
    {
    {
~
      Console.Write("{0}, ", e);
      Console.WriteLine(e);
 
    }
    }
+

          
+
    Console.WriteLine();
 
  }
  }
 
}
}
 
}}
}}
3422,40 1749,29
 

        

        
 
Class Sample
Class Sample
 
  Shared Sub Main()
  Shared Sub Main()
~
    Dim list As New List(Of String)(New String() {"Alice", "Charlie", "Dave", "Bob"})
    Dim stringList As New List(Of String)(New String() {"0", "1", "2", "3", "4"})
+

          
+
    ' List内の要素をリバース (逆順に並べ替える)
+
    list.Sort()
+
    list.Reverse()
 

        

        
~
    Print(list)
    Dim intList As List(Of Integer) = stringList.ConvertAll(AddressOf Integer.Parse) ' すべての要素をInteger.Parseメソッドで変換する
+
  End Sub
 

        

        
~
  Shared Sub Print(ByVal list As List(Of String))
    For Each e As Integer In intList
~
    For Each e As String In list
      Console.WriteLine(e)
+
      Console.Write("{0}, ", e)
 
    Next
    Next
+

          
+
    Console.WriteLine()
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
Dave, Charlie, Bob, Alice,
0
-
1
-
2
-
3
-
4
 
}}
}}
 

        

        
~
#remarks
また、単なる型変換だけでなく、すべての要素に同じ処理を施した結果を取得するといった方法にも使えます。
+
そのほかの降順でのソート方法については[[programming/netfx/sorting/0_basictypes#SortDescending]]で詳しく解説しています。
+
#remarks-end
+

          
+
*読み取り専用 (AsReadOnly) [#List.AsReadOnly]
+
&msdn(netfx,member,System.Collections.Generic.List`1.AsReadOnly){AsReadOnlyメソッド};を使うと、Listと同じ内容をもった読み取り専用コレクション(&msdn(netfx,type,System.Collections.ObjectModel.ReadOnlyCollection`1){ReadOnlyCollection};)を取得することが出来ます。 このメソッドを使って作成した読み取り専用のコレクションに対しては、要素の追加・削除・変更などの操作を行うことが出来ません(行おうとすると&msdn(netfx,type,System.NotSupportedException){NotSupportedException};がスローされます)。
 

        

        
~
なお、AsReadOnlyメソッドは''元のListを読み取り専用にするものではない''ので注意してください。 このメソッドは単に、元のListを参照する読み取り専用のコレクション、Listに対する読み取り専用の''ビュー''を作成します。 元になったListに対しては、依然として要素の追加・削除・変更が可能です。
#tabpage(codelang=cs,C# 2.0,container-title=List内のすべての文字列をリバースしたListを取得する例)
+

          
+
#tabpage(codelang=cs,container-title=AsReadOnlyメソッドを使ってListを読み取り専用にしたコレクションを取得する)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3466,16 1782,24
 
  {
  {
 
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
 

        

        
~
    // 読み取り専用にしたものをIListとして格納する
    List<string> reversedList = list.ConvertAll(delegate(string s)
~
    IList<string> readOnlyList = list.AsReadOnly();
    {
-
      // 文字列をリバースする
-
      char[] chars = s.ToCharArray();
-

          
-
      Array.Reverse(chars);
-

          
-
      return new string(chars);
-
    });
 

        

        
~
    // IList.Addメソッドを使って要素の追加を試みる
    foreach (string e in reversedList)
~
    // (読み取り専用のため例外NotSupportedExceptionがスローされる)
    {
~
    readOnlyList.Add("Frank");
      Console.WriteLine(e);
-
    }
 
  }
  }
 
}
}
 
}}
}}
~
#tabpage(codelang=vb)
#tabpage(codelang=vb,VB10)
 
#code{{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
3484,40 1808,38
 
  Shared Sub Main()
  Shared Sub Main()
 
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
 

        

        
~
    ' 読み取り専用にしたものをIListとして格納する
    Dim reversedList As List(Of String) = list.ConvertAll(Function(s)
~
    Dim readOnlyList As IList(Of String) = list.AsReadOnly()
      ' 文字列をリバースする
-
      Dim chars() As Char = s.ToCharArray()
-

          
-
      Array.Reverse(chars)
-

          
-
      Return New String(chars)
-
    End Function)
 

        

        
~
    ' IList.Addメソッドを使って要素の追加を試みる
    For Each e As String In reversedList
~
    ' (読み取り専用のため例外NotSupportedExceptionがスローされる)
      Console.WriteLine(e)
~
    readOnlyList.Add("Frank")
    Next
 
  End Sub
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(実行結果){{
#prompt(実行結果){{
~
ハンドルされていない例外: System.NotSupportedException: コレクションは読み取り専用です。
ecilA
~
   場所 System.Collections.ObjectModel.ReadOnlyCollection`1.System.Collections.Generic.ICollection<T>.Add(T value)
boB
~
   場所 Sample.Main()
eilrahC
-
evaD
-
evE
 
}}
}}
 

        

        
+
#remarks
+
ReadOnlyCollectionについてより詳しくは[[programming/netfx/collections/3_objectmodel_1_collection#ReadOnlyCollection]]を参照してください。
+
#remarks-end
+

          
+
#remarks
+
配列を読み取り専用にする場合についての[[programming/netfx/arrays/2_operations#Array.AsReadOnly]]も合わせて参照してください。
+
#remarks-end
+

          
+

          
+

          
 
*容量 [#List_Capacity]
*容量 [#List_Capacity]
 
Listでは、あらかじめListの内部に大きめの配列を用意しておき、そこに要素を格納していくことで可変長配列の機能を実現しています。 そのためListでは、実際にListに格納されている要素数よりも大きい配列が自動的に確保されます。 CountプロパティでList内に含まれる要素数を取得することができるのに対し、&msdn(netfx,member,System.Collections.Generic.List`1.Capacity){Capacityプロパティ};を参照することでList内で確保されている配列の容量を知ることができます。
Listでは、あらかじめListの内部に大きめの配列を用意しておき、そこに要素を格納していくことで可変長配列の機能を実現しています。 そのためListでは、実際にListに格納されている要素数よりも大きい配列が自動的に確保されます。 CountプロパティでList内に含まれる要素数を取得することができるのに対し、&msdn(netfx,member,System.Collections.Generic.List`1.Capacity){Capacityプロパティ};を参照することでList内で確保されている配列の容量を知ることができます。
 

        

        
~
以下のコードを使って、空のListに1つずつ要素を追加していったときのListの容量の変化を見てみます。
次の例では、空のListを作成し、1つずつ要素を追加していったときのListの容量の変化を見ています。
 

        

        
~
#tabpage(codelang=cs,container-title=Listの要素数Countと容量Capacityの変化)
#tabpage(codelang=cs)
~
#code(cs,type=benchmark){{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
 

        

        
3550,7 1872,7
 
}
}
 
}}
}}
 
#tabpage(codelang=vb)
#tabpage(codelang=vb)
~
#code(vb,type=benchmark){{
#code{{
 
Imports System
Imports System
 
Imports System.Collections.Generic
Imports System.Collections.Generic
 

        

        
3608,27 1930,14
 
Count=0 Capacity=32
Count=0 Capacity=32
 
}}
}}
 

        

        
~
この結果からも、Listでは要素の追加を行う際など必要になった時点で容量を拡張していることがわかります。 また、Clearメソッドを呼び出したあとも容量が変わっていないことがわかります。
このようにListでは、要素の追加を行う際など必要になった時点で容量を拡張していることがわかります。
 

        

        
~
このように、Listでは常に格納されている要素数以上の容量を持ちます。 また、Clearメソッドなどによって要素数が減っても一度確保された容量が減ることはありません。 従って、Listに対して多数の要素の追加・削除を行った後には、特に操作を行わないかぎり使われなくなった(必要以上の)領域がそのまま残されることになります。
この結果からもわかるとおり、Listでは常に格納されている要素数以上の容量を持ちます。 また、Clearメソッドなどによって要素数が減っても一度確保された容量が減ることはありません。 従って、Listに対して多数の要素の追加・削除を行った後には、使われなくなった(必要以上の)領域がそのまま残されることになります。
 

        

        
~
|*Listへの要素の追加と、List内部の状態
**容量の縮小 [#List_TrimExcess]
+
|~Listに対する操作|>|~List内部の状態|h
+
|CENTER:-|&column(content-style=font-size:80%;min-width:3em;text-align:center;){0, 1, (空き), (空き)};&br;(操作前の状態)|Count=2&br;Capacity=4|
+
|list.Add(2)|&column(content-style=font-size:80%;min-width:3em;text-align:center;){0, 1, 2, (空き)};&br;(空いている領域があるため、そこに要素が追加される)|Count=3&br;Capacity=4|
+
|list.Add(3)|&column(content-style=font-size:80%;min-width:3em;text-align:center;){0, 1, 2, 3};&br;(空いている領域があるため、そこに要素が追加されるが、以降追加するための空き領域がなくなる)|Count=4&br;Capacity=4|
+
|list.Add(4)|&column(content-style=font-size:80%;min-width:3em;text-align:center;){0, 1, 2, 3, (空き), (空き), (空き), (空き)};&br;(まずList内で自動的に容量の拡張が行われ、追加するための領域が確保される)|Count=4&br;Capacity=8|
+
|~|&column(content-style=font-size:80%;min-width:3em;text-align:center;){0, 1, 2, 3, 4, (空き), (空き), (空き)};&br;(確保された領域に要素が追加される)|Count=5&br;Capacity=8|
+

          
+
|*ListのクリアとList内部の状態
+
|~Listに対する操作|>|~List内部の状態|h
+
|CENTER:-|&column(content-style=font-size:80%;min-width:3em;text-align:center;){0, 1, 2, (空き)};&br;(操作前の状態)|Count=3&br;Capacity=4|
+
|list.Clear()|&column(content-style=font-size:80%;min-width:3em;text-align:center;){(空き), (空き), (空き), (空き)};&br;(すべての要素が削除され、各領域は空き状態になるが、容量自体は削減されない)|Count=0&br;Capacity=4|
+

          
+
**容量の縮小 (TrimExcess) [#List_TrimExcess]
 
Listにそれ以上要素を追加する必要がなくなった場合などには、&msdn(netfx,member,System.Collections.Generic.List`1.TrimExcess){TrimExcessメソッド};を使用することで不要な容量を減らすことができます。
Listにそれ以上要素を追加する必要がなくなった場合などには、&msdn(netfx,member,System.Collections.Generic.List`1.TrimExcess){TrimExcessメソッド};を使用することで不要な容量を減らすことができます。
 

        

        
~
#tabpage(codelang=cs,container-title=TrimExcessメソッドを使ってList内部の不要になっている容量を減らす)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3701,21 2010,14
 
Count=1000 Capacity=1000
Count=1000 Capacity=1000
 
}}
}}
 

        

        
~
このメソッドはList内の再割当てを行うことで使用するメモリを最小化します。 そのため、Listにそれ以上変更を加えない(追加によって容量を再度拡張する必要がない)ことが明らかな場合などに用いるべきで、不必要に何度も呼び出すことはパフォーマンスの劣化に繋がります。
このメソッドはList内の再割当てを行うことで使用するメモリを最小化します。 そのため、Listにそれ以上変更を加えないことが明らかな場合などに用いるべきで、不必要に何度も呼び出すことはパフォーマンスの劣化に繋がります。
+

          
+
|*List.TrimExcessとList内部の状態
+
|~Listに対する操作|>|~List内部の状態|h
+
|CENTER:-|&column(content-style=font-size:80%;min-width:3em;text-align:center;){0, 1,〜,499,500,〜,〜,1499,(空き),〜,〜,(空き)};&br;(操作前の状態・インデックス1500〜2047までの領域は空きとなっている)|Count=1500&br;Capacity=2048|
+
|list.RemoveRange(0, 500)|&column(content-style=font-size:80%;min-width:3em;text-align:center;){(空き),〜,〜,(空き),500,〜,〜,1499,(空き),〜,〜,(空き)};&br;(インデックス0〜499までの領域が空きとなる)|Count=1000&br;Capacity=2048|
+
|list.TrimExcess()|&column(content-style=font-size:80%;min-width:3em;text-align:center;){500,〜,〜,1499};&br;(領域の再作成と要素の再配置が行われ、必要最低限の容量になる)|Count=1000&br;Capacity=1000|
 

        

        
~

          
**初期容量
+
**初期容量 [#List_InitialCapacity]
 
Listでは容量の拡張が行われる度に領域の再割当てと要素のコピーが行われます。 そのため、Listに格納される要素の最大数があらかじめ見積もれる場合には、Listの初期容量を指定することにより再割当てとコピーを抑止することができ、パフォーマンスの向上が見込めます。 また、不必要に大きい領域の確保が行われなくなるというメリットもあります。 Listでは、コンストラクタで初期容量を指定してインスタンスを作成することができるようになっています。
Listでは容量の拡張が行われる度に領域の再割当てと要素のコピーが行われます。 そのため、Listに格納される要素の最大数があらかじめ見積もれる場合には、Listの初期容量を指定することにより再割当てとコピーを抑止することができ、パフォーマンスの向上が見込めます。 また、不必要に大きい領域の確保が行われなくなるというメリットもあります。 Listでは、コンストラクタで初期容量を指定してインスタンスを作成することができるようになっています。
 

        

        
 
次の例では、初期容量を指定しないListと指定したListについて、要素を10000個追加する場合の処理時間の違いを計測しています。
次の例では、初期容量を指定しないListと指定したListについて、要素を10000個追加する場合の処理時間の違いを計測しています。
 

        

        
~
#code(cs,type=benchmark){{
#code(cs){{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
 
using System.Diagnostics;
using System.Diagnostics;
3788,7 2090,7
 

        

        
 
初期容量を指定してListのインスタンスを作成しても、その数の要素数が確保されるわけではありません。 初期容量として指定した値に関わらず、インスタンスを作成した直後の要素数は0となります。
初期容量を指定してListのインスタンスを作成しても、その数の要素数が確保されるわけではありません。 初期容量として指定した値に関わらず、インスタンスを作成した直後の要素数は0となります。
 

        

        
~
#tabpage(codelang=cs,container-title=Listの初期容量を指定してもその要素数は確保されない)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3805,7 2107,7
 
    Console.WriteLine("Capacity = {0}", list.Capacity);
    Console.WriteLine("Capacity = {0}", list.Capacity);
 

        

        
 
    // インデックス50の要素を設定
    // インデックス50の要素を設定
~
    // (現在の要素数は0で、インデックス50は範囲外であるため、例外が発生する)
    // (要素数は0でインデックス50は範囲外のため例外が発生する)
 
    list[50] = 0;
    list[50] = 0;
 
  }
  }
 
}
}
3825,7 2127,7
 
    Console.WriteLine("Capacity = {0}", list.Capacity)
    Console.WriteLine("Capacity = {0}", list.Capacity)
 

        

        
 
    ' インデックス50の要素を設定
    ' インデックス50の要素を設定
~
    ' (現在の要素数は0で、インデックス50は範囲外であるため、例外が発生する)
    ' (要素数は0でインデックス50は範囲外のため例外が発生する)
 
    list(50) = 0
    list(50) = 0
 
  End Sub
  End Sub
 
End Class
End Class
3853,7 2155,7
 

        

        
 
次の例では、入れ子になったListを作成し、追加や削除・列挙などの操作を行っています。
次の例では、入れ子になったListを作成し、追加や削除・列挙などの操作を行っています。
 

        

        
~
#tabpage(codelang=cs,container-title=Listを入れ子にして扱う)
#tabpage(codelang=cs)
 
#code{{
#code{{
 
using System;
using System;
 
using System.Collections.Generic;
using System.Collections.Generic;
3959,115 2261,5
 
関連: [[programming/netfx/arrays/1_multidimensional]]
関連: [[programming/netfx/arrays/1_multidimensional]]
 
#remarks-end
#remarks-end
 

        

        
+

          
+
*ForEachメソッドによる列挙操作 [#List.ForEach]
+
Listクラスでは、``foreach``文による列挙の他に、&msdn(netfx,member,System.Collections.Generic.List`1.ForEach){ForEachメソッド};による列挙が出来るようになっています。 このメソッドは、引数に列挙時に個々の要素に対して行う操作をデリゲートとして指定します。
+

          
+
#remarks
+
ForEachメソッドによる列挙は、``foreach``文による列挙と結果は同じであるものの、``break``に相当する操作ができない、列挙する要素の数だけデリゲート呼び出しが行われるといった不都合があるため、ほとんどの場合では強いてForEachメソッドを使って列挙しなければならない必要性はありません。
+
#remarks-end
+

          
+
#tabpage(codelang=cs,C# 2.0)
+
#code(cs,foreach文・ForEachメソッドを使ってList内の要素を列挙する(匿名メソッド版、C# 2.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // foreach文による列挙
+
    Console.WriteLine("[foreach]");
+

          
+
    foreach (string e in list)
+
    {
+
      Console.WriteLine(e);
+
    }
+

          
+
    // ForEachメソッドによる列挙
+
    Console.WriteLine("[ForEach]");
+

          
+
    list.ForEach(delegate(string e)
+
    {
+
      Console.WriteLine(e);
+
    });
+
  }
+
}
+
}}
+
#tabpage(codelang=cs,C# 3.0)
+
#code(cs,foreach文・ForEachメソッドを使ってList内の要素を列挙する(ラムダ式版、C# 3.0以降)){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> list = new List<string>() {"Alice", "Bob", "Charlie", "Dave", "Eve"};
+

          
+
    // foreach文による列挙
+
    Console.WriteLine("[foreach]");
+

          
+
    foreach (string e in list)
+
    {
+
      Console.WriteLine(e);
+
    }
+

          
+
    // ForEachメソッドによる列挙
+
    Console.WriteLine("[ForEach]");
+

          
+
    list.ForEach(e => Console.WriteLine(e));
+
  }
+
}
+
}}
+
#tabpage(codelang=vb,VB10)
+
#code(vb,foreach文・ForEachメソッドを使ってList内の要素を列挙する(ラムダ式版、VB10以降)){{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim list As New List(Of String)(New String() {"Alice", "Bob", "Charlie", "Dave", "Eve"})
+

          
+
    ' For Eachステートメントによる列挙
+
    Console.WriteLine("[For Each statement]")
+

          
+
    For Each e As String In list
+
      Console.WriteLine(e)
+
    Next
+

          
+
    ' ForEachメソッドによる列挙
+
    Console.WriteLine("[ForEach]")
+

          
+
    list.ForEach(Sub(e) Console.WriteLine(e))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
[foreach]
+
Alice
+
Bob
+
Charlie
+
Dave
+
Eve
+
[ForEach]
+
Alice
+
Bob
+
Charlie
+
Dave
+
Eve
+
}}
+

          
+
foreach文で列挙している途中にRemoveメソッドやAddメソッドなどを呼び出してListクラスの内容を変更することは無効な操作であるため、例外&msdn(netfx,type,System.InvalidOperationException){InvalidOperationException};がスローされます。
+

          
+
#remarks
+
ForEachメソッドを使った列挙の場合でも同様に無効な操作となりますが、.NET Framework 4.0以前ではInvalidOperationExceptionがスローされず、.NET Framework 4.5以降ではスローされるようになっています。 この点については[[programming/netfx/enumerator/1_modify_collection#List.ForEach]]で詳しく解説しています。
+
#remarks-end
+

          
+

          
 
#navi(..)
#navi(..)