C#のListと配列の違い・使い分け・変換方法を初心者向けに徹底解説

はじめに

C#で複数のデータを扱うときによく使うのが「配列」と「List」です。

たとえば、複数の名前、点数、商品名、IDなどをまとめて管理したい場合、C#では配列やListを使います。しかし初心者のうちは、「Listと配列の違いがわからない」「どちらを使えばよいのか迷う」「配列からListへ変換する方法がわからない」と悩むことも多いでしょう。

結論から言うと、要素数が固定なら配列、要素数が増減するならListを使うのが基本です。

この記事では、C#のListと配列の違い、使い分け、基本的な書き方、変換方法、よくあるエラーまで初心者向けにわかりやすく解説します。

1. C#のListと配列とは？まず押さえる基本

1-1. 配列とは何か

配列とは、同じ型のデータをまとめて管理できる仕組みです。

たとえば、複数の整数を扱いたい場合、次のように配列を使えます。

C#
int[] scores = { 80, 90, 70 };

この例では、scoresという配列に、80、90、70という3つの整数が入っています。

配列の大きな特徴は、要素数が固定されることです。一度作成した配列は、基本的に後から要素数を増やしたり減らしたりできません。

C#
int[] numbers = new int[3];

numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

このように、new int[3]と書くと、整数を3つ入れられる配列が作られます。

1-2. Listとは何か

Listは、配列と同じように複数のデータをまとめて管理できるコレクションです。

C#では、List<T>という形で使います。Tには、扱いたいデータの型を指定します。

C#
List<int> scores = new List<int>();

scores.Add(80);
scores.Add(90);
scores.Add(70);

この例では、int型の値を入れられるListを作成しています。

Listの大きな特徴は、要素数を後から自由に増やしたり減らしたりできることです。要素を追加するときはAdd、削除するときはRemoveやRemoveAtを使います。

Listを使うには、基本的に次のusingが必要です。

C#
using System.Collections.Generic;

1-3. Listと配列がよく使われる場面

C#の配列は、要素数が決まっているデータを扱うときによく使われます。

たとえば、曜日、月、固定された設定値、あらかじめ数が決まっているデータなどです。

C#
string[] days = { "月", "火", "水", "木", "金", "土", "日" };

一方、Listは要素数が変わるデータを扱うときによく使われます。

たとえば、ユーザーが入力した名前の一覧、検索結果、買い物かごの商品一覧、ゲーム内のアイテム一覧などです。

C#
List<string> items = new List<string>();

items.Add("りんご");
items.Add("バナナ");
items.Add("みかん");

このように、C#では「固定されたデータは配列」「増減するデータはList」という考え方が基本になります。

1-4. 初心者が混同しやすいポイント

初心者が混同しやすいのは、配列もListも「複数のデータをまとめて扱える」という点が似ているからです。

どちらも次のように、インデックスを使って要素にアクセスできます。

C#
int[] array = { 10, 20, 30 };
Console.WriteLine(array[0]);

List<int> list = new List<int> { 10, 20, 30 };
Console.WriteLine(list[0]);

どちらも[0]で最初の要素を取得できます。

ただし、配列は要素数が固定、Listは要素数を変更できるという違いがあります。また、配列の要素数はLengthで取得し、Listの要素数はCountで取得します。

C#
Console.WriteLine(array.Length);
Console.WriteLine(list.Count);

このLengthとCountの違いも、初心者がよく間違えるポイントです。

2. C#のListと配列の違い

2-1. 要素数を変更できるかどうか

C#のListと配列の最も大きな違いは、要素数を変更できるかどうかです。

配列は、作成した時点で要素数が決まります。

C#
int[] numbers = new int[3];

この配列には、3つの要素しか入れられません。後から4つ目の要素を直接追加することはできません。

一方、Listは後から要素を追加できます。

C#
List<int> numbers = new List<int>();

numbers.Add(10);
numbers.Add(20);
numbers.Add(30);
numbers.Add(40);

このように、Listは必要に応じてデータを増やせるため、要素数が変わる場面に向いています。

2-2. 要素の追加・削除のしやすさ

配列は要素の追加や削除が苦手です。

配列の中身を変更することはできますが、配列そのもののサイズを簡単に変えることはできません。

C#
int[] numbers = { 10, 20, 30 };
numbers[1] = 99;

このように、既存の要素を変更することはできます。しかし、新しい要素を追加するには、新しい配列を作り直す必要があります。

一方、Listでは要素の追加や削除が簡単です。

C#
List<int> numbers = new List<int> { 10, 20, 30 };

numbers.Add(40);
numbers.Remove(20);
numbers.RemoveAt(0);

Addで追加、Removeで値を指定して削除、RemoveAtでインデックスを指定して削除できます。

2-3. メモリと処理速度の違い

配列は要素数が固定されているため、構造がシンプルです。そのため、単純なデータアクセスでは配列のほうが少し速い場合があります。

一方、Listは内部的に配列を使ってデータを管理しています。Listは要素を追加できるようにするため、内部で容量を調整する仕組みを持っています。

そのため、Listは配列より少しだけ仕組みが複雑です。ただし、通常のアプリケーション開発では、Listと配列の速度差を気にする場面はそれほど多くありません。

初心者のうちは、速度よりも「要素数が固定か、変わるか」で選ぶほうがわかりやすいです。

2-4. 書き方・使いやすさの違い

配列はシンプルに書けます。

C#
string[] names = { "田中", "佐藤", "鈴木" };

Listも初期化時に値を入れられます。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

ListはAdd、Remove、Contains、Find、Sortなど便利なメソッドが多いため、データを操作しやすいです。

C#
names.Add("高橋");
names.Remove("佐藤");
bool exists = names.Contains("田中");

配列は軽量でシンプル、Listは柔軟で使いやすい、という違いがあります。

2-5. Listと配列の違いを比較表で整理

C#でListと配列のどちらを使うか迷ったら、まずは要素数が変わるかどうかを考えましょう。

3. C#で配列を使う方法

3-1. 配列の宣言と初期化

C#で配列を宣言するには、型の後ろに[]を付けます。

C#
int[] numbers;

配列を作成するには、newを使います。

C#
int[] numbers = new int[3];

この場合、3つの整数を入れられる配列が作られます。

最初から値を入れて初期化することもできます。

C#
int[] numbers = { 10, 20, 30 };

文字列の配列なら、次のように書きます。

C#
string[] names = { "田中", "佐藤", "鈴木" };

配列では、すべての要素が同じ型である必要があります。int[]には整数、string[]には文字列を入れます。

3-2. 配列の要素を取得・変更する方法

配列の要素には、インデックスを使ってアクセスします。

インデックスは0から始まります。

C#
string[] names = { "田中", "佐藤", "鈴木" };

Console.WriteLine(names[0]);
Console.WriteLine(names[1]);
Console.WriteLine(names[2]);

実行結果は次のようになります。

C#
田中
佐藤
鈴木

配列の要素を変更するには、インデックスを指定して新しい値を代入します。

C#
names[1] = "高橋";

Console.WriteLine(names[1]);

この場合、佐藤が高橋に変更されます。

3-3. 配列をforeachでループ処理する方法

配列のすべての要素を順番に処理したい場合は、foreachを使うと便利です。

C#
string[] names = { "田中", "佐藤", "鈴木" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

foreachを使うと、配列の要素数を意識せずに、すべての要素を順番に取り出せます。

インデックスが必要な場合は、for文を使います。

C#
for (int i = 0; i < names.Length; i++)
{
    Console.WriteLine($"{i}: {names[i]}");
}

配列の要素数を取得するときは、Lengthを使います。

3-4. 配列を使うメリット

配列を使うメリットは、構造がシンプルでわかりやすいことです。

要素数が決まっているデータを扱う場合、配列はとても便利です。

たとえば、曜日のように数が変わらないデータは配列に向いています。

C#
string[] days = { "月", "火", "水", "木", "金", "土", "日" };

配列はC#の基本的なデータ構造なので、他の機能やライブラリでもよく登場します。また、配列はListよりもシンプルなため、基本を学ぶにはよい題材です。

3-5. 配列を使うときの注意点

配列を使うときの注意点は、要素数を後から変更できないことです。

次のような配列を作った場合、要素は3つだけです。

C#
int[] numbers = new int[3];

存在しない4番目の要素にアクセスしようとすると、エラーになります。

C#
numbers[3] = 40;

配列のインデックスは0から始まるため、要素数が3の場合に使えるインデックスは0、1、2です。3を指定すると範囲外になります。

また、配列は要素の追加や削除が苦手です。データの数が変わる可能性がある場合は、Listを使うほうが扱いやすいです。

4. C#でListを使う方法

4-1. Listの宣言と初期化

C#でListを使うには、まず次のusingを追加します。

C#
using System.Collections.Generic;

Listは次のように宣言します。

C#
List<int> numbers = new List<int>();

この例では、整数を入れられるListを作成しています。

最初から値を入れて初期化することもできます。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

最近のC#では、型推論を使って次のように書くこともできます。

C#
var names = new List<string> { "田中", "佐藤", "鈴木" };

varを使っても、namesはList<string>として扱われます。

4-2. Listに要素を追加する方法

Listに要素を追加するには、Addメソッドを使います。

C#
List<string> names = new List<string>();

names.Add("田中");
names.Add("佐藤");
names.Add("鈴木");

複数の要素をまとめて追加したい場合は、AddRangeを使います。

C#
List<string> names = new List<string>();

names.AddRange(new string[] { "田中", "佐藤", "鈴木" });

Listは要素数が自動的に増えるため、配列よりも追加処理が簡単です。

4-3. Listの要素を削除する方法

Listの要素を削除するには、RemoveやRemoveAtを使います。

Removeは、指定した値を削除します。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

names.Remove("佐藤");

この場合、佐藤が削除されます。

RemoveAtは、指定したインデックスの要素を削除します。

C#
names.RemoveAt(0);

この場合、先頭の要素が削除されます。

すべての要素を削除したい場合は、Clearを使います。

C#
names.Clear();

条件に一致する要素を削除したい場合は、RemoveAllが便利です。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

numbers.RemoveAll(n => n % 2 == 0);

この例では、偶数の要素を削除しています。

4-4. Listの要素を検索・取得する方法

Listの要素を取得するには、配列と同じようにインデックスを使います。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

Console.WriteLine(names[0]);

特定の値が含まれているか調べるには、Containsを使います。

C#
bool exists = names.Contains("佐藤");

条件に一致する最初の要素を取得したい場合は、Findを使います。

C#
List<int> numbers = new List<int> { 10, 20, 30, 40 };

int result = numbers.Find(n => n > 25);

Console.WriteLine(result);

この例では、25より大きい最初の値である30が取得されます。

4-5. Listをforeachでループ処理する方法

Listも配列と同じように、foreachでループ処理できます。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

インデックスを使いたい場合は、for文を使います。

C#
for (int i = 0; i < names.Count; i++)
{
    Console.WriteLine($"{i}: {names[i]}");
}

Listの要素数を取得するときは、LengthではなくCountを使います。

4-6. Listを使うメリット

Listを使うメリットは、要素の追加や削除が簡単なことです。

配列ではサイズが固定されますが、Listならデータの数が変わっても柔軟に対応できます。

C#
List<string> tasks = new List<string>();

tasks.Add("メール確認");
tasks.Add("資料作成");
tasks.Add("会議");

tasks.Remove("会議");

このように、タスク一覧や商品一覧、検索結果など、データが増えたり減ったりする場面ではListが便利です。

また、Listには便利なメソッドが多く用意されています。

C#
tasks.Contains("資料作成");
tasks.Sort();
tasks.Clear();

初心者が実用的なプログラムを書くときは、Listを使う場面が非常に多いです。

4-7. Listを使うときの注意点

Listは便利ですが、注意点もあります。

まず、Listを使うにはSystem.Collections.Genericが必要です。

C#
using System.Collections.Generic;

これを書き忘れると、環境によってはList<>が見つからないというエラーになることがあります。

また、Listでも存在しないインデックスにアクセスするとエラーになります。

C#
List<int> numbers = new List<int> { 10, 20, 30 };

Console.WriteLine(numbers[3]);

このListの要素数は3つなので、使えるインデックスは0、1、2です。3を指定すると範囲外エラーになります。

Listは要素数を変更できますが、インデックスの範囲には注意が必要です。

5. C#のListと配列の使い分け

5-1. 配列を使うべきケース

配列を使うべきケースは、要素数があらかじめ決まっている場合です。

たとえば、次のようなデータは配列に向いています。

C#
string[] weekDays = { "月", "火", "水", "木", "金", "土", "日" };

曜日は7つで固定されているため、配列で管理しやすいです。

他にも、座標データ、固定された設定値、あらかじめ件数が決まっているデータなどは配列が向いています。

C#
int[] rgb = { 255, 128, 0 };

このように、データの数が変わらない場合は配列を選ぶとよいでしょう。

5-2. Listを使うべきケース

Listを使うべきケースは、要素数が後から変わる場合です。

たとえば、ユーザーが入力した名前を追加していくような処理ではListが向いています。

C#
List<string> users = new List<string>();

users.Add("田中");
users.Add("佐藤");
users.Add("鈴木");

検索結果、注文商品、コメント一覧、ログ、ゲーム内アイテムなど、データが増えたり減ったりするものはListで扱うと便利です。

C#
List<string> cartItems = new List<string>();

cartItems.Add("ノートPC");
cartItems.Add("マウス");
cartItems.Remove("マウス");

Listは追加や削除を前提にしたデータ管理に向いています。

5-3. 要素数が固定なら配列を選ぶ

要素数が固定なら、配列を選ぶのが基本です。

C#
int[] points = new int[5];

このように、最初から5つのデータを扱うことが決まっているなら、配列で十分です。

配列はシンプルで、余計な操作を必要としません。データの数が変わらないなら、Listを使わなくても問題ありません。

5-4. 要素数が変わるならListを選ぶ

要素数が変わるなら、Listを選びましょう。

C#
List<int> points = new List<int>();

points.Add(80);
points.Add(90);
points.Add(70);

後からデータを追加したり削除したりするなら、Listのほうが圧倒的に扱いやすいです。

配列でも新しい配列を作り直せば要素数を変えるような処理はできますが、初心者には複雑です。Listを使えば、AddやRemoveで簡単に操作できます。

5-5. 初心者はどちらから使えばよいか

初心者は、まず配列で「複数のデータをまとめる考え方」を学び、その後にListを使うのがおすすめです。

配列を学ぶと、インデックス、要素数、ループ処理などの基本が理解できます。

C#
string[] names = { "田中", "佐藤", "鈴木" };

そのうえでListを学ぶと、追加や削除ができる便利なコレクションとして理解しやすくなります。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };
names.Add("高橋");

実務ではListを使う場面が多いため、最終的にはListをしっかり使えるようになることが大切です。

5-6. 実務でよくある使い分け例

実務では、配列とListを次のように使い分けることが多いです。

固定の選択肢を扱う場合は配列を使います。

C#
string[] roles = { "管理者", "一般ユーザー", "ゲスト" };

ユーザー一覧のように増減するデータはListを使います。

C#
List<string> users = new List<string>();

users.Add("user001");
users.Add("user002");

APIから取得したデータをいったんListで受け取り、必要に応じて配列に変換することもあります。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

string[] nameArray = names.ToArray();

実務では、「データの数が変わるか」「追加・削除が必要か」「他のメソッドが配列を要求しているか」を考えて使い分けます。

6. C#でListと配列を変換する方法

6-1. 配列からListに変換する方法

C#では、配列からListに変換できます。

代表的な方法は、ToListを使う方法です。

C#
using System.Collections.Generic;
using System.Linq;

string[] array = { "田中", "佐藤", "鈴木" };

List<string> list = array.ToList();

ToListを使うには、基本的に次のusingが必要です。

C#
using System.Linq;

また、Listのコンストラクターに配列を渡して変換することもできます。

C#
string[] array = { "田中", "佐藤", "鈴木" };

List<string> list = new List<string>(array);

この方法なら、LINQを使わずに配列からListを作成できます。

6-2. Listから配列に変換する方法

Listから配列に変換するには、ToArrayを使います。

C#
List<string> list = new List<string> { "田中", "佐藤", "鈴木" };

string[] array = list.ToArray();

ToArrayを使うと、Listの中身を配列として取得できます。

メソッドの引数が配列を要求している場合などに便利です。

C#
void PrintNames(string[] names)
{
    foreach (string name in names)
    {
        Console.WriteLine(name);
    }
}

List<string> list = new List<string> { "田中", "佐藤", "鈴木" };

PrintNames(list.ToArray());

6-3. ToListメソッドの使い方

ToListは、配列などのコレクションをListに変換するメソッドです。

C#
using System.Linq;

int[] numbers = { 1, 2, 3, 4, 5 };

List<int> numberList = numbers.ToList();

ToListを使うと、配列の中身をもとに新しいListが作られます。

変換後のListに要素を追加しても、元の配列の要素数が増えるわけではありません。

C#
int[] array = { 1, 2, 3 };

List<int> list = array.ToList();

list.Add(4);

Console.WriteLine(array.Length);
Console.WriteLine(list.Count);

この場合、配列の要素数は3、Listの要素数は4になります。

6-4. ToArrayメソッドの使い方

ToArrayは、Listを配列に変換するメソッドです。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = list.ToArray();

ToArrayを使うと、Listの中身をもとに新しい配列が作られます。

変換後にListへ要素を追加しても、すでに作られた配列には反映されません。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = list.ToArray();

list.Add(4);

Console.WriteLine(array.Length);
Console.WriteLine(list.Count);

この場合、配列の要素数は3、Listの要素数は4になります。

6-5. 変換時によくあるエラーと対処法

配列からListへ変換するときによくあるエラーは、ToListが使えないというものです。

C#
string[] array = { "A", "B", "C" };

List<string> list = array.ToList();

このコードでエラーになる場合は、using System.Linq;が書かれていない可能性があります。

C#
using System.Linq;

また、Listを使うには次のusingも必要です。

C#
using System.Collections.Generic;

型が一致しないエラーにも注意が必要です。

C#
int[] numbers = { 1, 2, 3 };

// List<string> list = numbers.ToList(); // エラー

int[]をList<string>に直接変換することはできません。int[]を変換するなら、List<int>にする必要があります。

C#
List<int> list = numbers.ToList();

7. Listと配列でよく使う便利な処理

7-1. 要素数を取得する方法

配列の要素数を取得するには、Lengthを使います。

C#
int[] array = { 10, 20, 30 };

Console.WriteLine(array.Length);

Listの要素数を取得するには、Countを使います。

C#
List<int> list = new List<int> { 10, 20, 30 };

Console.WriteLine(list.Count);

初心者は、配列にCount、ListにLengthを使おうとしてエラーになることがあります。

基本は次のように覚えましょう。

C#
配列は Length
Listは Count

7-2. 特定の値を検索する方法

配列で特定の値が含まれているか調べるには、LINQのContainsを使えます。

C#
using System.Linq;

int[] array = { 10, 20, 30 };

bool exists = array.Contains(20);

ListでもContainsを使えます。

C#
List<int> list = new List<int> { 10, 20, 30 };

bool exists = list.Contains(20);

特定の値が含まれていればtrue、含まれていなければfalseになります。

7-3. 並び替えする方法

Listを並び替えるには、Sortを使います。

C#
List<int> numbers = new List<int> { 30, 10, 20 };

numbers.Sort();

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

実行結果は、10、20、30の順になります。

配列を並び替えるには、Array.Sortを使います。

C#
int[] numbers = { 30, 10, 20 };

Array.Sort(numbers);

文字列も並び替えできます。

C#
string[] names = { "Suzuki", "Tanaka", "Sato" };

Array.Sort(names);

7-4. 条件に一致する要素を取得する方法

Listで条件に一致する要素を取得するには、FindやFindAllを使えます。

C#
List<int> numbers = new List<int> { 10, 20, 30, 40 };

int result = numbers.Find(n => n >= 30);

Findは、条件に一致する最初の要素を返します。

条件に一致するすべての要素を取得したい場合は、FindAllを使います。

C#
List<int> results = numbers.FindAll(n => n >= 30);

配列の場合は、LINQのWhereを使うと便利です。

C#
using System.Linq;

int[] numbers = { 10, 20, 30, 40 };

int[] results = numbers.Where(n => n >= 30).ToArray();

7-5. LINQを使ったList・配列の操作

LINQを使うと、Listや配列をより簡潔に操作できます。

LINQを使うには、次のusingを追加します。

C#
using System.Linq;

たとえば、偶数だけを取り出す場合は次のように書けます。

C#
int[] numbers = { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

Listでも同じように使えます。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

結果をListにしたい場合はToList、配列にしたい場合はToArrayを使います。

C#
List<int> evenList = numbers.Where(n => n % 2 == 0).ToList();

int[] evenArray = numbers.Where(n => n % 2 == 0).ToArray();

LINQを使えるようになると、C#のListや配列の操作がかなり楽になります。

8. C#のListと配列で初心者がつまずきやすいエラー

8-1. インデックス範囲外エラー

C#のListや配列で初心者がよく遭遇するのが、インデックス範囲外エラーです。

配列やListのインデックスは0から始まります。

C#
int[] numbers = { 10, 20, 30 };

Console.WriteLine(numbers[0]);
Console.WriteLine(numbers[1]);
Console.WriteLine(numbers[2]);

要素数が3つの場合、最後のインデックスは2です。

次のように3を指定するとエラーになります。

C#
Console.WriteLine(numbers[3]);

Listでも同じです。

C#
List<int> numbers = new List<int> { 10, 20, 30 };

Console.WriteLine(numbers[3]);

エラーを防ぐには、要素数を確認してからアクセスします。

C#
if (numbers.Count > 0)
{
    Console.WriteLine(numbers[0]);
}

配列の場合はLengthを使います。

C#
if (numbers.Length > 0)
{
    Console.WriteLine(numbers[0]);
}

8-2. nullでつまずきやすいエラー

Listや配列の変数がnullのままになっていると、要素にアクセスしたときにエラーになります。

C#
List<string> names = null;

// names.Add("田中"); // エラー

この場合、namesにはListの実体が入っていません。Listを使う前に、newで作成する必要があります。

C#
List<string> names = new List<string>();

names.Add("田中");

配列でも同じです。

C#
string[] names = null;

// Console.WriteLine(names.Length); // エラー

配列を使う場合も、先に初期化しましょう。

C#
string[] names = new string[3];

8-3. 参照エラー

C#の配列やListは参照型として扱われます。そのため、別の変数に代入した場合、同じデータを参照することがあります。

C#
List<int> list1 = new List<int> { 1, 2, 3 };
List<int> list2 = list1;

list2[0] = 99;

Console.WriteLine(list1[0]);

この場合、list2を変更するとlist1にも影響します。なぜなら、list1とlist2が同じListを参照しているからです。

別のListとしてコピーしたい場合は、次のように新しいListを作ります。

C#
List<int> list1 = new List<int> { 1, 2, 3 };
List<int> list2 = new List<int>(list1);

list2[0] = 99;

Console.WriteLine(list1[0]);
Console.WriteLine(list2[0]);

配列の場合も同じように、単純に代入すると同じ配列を参照します。

C#
int[] array1 = { 1, 2, 3 };
int[] array2 = array1;

array2[0] = 99;

Console.WriteLine(array1[0]);

別の配列としてコピーしたい場合は、ToArrayなどを使います。

C#
int[] array1 = { 1, 2, 3 };
int[] array2 = array1.ToArray();

8-4. 型が一致しないエラー

Listや配列では、指定した型と違う値を入れることはできません。

C#
int[] numbers = new int[3];

// numbers[0] = "田中"; // エラー

int[]には整数しか入れられません。文字列を入れたい場合は、string[]を使います。

C#
string[] names = new string[3];

names[0] = "田中";

Listでも同じです。

C#
List<int> numbers = new List<int>();

// numbers.Add("田中"); // エラー

List<int>には整数しか追加できません。文字列を扱うならList<string>を使います。

C#
List<string> names = new List<string>();

names.Add("田中");

C#は型に厳しい言語なので、Listや配列の型を意識することが大切です。

8-5. using System.Collections.Genericが必要なケース

Listを使う場合は、通常、次のusingが必要です。

C#
using System.Collections.Generic;

これを書かずにListを使うと、環境によってはList<>が見つからないというエラーになることがあります。

C#
List<string> names = new List<string>();

エラーが出た場合は、ファイルの先頭にusingがあるか確認しましょう。

C#
using System;
using System.Collections.Generic;

また、ToListやWhereなどのLINQを使う場合は、次のusingも必要です。

C#
using System.Linq;

Listを使うときはSystem.Collections.Generic、LINQを使うときはSystem.Linqと覚えておくとよいでしょう。

8-6. エラーを防ぐための書き方

Listや配列のエラーを防ぐには、次のポイントを意識しましょう。

まず、要素にアクセスする前に、要素数を確認します。

C#
if (list.Count > 0)
{
    Console.WriteLine(list[0]);
}

配列の場合はLengthを使います。

C#
if (array.Length > 0)
{
    Console.WriteLine(array[0]);
}

次に、nullかどうかを確認します。

C#
if (list != null && list.Count > 0)
{
    Console.WriteLine(list[0]);
}

配列でも同じです。

C#
if (array != null && array.Length > 0)
{
    Console.WriteLine(array[0]);
}

また、Listや配列に入れる値の型を間違えないようにしましょう。

C#
List<int> numbers = new List<int>();
numbers.Add(10);

エラーを防ぐには、「nullではないか」「インデックスは範囲内か」「型は合っているか」を確認することが大切です。

9. C#のListと配列に関するよくある質問

9-1. Listと配列はどちらが速いのか

単純な要素アクセスだけで見ると、配列のほうが少し速い場合があります。配列は固定長で構造がシンプルだからです。

ただし、通常のアプリケーション開発では、Listと配列の速度差が問題になることはあまりありません。

初心者のうちは、速度よりも使い分けを優先しましょう。

要素数が固定なら配列、要素数が変わるならListです。

9-2. Listは配列の代わりに使えるのか

多くの場合、Listは配列の代わりに使えます。

Listでもインデックスを使って要素を取得できます。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

Console.WriteLine(names[0]);

ただし、メソッドの引数が配列を要求している場合は、Listをそのまま渡せないことがあります。

その場合は、ToArrayで配列に変換します。

C#
string[] array = names.ToArray();

Listは便利ですが、配列が必要な場面では変換が必要です。

9-3. 配列の要素数は後から変更できるのか

配列の要素数は、基本的に後から変更できません。

C#
int[] numbers = new int[3];

この配列は、3つの要素を持つ配列として作られます。後から直接4つに増やすことはできません。

どうしても要素数を変えたい場合は、新しい配列を作り直す必要があります。

C#
int[] oldArray = { 1, 2, 3 };
int[] newArray = new int[4];

for (int i = 0; i < oldArray.Length; i++)
{
    newArray[i] = oldArray[i];
}

newArray[3] = 4;

ただし、このような処理は手間がかかるため、要素数が変わる場合はListを使うほうが簡単です。

9-4. Listの中身を配列のように扱えるのか

Listの中身は、配列のようにインデックスで扱えます。

C#
List<int> numbers = new List<int> { 10, 20, 30 };

Console.WriteLine(numbers[0]);
numbers[1] = 99;

このように、list[0]のような書き方で要素を取得したり変更したりできます。

ただし、要素数の取得方法は配列と違います。

C#
Console.WriteLine(numbers.Count);

ListではLengthではなくCountを使います。

9-5. string配列とList<string>の違い

string[]は、文字列の配列です。

C#
string[] names = { "田中", "佐藤", "鈴木" };

要素数が固定されているため、後から簡単に追加することはできません。

一方、List<string>は文字列を扱うListです。

C#
List<string> names = new List<string> { "田中", "佐藤", "鈴木" };

names.Add("高橋");

List<string>なら、後から文字列を追加したり削除したりできます。

つまり、文字列の数が固定ならstring[]、増減するならList<string>を使うとよいでしょう。

まとめ

C#のListと配列は、どちらも複数のデータをまとめて扱うための仕組みです。

配列は、要素数が固定されているデータに向いています。

C#
int[] numbers = { 1, 2, 3 };

Listは、要素数が増えたり減ったりするデータに向いています。

C#
List<int> numbers = new List<int> { 1, 2, 3 };

numbers.Add(4);

C#のListと配列の大きな違いは、要素数を変更できるかどうかです。配列は固定長、Listは可変長です。

また、配列の要素数はLength、Listの要素数はCountで取得します。

C#
array.Length;
list.Count;

配列からListに変換するにはToList、Listから配列に変換するにはToArrayを使います。

C#
List<int> list = array.ToList();

int[] array = list.ToArray();

初心者のうちは、次のように覚えるとわかりやすいです。

要素数が決まっているなら配列、要素数が変わるならList。

この基本を押さえておけば、C#で複数のデータを扱うコードが書きやすくなります。