0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@kotaro_ai_lab

【Java研修】新入社員向けコーディング問題⑩ コレクションと Stream API 編

0
Last updated at Posted at 2026-02-15

はじめに

Java研修コーディング問題集の 最終回 は コレクションと Stream API です。

List, Map, Set といったコレクションフレームワークと、Java 8で導入された Stream API は、実務で最も頻繁に使う機能です。しっかり使いこなせるようにしましょう。

難易度の見方

マーク 難易度 目安
⭐ 基本 研修1週目レベル
⭐⭐ 応用 少し考える必要あり
⭐⭐⭐ チャレンジ 複数の知識を組み合わせる

問題1：ArrayList の基本操作 ⭐

問題

ArrayList<String> を使って、以下の操作を行ってください。

  1. "Java", "Python", "JavaScript", "Go", "Rust" を追加
  2. リストの内容とサイズを表示
  3. "Python" を削除
  4. 先頭に "C++" を挿入
  5. 最終的なリストを表示

期待する出力

リスト: [Java, Python, JavaScript, Go, Rust]
サイズ: 5
"Python"を削除 → [Java, JavaScript, Go, Rust]
先頭に"C++"を挿入 → [C++, Java, JavaScript, Go, Rust]
模範解答 
import java.util.ArrayList;

public class Exercise01 {
    public static void main(String[] args) {
        ArrayList<String> languages = new ArrayList<>();
        languages.add("Java");
        languages.add("Python");
        languages.add("JavaScript");
        languages.add("Go");
        languages.add("Rust");

        System.out.println("リスト: " + languages);
        System.out.println("サイズ: " + languages.size());

        languages.remove("Python");
        System.out.println("\"Python\"を削除 → " + languages);

        languages.add(0, "C++");
        System.out.println("先頭に\"C++\"を挿入 → " + languages);
    }
}

ポイント: ArrayList は配列と異なり、サイズを動的に変更できます。add(), remove(), get(), size() が基本的な操作です。<String> はジェネリクスで、格納する型を指定します。

問題2：HashMap の基本操作 ⭐

問題

HashMap<String, Integer> を使って、果物の在庫管理を行ってください。

  1. りんご:30, バナナ:15, みかん:50, ぶどう:10 を登録
  2. 全データを表示
  3. バナナの在庫を25に更新
  4. ぶどうを削除
  5. 特定のキーが存在するかチェック

期待する出力

=== 果物在庫 ===
りんご: 30個
バナナ: 15個
みかん: 50個
ぶどう: 10個

バナナの在庫を25に更新
ぶどうを削除

=== 更新後 ===
りんご: 30個
バナナ: 25個
みかん: 50個

"バナナ" は存在する: true
"メロン" は存在する: false
模範解答 
import java.util.LinkedHashMap;
import java.util.Map;

public class Exercise02 {
    public static void main(String[] args) {
        Map<String, Integer> stock = new LinkedHashMap<>();
        stock.put("りんご", 30);
        stock.put("バナナ", 15);
        stock.put("みかん", 50);
        stock.put("ぶどう", 10);

        System.out.println("=== 果物在庫 ===");
        for (Map.Entry<String, Integer> entry : stock.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue() + "個");
        }

        System.out.println("\nバナナの在庫を25に更新");
        stock.put("バナナ", 25);

        System.out.println("ぶどうを削除");
        stock.remove("ぶどう");

        System.out.println("\n=== 更新後 ===");
        for (Map.Entry<String, Integer> entry : stock.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue() + "個");
        }

        System.out.println("\n\"バナナ\" は存在する: " + stock.containsKey("バナナ"));
        System.out.println("\"メロン\" は存在する: " + stock.containsKey("メロン"));
    }
}

ポイント: Map はキーと値のペアでデータを管理します。put() で追加・更新、get() で取得、remove() で削除、containsKey() でキーの存在チェックができます。HashMap は順序を保証しませんが、LinkedHashMap は挿入順を保持します。

問題3：Set で重複排除 ⭐

問題

以下の配列から重複を取り除いた結果を HashSet で取得してください。

{"Java", "Python", "Java", "Go", "Python", "Rust", "Java", "Go"}

期待する出力

元の配列: [Java, Python, Java, Go, Python, Rust, Java, Go]
要素数: 8

重複排除後: [Java, Python, Go, Rust]
要素数: 4
模範解答 
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class Exercise03 {
    public static void main(String[] args) {
        String[] arr = {"Java", "Python", "Java", "Go", "Python", "Rust", "Java", "Go"};
        List<String> list = Arrays.asList(arr);

        System.out.println("元の配列: " + list);
        System.out.println("要素数: " + list.size());

        // LinkedHashSetで順序を保持しつつ重複排除
        Set<String> uniqueSet = new LinkedHashSet<>(list);

        System.out.println("\n重複排除後: " + uniqueSet);
        System.out.println("要素数: " + uniqueSet.size());
    }
}

ポイント: Set は重複を許さないコレクションです。HashSet は順序なし、LinkedHashSet は挿入順を保持、TreeSet はソート済みです。コレクションのコンストラクタに別のコレクションを渡すだけで変換できます。

問題4：List のソートと検索 ⭐⭐

問題

社員名簿をリストで管理し、名前順ソートと条件検索を行ってください。

期待する出力

=== 社員名簿 ===
元の順: [田中, 鈴木, 佐藤, 高橋, 伊藤]
名前順: [伊藤, 佐藤, 高橋, 田中, 鈴木]
逆順:   [鈴木, 田中, 高橋, 佐藤, 伊藤]

"佐藤" はリストに含まれる: true
"山田" はリストに含まれる: false
"佐藤" の位置（ソート後）: 1
模範解答 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Exercise04 {
    public static void main(String[] args) {
        List<String> employees = new ArrayList<>();
        employees.add("田中");
        employees.add("鈴木");
        employees.add("佐藤");
        employees.add("高橋");
        employees.add("伊藤");

        System.out.println("=== 社員名簿 ===");
        System.out.println("元の順: " + employees);

        Collections.sort(employees);
        System.out.println("名前順: " + employees);

        Collections.sort(employees, Collections.reverseOrder());
        System.out.println("逆順:   " + employees);

        System.out.println();
        System.out.println("\"佐藤\" はリストに含まれる: " + employees.contains("佐藤"));
        System.out.println("\"山田\" はリストに含まれる: " + employees.contains("山田"));

        Collections.sort(employees);
        System.out.println("\"佐藤\" の位置（ソート後）: " + employees.indexOf("佐藤"));
    }
}

ポイント: Collections.sort() でリストをソートできます。Comparable を実装した型（Stringは実装済み）は自然順序でソートされます。contains() で要素の存在チェック、indexOf() でインデックスの取得ができます。

問題5：Stream API の基本 ⭐⭐

問題

整数のリスト [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] に対して、Stream API を使って以下の処理を行ってください。

  1. 偶数のみフィルタリング
  2. 各要素を2倍に変換
  3. 合計を計算
  4. 最大値・最小値を取得

期待する出力

元のリスト: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

偶数のみ: [2, 4, 6, 8, 10]
各要素を2倍: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
合計: 55
最大値: 10
最小値: 1
模範解答 
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Exercise05 {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        System.out.println("元のリスト: " + numbers);

        // 偶数のみフィルタリング
        List<Integer> evens = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        System.out.println("\n偶数のみ: " + evens);

        // 各要素を2倍
        List<Integer> doubled = numbers.stream()
            .map(n -> n * 2)
            .collect(Collectors.toList());
        System.out.println("各要素を2倍: " + doubled);

        // 合計
        int sum = numbers.stream()
            .mapToInt(Integer::intValue)
            .sum();
        System.out.println("合計: " + sum);

        // 最大値・最小値
        int max = numbers.stream().mapToInt(Integer::intValue).max().orElse(0);
        int min = numbers.stream().mapToInt(Integer::intValue).min().orElse(0);
        System.out.println("最大値: " + max);
        System.out.println("最小値: " + min);
    }
}

ポイント: Stream API は filter（フィルタ）、map（変換）、reduce（集約）の3つの操作が基本です。collect() で結果をリストに変換します。メソッド参照（Integer::intValue）はラムダ式の簡略表記です。

問題6：Stream API でオブジェクトの処理 ⭐⭐

問題

社員リストに対して Stream API を使って各種集計を行ってください。

期待する出力

=== 社員データ ===
田中太郎 (30歳, 営業部, 450万円)
鈴木花子 (25歳, 開発部, 500万円)
佐藤次郎 (35歳, 営業部, 550万円)
高橋美咲 (28歳, 開発部, 480万円)
伊藤健太 (32歳, 人事部, 420万円)
山田優子 (27歳, 開発部, 520万円)

--- 集計結果 ---
30歳以上: [田中太郎, 佐藤次郎, 伊藤健太]
開発部のメンバー: [鈴木花子, 高橋美咲, 山田優子]
年収の平均: 486.7万円
年収が最も高い人: 佐藤次郎（550万円）
部署別の人数: {人事部=1, 営業部=2, 開発部=3}
模範解答 
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Employee {
    String name;
    int age;
    String department;
    int salary;  // 万円

    Employee(String name, int age, String department, int salary) {
        this.name = name;
        this.age = age;
        this.department = department;
        this.salary = salary;
    }
}

public class Exercise06 {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("田中太郎", 30, "営業部", 450),
            new Employee("鈴木花子", 25, "開発部", 500),
            new Employee("佐藤次郎", 35, "営業部", 550),
            new Employee("高橋美咲", 28, "開発部", 480),
            new Employee("伊藤健太", 32, "人事部", 420),
            new Employee("山田優子", 27, "開発部", 520)
        );

        System.out.println("=== 社員データ ===");
        employees.forEach(e ->
            System.out.println(e.name + " (" + e.age + "歳, " + e.department + ", " + e.salary + "万円)")
        );

        System.out.println("\n--- 集計結果 ---");

        // 30歳以上
        List<String> over30 = employees.stream()
            .filter(e -> e.age >= 30)
            .map(e -> e.name)
            .collect(Collectors.toList());
        System.out.println("30歳以上: " + over30);

        // 開発部のメンバー
        List<String> devMembers = employees.stream()
            .filter(e -> e.department.equals("開発部"))
            .map(e -> e.name)
            .collect(Collectors.toList());
        System.out.println("開発部のメンバー: " + devMembers);

        // 年収の平均
        double avgSalary = employees.stream()
            .mapToInt(e -> e.salary)
            .average()
            .orElse(0);
        System.out.println("年収の平均: " + String.format("%.1f", avgSalary) + "万円");

        // 年収が最も高い人
        Employee highest = employees.stream()
            .max(Comparator.comparingInt(e -> e.salary))
            .orElse(null);
        if (highest != null) {
            System.out.println("年収が最も高い人: " + highest.name + "（" + highest.salary + "万円）");
        }

        // 部署別の人数
        Map<String, Long> deptCount = employees.stream()
            .collect(Collectors.groupingBy(e -> e.department, Collectors.counting()));
        System.out.println("部署別の人数: " + deptCount);
    }
}

ポイント: Stream API はオブジェクトのリストに対しても強力です。filter + map の組み合わせ、Comparator によるソート・最大値取得、Collectors.groupingBy によるグルーピングは実務で頻繁に使うパターンです。

問題7：Map の応用（単語カウント）⭐⭐

問題

文章中の各単語の出現回数をカウントし、出現回数順に表示してください。

文章："java is great java is powerful and java is everywhere"

期待する出力

文章: java is great java is powerful and java is everywhere

=== 単語カウント ===
java: 3回
is: 3回
great: 1回
powerful: 1回
and: 1回
everywhere: 1回
模範解答 
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Exercise07 {
    public static void main(String[] args) {
        String sentence = "java is great java is powerful and java is everywhere";

        System.out.println("文章: " + sentence);
        System.out.println("\n=== 単語カウント ===");

        String[] words = sentence.split(" ");

        // 出現順を保持しながらカウント
        Map<String, Integer> wordCount = new LinkedHashMap<>();
        for (String word : words) {
            wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
        }

        // 出現回数順にソートして表示
        wordCount.entrySet().stream()
            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
            .forEach(entry ->
                System.out.println(entry.getKey() + ": " + entry.getValue() + "回")
            );
    }
}

ポイント: getOrDefault() はキーが存在しない場合にデフォルト値を返す便利なメソッドです。Map.Entry のストリーム処理で値によるソートができます。単語カウントはテキスト処理の基本パターンです。

問題8：ラムダ式とComparator ⭐⭐

問題

商品リストをさまざまな条件でソートしてください。

期待する出力

=== 商品リスト ===
[ノートPC:98000円, マウス:2500円, キーボード:8000円, モニター:35000円, USBメモリ:1500円]

価格の昇順:
[USBメモリ:1500円, マウス:2500円, キーボード:8000円, モニター:35000円, ノートPC:98000円]

価格の降順:
[ノートPC:98000円, モニター:35000円, キーボード:8000円, マウス:2500円, USBメモリ:1500円]

名前の長さ順:
[マウス:2500円, ノートPC:98000円, モニター:35000円, USBメモリ:1500円, キーボード:8000円]
模範解答 
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Product {
    String name;
    int price;

    Product(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return name + ":" + price + "円";
    }
}

public class Exercise08 {
    public static void main(String[] args) {
        List<Product> products = new ArrayList<>();
        products.add(new Product("ノートPC", 98000));
        products.add(new Product("マウス", 2500));
        products.add(new Product("キーボード", 8000));
        products.add(new Product("モニター", 35000));
        products.add(new Product("USBメモリ", 1500));

        System.out.println("=== 商品リスト ===");
        System.out.println(products);

        // 価格の昇順
        List<Product> byPriceAsc = new ArrayList<>(products);
        byPriceAsc.sort(Comparator.comparingInt(p -> p.price));
        System.out.println("\n価格の昇順:");
        System.out.println(byPriceAsc);

        // 価格の降順
        List<Product> byPriceDesc = new ArrayList<>(products);
        byPriceDesc.sort(Comparator.comparingInt((Product p) -> p.price).reversed());
        System.out.println("\n価格の降順:");
        System.out.println(byPriceDesc);

        // 名前の長さ順
        List<Product> byNameLength = new ArrayList<>(products);
        byNameLength.sort(Comparator.comparingInt(p -> p.name.length()));
        System.out.println("\n名前の長さ順:");
        System.out.println(byNameLength);
    }
}

ポイント: Comparator.comparingInt() にラムダ式を渡すことで、任意の基準でソートできます。.reversed() で降順になります。Comparator.comparing(Product::getName).thenComparing(Product::getPrice) のように複合ソートも可能です。

問題9：Stream API チェーン処理 ⭐⭐⭐

問題

注文データを Stream API で分析してください。

期待する出力

=== 注文分析 ===

全注文:
  #1 田中: ノートPC × 1 = 98000円
  #2 鈴木: マウス × 3 = 7500円
  #3 田中: キーボード × 2 = 16000円
  #4 佐藤: モニター × 1 = 35000円
  #5 鈴木: USBメモリ × 5 = 7500円
  #6 田中: マウス × 2 = 5000円
  #7 佐藤: ノートPC × 1 = 98000円

--- 分析結果 ---
合計売上: 267000円
平均注文額: 38142円
10000円以上の注文: 3件
顧客別の合計金額:
  田中: 119000円
  鈴木: 15000円
  佐藤: 133000円
最高額の注文: #1 田中 ノートPC（98000円）
模範解答 
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Order {
    int id;
    String customer;
    String product;
    int quantity;
    int unitPrice;

    Order(int id, String customer, String product, int quantity, int unitPrice) {
        this.id = id;
        this.customer = customer;
        this.product = product;
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }

    int getTotal() {
        return quantity * unitPrice;
    }
}

public class Exercise09 {
    public static void main(String[] args) {
        List<Order> orders = Arrays.asList(
            new Order(1, "田中", "ノートPC", 1, 98000),
            new Order(2, "鈴木", "マウス", 3, 2500),
            new Order(3, "田中", "キーボード", 2, 8000),
            new Order(4, "佐藤", "モニター", 1, 35000),
            new Order(5, "鈴木", "USBメモリ", 5, 1500),
            new Order(6, "田中", "マウス", 2, 2500),
            new Order(7, "佐藤", "ノートPC", 1, 98000)
        );

        System.out.println("=== 注文分析 ===\n");

        // 全注文表示
        System.out.println("全注文:");
        orders.forEach(o ->
            System.out.printf("  #%d %s: %s × %d = %d円%n",
                o.id, o.customer, o.product, o.quantity, o.getTotal())
        );

        System.out.println("\n--- 分析結果 ---");

        // 合計売上
        int totalSales = orders.stream()
            .mapToInt(Order::getTotal)
            .sum();
        System.out.println("合計売上: " + totalSales + "円");

        // 平均注文額
        double avgOrder = orders.stream()
            .mapToInt(Order::getTotal)
            .average()
            .orElse(0);
        System.out.println("平均注文額: " + (int) avgOrder + "円");

        // 10000円以上の注文
        long highValueCount = orders.stream()
            .filter(o -> o.getTotal() >= 10000)
            .count();
        System.out.println("10000円以上の注文: " + highValueCount + "件");

        // 顧客別の合計金額
        Map<String, Integer> customerTotal = orders.stream()
            .collect(Collectors.groupingBy(
                o -> o.customer,
                Collectors.summingInt(Order::getTotal)
            ));
        System.out.println("顧客別の合計金額:");
        customerTotal.forEach((customer, total) ->
            System.out.println("  " + customer + ": " + total + "円")
        );

        // 最高額の注文
        Order maxOrder = orders.stream()
            .max(Comparator.comparingInt(Order::getTotal))
            .orElse(null);
        if (maxOrder != null) {
            System.out.println("最高額の注文: #" + maxOrder.id + " " + maxOrder.customer
                + " " + maxOrder.product + "（" + maxOrder.getTotal() + "円）");
        }
    }
}

ポイント: Collectors.groupingBy と Collectors.summingInt を組み合わせることで、SQLの GROUP BY + SUM のような集計ができます。メソッド参照（Order::getTotal）はラムダ式 o -> o.getTotal() の簡略形です。

問題10：総合問題 - 成績管理システム ⭐⭐⭐

問題

コレクションと Stream API を総合的に使った成績管理システムを作成してください。

機能：

  1. 生徒と科目ごとの点数を管理
  2. 生徒別の平均点を計算
  3. 科目別の平均点を計算
  4. 総合トップ3を表示
  5. 科目ごとの最高得点者を表示
  6. 成績分布（A～D評価）を表示

期待する出力

=== 成績管理システム ===

--- 全成績データ ---
田中: {国語=85, 数学=72, 英語=90}
鈴木: {国語=92, 数学=88, 英語=76}
佐藤: {国語=78, 数学=95, 英語=82}
高橋: {国語=65, 数学=70, 英語=95}
伊藤: {国語=88, 数学=82, 英語=79}

--- 生徒別平均点 ---
田中: 82.3点
鈴木: 85.3点
佐藤: 85.0点
高橋: 76.7点
伊藤: 83.0点

--- 科目別平均点 ---
国語: 81.6点
数学: 81.4点
英語: 84.4点

--- 総合トップ3 ---
1位: 鈴木（85.3点）
2位: 佐藤（85.0点）
3位: 伊藤（83.0点）

--- 科目別 最高得点者 ---
国語: 鈴木（92点）
数学: 佐藤（95点）
英語: 高橋（95点）

--- 成績分布 ---
A（90点以上）: 4件
B（70点以上）: 10件
C（50点以上）: 1件
D（50点未満）: 0件
模範解答 
import java.util.*;
import java.util.stream.Collectors;

public class Exercise10 {
    public static void main(String[] args) {
        // データ準備
        Map<String, Map<String, Integer>> grades = new LinkedHashMap<>();
        grades.put("田中", createScores(85, 72, 90));
        grades.put("鈴木", createScores(92, 88, 76));
        grades.put("佐藤", createScores(78, 95, 82));
        grades.put("高橋", createScores(65, 70, 95));
        grades.put("伊藤", createScores(88, 82, 79));

        String[] subjects = {"国語", "数学", "英語"};

        System.out.println("=== 成績管理システム ===");

        // 全成績データ
        System.out.println("\n--- 全成績データ ---");
        grades.forEach((name, scores) ->
            System.out.println(name + ": " + scores)
        );

        // 生徒別平均点
        System.out.println("\n--- 生徒別平均点 ---");
        Map<String, Double> studentAvg = new LinkedHashMap<>();
        grades.forEach((name, scores) -> {
            double avg = scores.values().stream()
                .mapToInt(Integer::intValue)
                .average()
                .orElse(0);
            studentAvg.put(name, avg);
            System.out.printf("%s: %.1f点%n", name, avg);
        });

        // 科目別平均点
        System.out.println("\n--- 科目別平均点 ---");
        for (String subject : subjects) {
            double avg = grades.values().stream()
                .mapToInt(scores -> scores.get(subject))
                .average()
                .orElse(0);
            System.out.printf("%s: %.1f点%n", subject, avg);
        }

        // 総合トップ3
        System.out.println("\n--- 総合トップ3 ---");
        studentAvg.entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .limit(3)
            .forEach(new java.util.function.Consumer<Map.Entry<String, Double>>() {
                int rank = 1;
                @Override
                public void accept(Map.Entry<String, Double> entry) {
                    System.out.printf("%d位: %s（%.1f点）%n", rank++, entry.getKey(), entry.getValue());
                }
            });

        // 科目別 最高得点者
        System.out.println("\n--- 科目別 最高得点者 ---");
        for (String subject : subjects) {
            grades.entrySet().stream()
                .max(Comparator.comparingInt(e -> e.getValue().get(subject)))
                .ifPresent(e ->
                    System.out.println(subject + ": " + e.getKey() + "（" + e.getValue().get(subject) + "点）")
                );
        }

        // 成績分布
        System.out.println("\n--- 成績分布 ---");
        List<Integer> allScores = grades.values().stream()
            .flatMap(scores -> scores.values().stream())
            .collect(Collectors.toList());

        long gradeA = allScores.stream().filter(s -> s >= 90).count();
        long gradeB = allScores.stream().filter(s -> s >= 70 && s < 90).count();
        long gradeC = allScores.stream().filter(s -> s >= 50 && s < 70).count();
        long gradeD = allScores.stream().filter(s -> s < 50).count();

        System.out.println("A（90点以上）: " + gradeA + "件");
        System.out.println("B（70点以上）: " + gradeB + "件");
        System.out.println("C（50点以上）: " + gradeC + "件");
        System.out.println("D（50点未満）: " + gradeD + "件");
    }

    static Map<String, Integer> createScores(int japanese, int math, int english) {
        Map<String, Integer> scores = new LinkedHashMap<>();
        scores.put("国語", japanese);
        scores.put("数学", math);
        scores.put("英語", english);
        return scores;
    }
}

ポイント: コレクション（Map, List）と Stream API を組み合わせた総合問題です。flatMap でネストしたコレクションを平坦化し、groupingBy でグルーピング、limit で上位N件の取得ができます。実務のデータ分析やレポート生成でもこのパターンが多く使われます。

まとめ

問題 テーマ 難易度
問題1 ArrayList の基本操作 ⭐
問題2 HashMap の基本操作 ⭐
問題3 Set で重複排除 ⭐
問題4 List のソートと検索 ⭐⭐
問題5 Stream API の基本 ⭐⭐
問題6 Stream でオブジェクト処理 ⭐⭐
問題7 Map の応用（単語カウント） ⭐⭐
問題8 ラムダ式と Comparator ⭐⭐
問題9 Stream API チェーン処理 ⭐⭐⭐
問題10 成績管理システム（総合問題） ⭐⭐⭐

シリーズ完結！

全10回、100問のコーディング問題集をお読みいただきありがとうございました。

学習の振り返り

回 テーマ 主なスキル
① 変数・データ型・演算子 型の使い分け、キャスト、演算子
② 条件分岐 if-else, switch, 論理演算子
③ 繰り返し処理 for, while, break/continue
④ 配列 宣言、ループとの組み合わせ、二次元配列
⑤ メソッド 引数・戻り値、オーバーロード、再帰
⑥ 文字列操作 String メソッド、StringBuilder
⑦ クラスとオブジェクト コンストラクタ、カプセル化、static
⑧ 継承とインターフェース ポリモーフィズム、抽象クラス
⑨ 例外処理 try-catch, 独自例外, try-with-resources
⑩ コレクションと Stream API List, Map, Set, ラムダ式, Stream

これらの基礎を固めた上で、フレームワーク（Spring Boot等）やデータベース連携の学習に進みましょう！

シリーズ一覧：Java研修コーディング問題集

  1. 変数・データ型・演算子 編
  2. 条件分岐（if / switch）編
  3. 繰り返し処理（for / while）編
  4. 配列 編
  5. メソッド 編
  6. 文字列操作（String）編
  7. クラスとオブジェクト 編
  8. 継承とインターフェース 編
  9. 例外処理 編
  10. 👉 コレクションと Stream API 編（本記事）

著者: @kotaro_ai_lab
AI駆動開発やテック情報を毎日発信しています。フォローお気軽にどうぞ！

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?