List

Java – Streamを使用したListのソート方法

2025-04-15更新日: 2025-04-15

JavaのStream APIを使用すると、リストを簡潔にソートできます。

stream()メソッドでリストをストリームに変換し、sorted()メソッドを使用してソートを行います。

sorted()はデフォルトの自然順序でソートするか、Comparatorを引数に指定してカスタム順序でソートできます。

最後にcollect(Collectors.toList())でソート結果をリストに変換します。

これにより、元のリストを変更せず新しいリストを取得できます。

目次から探す

Streamを使用したListのソート方法
特定のデータ型を持つListのソート
ソート結果の取得と元のリストの扱い
Stream APIを使用したソートの注意点
まとめ

Streamを使用したListのソート方法

JavaのStream APIを使用すると、コレクションの操作が非常に簡単になります。

特に、ListのソートはStreamを使うことで、より直感的に行うことができます。

このセクションでは、Streamを使用したListのソート方法について詳しく解説します。

特定のデータ型を持つListのソート

まずは、特定のデータ型を持つListをソートする方法を見ていきましょう。

以下のサンプルコードでは、整数のListを昇順にソートします。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        // 整数のListを作成
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2);
        
        // Streamを使用してListを昇順にソート
        List<Integer> sortedNumbers = numbers.stream()
            .sorted() // 昇順にソート
            .collect(Collectors.toList()); // Listに戻す
        
        // ソート結果を表示
        System.out.println(sortedNumbers);
    }
}

[1, 2, 3, 5, 8]

このコードでは、sorted()メソッドを使用してListを昇順にソートしています。

collect(Collectors.toList())を使って、Streamの結果を再びListに変換しています。

ソート結果の取得と元のリストの扱い

Streamを使用してソートを行う場合、元のリストは変更されません。

新しいリストが生成されるため、元のデータを保持したまま操作が可能です。

以下のサンプルコードでは、元のリストとソート後のリストを比較します。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        // 整数のListを作成
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2);
        
        // Streamを使用してListを昇順にソート
        List<Integer> sortedNumbers = numbers.stream()
            .sorted() // 昇順にソート
            .collect(Collectors.toList()); // Listに戻す
        
        // 元のリストとソート結果を表示
        System.out.println("元のリスト: " + numbers);
        System.out.println("ソート後のリスト: " + sortedNumbers);
    }
}

元のリスト: [5, 3, 8, 1, 2]
ソート後のリスト: [1, 2, 3, 5, 8]

このように、元のリストはそのまま残り、ソートされた新しいリストが生成されます。

Stream APIを使用したソートの注意点

Stream APIを使用する際の注意点として、以下の点が挙げられます。

注意点	説明
不変性	元のリストは変更されず、新しいリストが生成される。
パフォーマンス	大きなデータセットでは、パフォーマンスに影響が出ることがある。
並列処理の利用	`parallelStream()`を使用することで、並列処理が可能。

これらの注意点を理解しておくことで、より効果的にStream APIを活用することができます。

特定のデータ型を持つListのソート

特定のデータ型を持つListをソートする際、JavaのStream APIを利用することで、簡潔かつ効率的に実現できます。

ここでは、整数型、文字列型、カスタムオブジェクト型のListをそれぞれソートする方法を解説します。

整数型のListをソートする

整数型のListを昇順にソートする基本的な方法を見てみましょう。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        // 整数のListを作成
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2);
        
        // Streamを使用してListを昇順にソート
        List<Integer> sortedNumbers = numbers.stream()
            .sorted() // 昇順にソート
            .collect(Collectors.toList()); // Listに戻す
        
        // ソート結果を表示
        System.out.println(sortedNumbers);
    }
}

[1, 2, 3, 5, 8]

このコードでは、sorted()メソッドを使用して整数のListを昇順にソートしています。

文字列型のListをソートする

次に、文字列型のListをソートする方法を見てみましょう。

文字列のソートは、アルファベット順に行われます。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        // 文字列のListを作成
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        
        // Streamを使用してListを昇順にソート
        List<String> sortedNames = names.stream()
            .sorted() // 昇順にソート
            .collect(Collectors.toList()); // Listに戻す
        
        // ソート結果を表示
        System.out.println(sortedNames);
    }
}

[Alice, Bob, Charlie, David]

このコードでは、文字列のListをアルファベット順にソートしています。

カスタムオブジェクト型のListをソートする

カスタムオブジェクト型のListをソートする場合、Comparatorを使用して特定のフィールドに基づいてソートすることができます。

以下の例では、Personクラスを作成し、年齢に基づいてソートします。

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}
public class App {
    public static void main(String[] args) {
        // PersonオブジェクトのListを作成
        List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );
        
        // 年齢に基づいてListを昇順にソート
        List<Person> sortedPeople = people.stream()
            .sorted(Comparator.comparingInt(person -> person.age)) // 年齢でソート
            .collect(Collectors.toList()); // Listに戻す
        
        // ソート結果を表示
        System.out.println(sortedPeople);
    }
}

[Bob (25), Alice (30), Charlie (35)]

このコードでは、Comparator.comparingInt()を使用して、Personオブジェクトの年齢に基づいてListを昇順にソートしています。

特定のデータ型を持つListのソートは、Stream APIを使用することで簡単に実現できます。

整数型、文字列型、カスタムオブジェクト型のそれぞれに対して、適切な方法を選択することで、効率的にデータを整理することが可能です。

ソート結果の取得と元のリストの扱い

JavaのStream APIを使用してListをソートする際、元のリストは変更されず、新しいリストが生成されるという特性があります。

このセクションでは、ソート結果の取得方法と元のリストの扱いについて詳しく解説します。

元のリストを保持する

Streamを使用してListをソートする場合、元のリストはそのまま保持されます。

これにより、元のデータを失うことなく、ソートされた結果を得ることができます。

以下のサンプルコードでは、元のリストとソート後のリストを比較して表示します。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        // 整数のListを作成
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2);
        
        // Streamを使用してListを昇順にソート
        List<Integer> sortedNumbers = numbers.stream()
            .sorted() // 昇順にソート
            .collect(Collectors.toList()); // Listに戻す
        
        // 元のリストとソート結果を表示
        System.out.println("元のリスト: " + numbers);
        System.out.println("ソート後のリスト: " + sortedNumbers);
    }
}

元のリスト: [5, 3, 8, 1, 2]
ソート後のリスト: [1, 2, 3, 5, 8]

このコードでは、元のリストnumbersはそのまま残り、ソートされた新しいリストsortedNumbersが生成されています。

ソート結果の取得方法

ソート結果を取得する際は、collect(Collectors.toList())を使用してStreamの結果をListに変換します。

これにより、ソートされたデータを新しいListとして取得できます。

以下のサンプルコードでは、文字列型のListをソートし、結果を取得します。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        // 文字列のListを作成
        List<String> names = Arrays.asList("Charlie", "Alice", "Bob", "David");
        
        // Streamを使用してListを昇順にソート
        List<String> sortedNames = names.stream()
            .sorted() // 昇順にソート
            .collect(Collectors.toList()); // Listに戻す
        
        // ソート結果を表示
        System.out.println("ソート後のリスト: " + sortedNames);
    }
}

ソート後のリスト: [Alice, Bob, Charlie, David]

このように、sorted()メソッドを使用してソートを行い、collect(Collectors.toList())で結果を取得しています。

元のリストを変更したい場合

元のリストを変更したい場合は、Listのsort()メソッドを使用することができます。

この方法では、元のリスト自体がソートされます。

以下のサンプルコードでは、元のリストを直接ソートしています。

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class App {
    public static void main(String[] args) {
        // 整数のListを作成
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2);
        
        // 元のリストを昇順にソート
        Collections.sort(numbers); // 元のリストを直接ソート
        
        // ソート結果を表示
        System.out.println("ソート後のリスト: " + numbers);
    }
}

ソート後のリスト: [1, 2, 3, 5, 8]

このコードでは、Collections.sort()を使用して元のリストnumbersを直接ソートしています。

Stream APIを使用したListのソートでは、元のリストは変更されず、新しいリストが生成されるため、データの整合性を保ちながら操作が可能です。

元のリストを変更したい場合は、Collections.sort()を使用することで、直接ソートすることもできます。

これにより、用途に応じた柔軟なデータ操作が実現できます。

Stream APIを使用したソートの注意点

JavaのStream APIを使用してListをソートする際には、いくつかの注意点があります。

これらを理解しておくことで、より効果的にStreamを活用し、意図した通りの結果を得ることができます。

このセクションでは、主な注意点を解説します。

不変性

Streamを使用してListをソートする場合、元のリストは変更されず、新しいリストが生成されます。

この特性は、データの整合性を保つ上で非常に重要です。

元のリストを保持したまま、ソートされた結果を得ることができるため、データの損失を防ぐことができます。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class App {
    public static void main(String[] args) {
        // 整数のListを作成
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2);
        
        // Streamを使用してListを昇順にソート
        List<Integer> sortedNumbers = numbers.stream()
            .sorted() // 昇順にソート
            .collect(Collectors.toList()); // Listに戻す
        
        // 元のリストとソート結果を表示
        System.out.println("元のリスト: " + numbers);
        System.out.println("ソート後のリスト: " + sortedNumbers);
    }
}

元のリスト: [5, 3, 8, 1, 2]
ソート後のリスト: [1, 2, 3, 5, 8]

パフォーマンス

大きなデータセットを扱う場合、Stream APIの使用はパフォーマンスに影響を与えることがあります。

特に、非常に大きなリストをソートする際には、メモリ使用量や処理時間が増加する可能性があります。

パフォーマンスが重要な場合は、必要に応じて並列処理を検討することが有効です。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class App {
    public static void main(String[] args) {
        // 大きな整数のListを作成
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2, 7, 4, 6, 9, 0);

        // Streamを使用してListを昇順にソート(並列処理)
        List<Integer> sortedNumbers = numbers.parallelStream()
                .sorted() // 昇順にソート
                .collect(Collectors.toList()); // Listに戻す

        // ソート結果を表示
        System.out.println("ソート後のリスト: " + sortedNumbers);
    }
}

ソート後のリスト: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

並列処理の利用

Stream APIでは、parallelStream()を使用することで、並列処理を行うことができます。

これにより、複数のスレッドを使用してデータを処理することができ、パフォーマンスの向上が期待できます。

ただし、並列処理を使用する際は、スレッドセーフであることや、データの整合性に注意が必要です。

ソートの安定性

Stream APIのsorted()メソッドは、安定ソートを提供します。

つまり、同じ値を持つ要素の順序は、元のリストの順序を保持します。

これにより、特定の条件でソートを行う際に、元の順序を維持することができます。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.Comparator;

public class App {
    public static void main(String[] args) {
        // PersonオブジェクトのListを作成
        List<Person> people = Arrays.asList(
                new Person("Alice", 30),
                new Person("Bob", 25),
                new Person("Charlie", 25));

        // 年齢に基づいてListを昇順にソート
        List<Person> sortedPeople = people.stream()
                .sorted(Comparator.comparingInt(person -> person.age)) // 年齢でソート
                .collect(Collectors.toList()); // Listに戻す

        // ソート結果を表示
        System.out.println(sortedPeople);
    }
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}