たとえば、サーバーからデータを取得する処理は、クリックした瞬間に結果が返ってくるとは限りません。通信には時間がかかりますし、失敗することもあります。

Promiseを使うと、そのような非同期処理に対して「成功したらこの処理」「失敗したらこの処理」「最後にこの処理」という形で、後続の処理を整理できます。

Promiseは「値そのもの」ではありません。まだ終わっていない処理の結果を、あとで受け取るための箱のようなものです。

この記事では、Promiseとは何か、then・catch・finallyの使い方、fetchやasync/awaitとの関係を初心者向けに順番に解説します。

まず結論：Promiseは非同期処理の結果をあとで受け取る仕組み

Promiseを最初に理解するときは、次のように考えると分かりやすいです。

非同期処理を始める
  ↓
Promiseが返る
  ↓
成功したら then
失敗したら catch
最後に finally

Promiseは、処理が終わる前に「将来の結果を表すオブジェクト」として返されます。MDNでも、Promiseは非同期処理の最終的な完了または失敗と、その結果の値を表すオブジェクトとして説明されています。

つまり、Promiseは「通信結果そのもの」ではなく、通信結果をあとで受け取るための窓口です。

Promiseが必要になる理由

JavaScriptでは、ブラウザ操作や通信処理など、すぐに終わらない処理がよく出てきます。代表例は、APIからデータを取得するfetchです。

もし通信が終わるまで画面全体が止まってしまうと、ユーザーは何も操作できません。そのためJavaScriptでは、時間がかかる処理を待っている間も、他の処理を進められるように非同期処理を使います。

ただし、非同期処理には問題があります。結果がいつ返るか分からないため、普通の変数代入の感覚で書くと、まだ結果がない状態を読んでしまいます。

そこでPromiseを使い、結果が返ってきたあとに実行する処理を登録します。

Promiseの3つの状態

Promiseには、処理の進み具合を表す状態があります。最初は細かい仕様名よりも、次の3つを押さえれば十分です。

Promiseは最初はpendingです。その後、成功すればfulfilled、失敗すればrejectedになります。

この図では、Promiseを「非同期処理の結果をあとで受け取る流れ」として見てください。thenは成功、catchは失敗、finallyは最後の後片付けに対応します。

then・catch・finallyの基本

Promiseでよく使うのは、then・catch・finallyの3つです。

一番シンプルな形は次の通りです。

fetch("https://example.com/api/users")
  .then((response) => response.json())
  .then((users) => {
    console.log(users);
  })
  .catch((error) => {
    console.error("取得に失敗しました", error);
  })
  .finally(() => {
    console.log("処理が終わりました");
  });

thenは成功した結果を次へ渡します。catchは途中で失敗したときに呼ばれます。finallyは、成功しても失敗しても最後に実行されます。

Promiseチェーンとは？

Promiseでは、thenをつなげて処理を順番に書けます。このつながりをPromiseチェーンと呼ぶことがあります。

次の例では、最初のthenでレスポンスをJSONに変換し、次のthenで変換後のデータを使っています。

fetch("/users.json")
  .then((response) => response.json())
  .then((users) => users.filter((user) => user.active))
  .then((activeUsers) => {
    console.log(activeUsers);
  })
  .catch((error) => {
    console.error(error);
  });

ポイントは、前のthenで返した値が、次のthenへ渡されることです。

配列のfilterやmapがあやふやな場合は、map・filter・reduceの違いも参考になります。

fetch APIとPromiseの関係

fetchは、HTTP通信を行うためのWeb APIです。そしてfetch()を呼び出すとPromiseが返ります。

そのため、fetchのコードではPromiseの理解がほぼ必須になります。

const promise = fetch("/api/users");

console.log(promise); // Promiseが入っている

この時点で得られるのは、ユーザー一覧そのものではありません。通信結果をあとで受け取るためのPromiseです。

fetchのGET・POSTの基本は、fetch APIとは？で詳しく解説しています。

async/awaitとの違い

async/awaitは、Promiseをより自然な順番で書くための構文です。Promiseと別物というより、Promiseを読みやすく扱うための書き方です。

Promiseチェーンで書くと次のようになります。

fetch("/api/users")
  .then((response) => response.json())
  .then((users) => console.log(users))
  .catch((error) => console.error(error));

同じ処理をasync/awaitで書くと、次のようになります。

async function loadUsers() {
  try {
    const response = await fetch("/api/users");
    const users = await response.json();
    console.log(users);
  } catch (error) {
    console.error(error);
  }
}

awaitはPromiseの完了を待ち、その結果を取り出します。async/awaitの基本は、async/awaitとは？の記事で解説しています。

初心者がつまずきやすいポイント

特に多いのは、thenの中で値を返し忘れることです。次の処理に値を渡したい場合は、returnを意識しましょう。

Promiseをどんな場面で使うのか

Promiseは、次のような非同期処理でよく使われます。

• APIからデータを取得する
• 一定時間後に処理する
• ファイルや画像の読み込みを待つ
• 複数の非同期処理を順番に実行する
• 複数の非同期処理をまとめて待つ

ただし、最初からPromise.allやPromise.raceなどをすべて覚える必要はありません。まずはthen・catch・finallyと、async/awaitとの関係を押さえましょう。

関連して読みたい記事

• JavaScriptのコールバック関数とは？
• fetch APIとは？GETとPOSTの使い方
• async/awaitとは？Promiseとの違い
• JavaScriptのスコープとは？

まとめ

JavaScriptのPromiseは、非同期処理の結果をあとで受け取るための仕組みです。

• thenは成功時の処理を書く
• catchは失敗時の処理を書く
• finallyは最後の後片付けを書く
• async/awaitはPromiseを読みやすく扱う構文

Promiseを理解すると、fetchやasync/awaitのコードがかなり読みやすくなります。最初は「まだ終わっていない処理の結果を、あとで受け取る約束」と考えれば十分です。

たとえば、ユーザー情報を表す型を毎回{ id: number; name: string }と書くのは読みにくくなります。そこでtype User = ...のように名前を付けます。

初心者が迷いやすいのは、typeとinterfaceの違いです。どちらもオブジェクトの形を表せますが、得意な使いどころが少し違います。

最初は「typeは型に名前を付ける」「interfaceはオブジェクトの形を宣言する」と分けて考えると理解しやすいです。

この記事では、TypeScriptのtypeとは何か、基本構文、union型での使い方、interfaceとの違い、実務での使い分けを初心者向けに解説します。

まず結論：typeは型に名前を付ける書き方

typeは、型に別名を付けるために使います。TypeScript公式ドキュメントでも、type aliasは任意の型に名前を付けるものとして説明されています。

type User = {
  id: number;
  name: string;
};

const user: User = {
  id: 1,
  name: "Sato",
};

この例では、{ id: number; name: string }というオブジェクトの型に、Userという名前を付けています。

一度名前を付けると、変数、関数の引数、戻り値などで同じ型を使い回せます。

typeが必要になる理由

TypeScriptでは、型を直接書くこともできます。

function printUser(user: { id: number; name: string }) {
  console.log(user.name);
}

短いコードならこれでも問題ありません。しかし、同じ型を何度も書くと、コードが長くなり、修正漏れも起きやすくなります。

typeを使うと、型の意味が名前で分かるようになります。

type User = {
  id: number;
  name: string;
};

function printUser(user: User) {
  console.log(user.name);
}

このように、typeはコードを短くするためだけでなく、型の意味を名前で伝えるために使います。

typeの基本構文

typeの基本構文は次の通りです。

type 型名 = 型;

オブジェクト型に名前を付ける場合は、次のように書きます。

type Product = {
  id: number;
  name: string;
  price: number;
};

関数の引数や戻り値にも使えます。

function formatProduct(product: Product): string {
  return `${product.name}: ${product.price}円`;
}

TypeScriptの型注釈や関数の基本がまだ曖昧な場合は、TypeScript超入門やTypeScriptの関数宣言/関数式を先に読むと理解しやすくなります。

typeはunion型にも名前を付けられる

typeの大きな特徴は、オブジェクト型だけでなく、union型にも名前を付けられることです。

type ID = number | string;

function findUser(id: ID) {
  console.log(id);
}

number | stringは、「数値または文字列」という意味です。このような型をunion型と呼びます。

毎回number | stringと書く代わりにIDと名付けることで、「これはIDとして扱う値だ」と読み取りやすくなります。

この図では、typeを「型そのものを作る魔法」ではなく、型に名前を付けて使いやすくする入口として見てください。

interfaceとの違い

typeとinterfaceは、どちらもオブジェクトの形を表せます。

type UserType = {
  id: number;
  name: string;
};

interface UserInterface {
  id: number;
  name: string;
}

この例だけを見ると、ほとんど同じに見えます。実際、単純なオブジェクト型であれば、どちらでも表せます。

TypeScript公式ドキュメントでも、ほとんどのinterfaceの機能はtypeでも使える一方、interfaceは後から拡張できる点が大きな違いとして説明されています。

すでにTypeScriptのinterfaceを読んでいる場合は、この記事と合わせて見ると使い分けが整理しやすくなります。

typeを使うとよい場面

typeは、次のような場面で特に便利です。

• union型に名前を付けたい
• tuple型に名前を付けたい
• 関数型に名前を付けたい
• 複数の型を組み合わせたい
• APIレスポンスの型を読みやすく整理したい

たとえば、状態を文字列で表す場合はtypeが分かりやすいです。

type Status = "loading" | "success" | "error";

function render(status: Status) {
  if (status === "loading") {
    return "読み込み中";
  }
  if (status === "success") {
    return "成功";
  }
  return "エラー";
}

このように書くと、statusには決められた文字列だけを渡せます。入力ミスにも気づきやすくなります。

interfaceを使うとよい場面

一方、interfaceは、オブジェクトの形を中心に扱う場面でよく使われます。

• クラスに実装させる契約を表したい
• オブジェクトの構造を外部に公開したい
• ライブラリや拡張前提の型を定義したい
• 同じ名前のinterfaceを後から拡張したい

たとえば、クラスが持つべきメソッドを表す場合はinterfaceが読みやすいことがあります。

interface Repository {
  findById(id: string): Promise<User>;
  save(user: User): void;
}

ただし、これは絶対ルールではありません。プロジェクトごとのコーディング規約がある場合は、それに従うのが実務では重要です。

初心者がつまずきやすいポイント

特に重要なのは、typeは実行時の値ではなく、開発中にコードを安全に読むための型情報だという点です。

実務での使い分けの目安

迷ったときは、次のように考えると整理しやすくなります。

初心者のうちは、まずtypeでunion型、interfaceでオブジェクトの契約、と覚えると混乱しにくくなります。

関連して読みたい記事

• TypeScript超入門
• TypeScript入門
• TypeScriptのinterfaceとは？
• TypeScriptの変数と基本的な型
• TypeScriptの関数宣言/関数式

まとめ

TypeScriptのtypeは、型に名前を付けるための書き方です。

• 同じ型を何度も書かずに済む
• 型の意味を名前で伝えられる
• union型やtuple型にも名前を付けられる
• interfaceとは拡張方法や得意分野が違う

最初は、type ID = number | stringのような短い例から始めると理解しやすくなります。慣れてきたら、APIレスポンスや画面状態の型にも使ってみましょう。

たとえば、ある人のPCでは動くのに、別の人のPCでは動かない、という問題があります。Node.jsやPython、データベース、ライブラリのバージョンが違うと、同じコードでも動きが変わることがあります。

Dockerを使うと、アプリに必要な実行環境をイメージとしてまとめ、コンテナとして起動できます。これにより、開発環境、テスト環境、本番環境の差を小さくしやすくなります。

Dockerは「軽い仮想マシン」と説明されることがありますが、厳密には仮想マシンそのものではありません。まずはコンテナを動かす仕組みとして理解しましょう。

この記事では、Dockerとは何か、コンテナ・イメージ・Dockerfileの関係、仮想マシンとの違い、開発現場で使う理由を初心者向けに解説します。

まず結論：Dockerはアプリの実行環境をまとめて扱う仕組み

Dockerを最初に理解するときは、次の流れで考えると分かりやすいです。

Dockerfileを書く
  ↓
Dockerイメージを作る
  ↓
イメージからコンテナを起動する
  ↓
アプリが決められた環境で動く

Docker公式ドキュメントでも、Dockerはコンテナと呼ばれる分離された環境でアプリケーションをパッケージ化し、実行できるプラットフォームとして説明されています。

初心者のうちは、Dockerを「環境ごとアプリを動かしやすくする道具」として理解すれば十分です。

Dockerが必要になる理由

開発では、コードだけでなく実行環境も重要です。アプリが動くには、プログラミング言語の実行環境、ライブラリ、設定ファイル、OS上のツール、データベースなどが関係します。

これらが人によって違うと、次のような問題が起きます。

• 自分のPCでは動くが、他の人のPCでは動かない
• 本番環境だけエラーになる
• 環境構築の手順が長く、新人が詰まりやすい
• 古いプロジェクトと新しいプロジェクトで必要なバージョンが衝突する

Dockerは、このような環境差を小さくするために使われます。環境構築の手順をファイルとして残し、同じイメージから同じようなコンテナを起動できるようにします。

サーバーの基本がまだ曖昧な場合は、先にサーバーとは何か？を読むと、Dockerがどこで役立つかイメージしやすくなります。

コンテナとは何か

コンテナとは、アプリとその実行に必要なものを、他の環境から分けて動かすための単位です。

Docker公式の入門ドキュメントでは、コンテナはアプリの各部品ごとに分離されたプロセスとして説明されています。重要なのは、コンテナがホストOS全体を丸ごと複製するわけではない点です。

コンテナは、必要なファイルや設定を持ちながら、ホストや他のコンテナへの影響を小さくしてアプリを動かします。

イメージとは何か

Dockerイメージとは、コンテナを起動するためのテンプレートです。Docker公式ドキュメントでも、イメージはコンテナを作るための読み取り専用テンプレートとして説明されています。

たとえば、Node.jsアプリを動かすなら、Node.jsの実行環境、アプリのコード、必要なライブラリ、起動コマンドなどをイメージにまとめます。

イメージとコンテナの違いは、次のように考えると分かりやすいです。

この図では、Dockerfile、イメージ、コンテナの関係を左から右へ見てください。Dockerを理解するときは、まずこの3つを分けることが重要です。

Dockerfileとは何か

Dockerfileとは、Dockerイメージを作るための手順を書いたファイルです。

たとえば、次のような内容を書きます。

FROM node:22
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["npm", "start"]

この例では、Node.jsのイメージを土台にして、作業ディレクトリを作り、依存ライブラリをインストールし、最後にアプリを起動しています。

Dockerfileがあると、環境構築の手順を口頭や手順書だけでなく、実行できる形で残せます。

Dockerでよく出てくるコマンドの流れ

Dockerを学び始めると、build、run、ps、stopなどのコマンドが出てきます。最初はすべてを暗記するより、何を操作しているのかを分けて考えることが大切です。

ここでも中心になるのは、イメージとコンテナの違いです。buildはテンプレートを作る操作、runはそのテンプレートから実体を起動する操作、と見ると混乱しにくくなります。

また、実務では複数のコンテナをまとめて起動するためにDocker Composeを使うこともあります。ただし、初心者の最初の理解では、まず1つのDockerfileから1つのイメージを作り、1つのコンテナを起動する流れを押さえるのが先です。

仮想マシンとの違い

Dockerコンテナと仮想マシンは、どちらも環境を分けるために使われます。ただし仕組みは違います。

Docker公式ドキュメントでも、仮想マシンはカーネルやドライバを含むOS全体を持つ一方、コンテナは必要なファイルを持つ分離されたプロセスとして説明されています。

そのため、Dockerは仮想マシンより軽く扱えることが多いですが、すべての用途で仮想マシンの代わりになるわけではありません。

Dockerを使うメリット

Dockerを使う主なメリットは次の通りです。

• 環境構築を再現しやすい
• 開発者ごとの差を小さくできる
• CI/CDで同じ環境を使いやすい
• アプリと依存関係をまとめて扱いやすい
• 古い環境と新しい環境を分けやすい

特にCI/CDでは、テストやビルドを毎回同じ環境で実行しやすくなります。CI/CDの基本は、GitHub Actionsとは？やビルドとは？と一緒に見ると理解がつながります。

Dockerを使うときの注意点

Dockerは便利ですが、使えば自動的にすべてが解決するわけではありません。

初心者のうちは、まずローカル開発環境で小さく使い、イメージとコンテナの違いを実際に確認するのがおすすめです。

関連して読みたい記事

• サーバーとは何か？
• VPSとは？
• ビルドとは？
• GitHub Actionsとは？
• APIとは？Web APIとの違い

まとめ

Dockerは、アプリを動かすための環境をコンテナとしてまとめ、どこでも同じように動かしやすくするための仕組みです。

• Dockerfileはイメージを作る手順
• イメージはコンテナを起動するテンプレート
• コンテナは実際に動いている実行環境
• 仮想マシンとは仕組みが違う
• 環境差を減らし、開発やCI/CDを進めやすくする

最初から本番運用まで理解する必要はありません。まずは、Dockerfile、イメージ、コンテナの3つを分けて考えるところから始めましょう。

たとえば、開発者がGitHubにコードをpushしたとします。そのたびに、人が手作業でビルドして、テストして、問題がなければデプロイの準備をするのは大変です。そこで使われる考え方がCI/CDです。CI/CDでは、コード変更をきっかけに、ビルド、テスト、成果物作成、デプロイ準備などを自動で実行します。

CI/CDはツール名ではありません。GitHub ActionsやJenkinsなどは、CI/CDを実現するための道具です。

この記事では、CI/CDとは何か、CIとCDの違い、ビルド・テスト・デプロイとの関係、GitHub Actionsとのつながりを初心者向けに解説します。

まず結論：CI/CDは変更を安全に届けるための流れ

CI/CDを最初に理解するときは、次のように考えると分かりやすいです。

コードを変更する
  ↓
自動でビルドする
  ↓
自動でテストする
  ↓
問題がなければ、届けられる状態にする

この一連の流れをまとめてCI/CDと呼びます。

日本語では、CIは「継続的インテグレーション」、CDは「継続的デリバリー」または「継続的デプロイメント」と呼ばれます。

難しく見えますが、初心者のうちは「変更したコードを、毎回きちんと確認して、届けやすくする仕組み」と理解すれば十分です。

CIとは？変更をこまめに取り込み、自動で確認すること

CIは、Continuous Integrationの略です。直訳すると「継続的インテグレーション」です。

インテグレーションとは、複数の変更を1つに統合することです。チーム開発では、複数人がそれぞれコードを変更します。その変更を長期間ため込むと、あとでまとめたときに問題が起きやすくなります。

CIでは、コードの変更をこまめに取り込み、そのたびに自動で確認します。

• ビルドできるか
• テストが通るか
• 基本的なチェックに失敗していないか

つまりCIの目的は、問題を早く見つけることです。

ビルドの意味が曖昧な場合は、先にビルドとは？を読むと理解しやすくなります。コンパイルとの違いは、コンパイルとは？で整理しています。

CDとは？確認済みの変更を届けられる状態にすること

CDは、文脈によって2つの意味で使われます。

初心者がまず押さえるべきなのは、CDは「確認済みの変更を届ける段階」だということです。

ただし、すべての現場で本番環境への反映まで完全自動化しているわけではありません。最後の公開判断は人が行い、そこまでのビルドやテスト、リリース準備を自動化する構成もよくあります。

「CD」とだけ書かれている場合は、継続的デリバリーなのか、継続的デプロイメントなのかを文脈で確認しましょう。

CI/CDの全体像を図で整理する

CI/CDは、コード変更からリリース準備までをつなぐパイプラインとして考えると理解しやすくなります。

次の図では、CIは「壊れていないか確認する場所」、CDは「届けられる状態にする場所」として見てください。CI/CDをツール名として覚えるより、この流れで見る方が実務の会話を理解しやすくなります。

パイプラインとは、複数の処理を順番につないだ流れのことです。CI/CDパイプラインでは、たとえば次のような処理が順番に動きます。

• コードがpushされる
• 依存ライブラリを準備する
• ビルドする
• 自動テストを実行する
• 成果物を作る
• 必要に応じてデプロイする

重要なのは、CI/CDが「一度設定したら何でも勝手にうまくいく魔法」ではないことです。どのチェックを実行するか、失敗したときに止めるか、誰が最終確認するかは、プロジェクトごとに設計します。

CI/CDでは何が自動化されるのか

CI/CDで自動化される代表的な処理を整理します。

すべてのプロジェクトで、これらを全部自動化する必要があるわけではありません。最初は「pushしたらテストだけ自動で動く」でもCIの第一歩です。

GitHub ActionsとCI/CDの関係

GitHub Actionsは、GitHub上でワークフローを自動実行できる仕組みです。CI/CDそのものではなく、CI/CDを実現するためのツールの1つです。

たとえば、GitHubにpushされたらテストを実行する、pull requestが作られたらビルドする、といった処理を自動化できます。

name: ci

on:
  push:
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm install
      - run: npm test

この例では、pushやpull requestをきっかけに、依存ライブラリのインストールとテストを実行しています。実際の設定はプロジェクトによって変わりますが、考え方は同じです。

GitHub Actionsの基本は、GitHub Actionsとは？の記事で解説しています。Gitの変更単位であるコミットについては、Gitのコミットとは何か？もあわせて読むと理解しやすくなります。

CI/CDを使うメリット

CI/CDを使うメリットは、単に作業が楽になることだけではありません。開発の品質とスピードを両方支えるために使われます。

• 問題を早く見つけられる
• 手作業によるミスを減らせる
• チーム全員が同じ確認手順を使える
• リリース前の不安を小さくできる
• 小さな変更をこまめに届けやすくなる

特に大きいのは、問題を「あとでまとめて見つける」のではなく、「変更した直後に見つける」点です。

テストの考え方を押さえたい場合は、システムテストの７原則や、ホワイトボックステストとブラックボックステストの違いも参考になります。

手作業リリースとの違い

CI/CDを導入する前は、ビルドやテスト、デプロイ準備を人が手順書に沿って実行することがあります。もちろん手作業がすべて悪いわけではありませんが、毎回同じ確認を人が行うと、漏れや手順違いが起きやすくなります。

この比較図で見てほしいのは、CI/CDが単に「作業を楽にする仕組み」ではない点です。重要なのは、確認を人の記憶や手順から、毎回同じように動く仕組みへ移すことです。

ただし、CI/CDを入れれば品質が自動的に上がるわけではありません。意味のあるテストやチェックを用意し、その結果をチームが見て改善していくことが重要です。

初心者がつまずきやすいポイント

CI/CDで初心者がつまずきやすいポイントを整理します。

特に大事なのは、CI/CDを「自動化ツールの設定」とだけ考えないことです。CI/CDの本質は、変更を小さく確認し、問題を早く見つけ、届けるまでの流れを安定させることです。

関連して読みたい記事

CI/CDは、Git、ビルド、テスト、構成管理とつながっている用語です。次の記事もあわせて読むと理解が深まります。

• GitHub Actionsとは？仕組みや使い方を３分でわかりやすく
• ビルドとは？プログラミングの基本用語を１分でわかりやすく
• コンパイルとは？初心者向けに1からわかりやすく解説
• Gitのコミットとは何か？その本質を3分でわかりやすく解説
• 構成管理とは？目的と意味を３分で解説！

まとめ

CI/CDとは、コードの変更を自動で確認し、安全に届けるための流れです。

• CIは、変更をこまめに取り込み、自動で確認すること
• CDは、確認済みの変更を届けられる状態にすること
• GitHub Actionsなどのツールは、CI/CDを実現する手段
• CI/CDの目的は、問題を早く見つけ、手作業のミスを減らすこと

最初から高度なデプロイ戦略まで覚える必要はありません。まずは、「pushしたら自動でビルド・テストが動き、問題があれば早く気づける仕組み」として理解すると、CI/CDの全体像をつかみやすくなります。

まず最初にお伝えしたいのは、JSPは決して難しいものではありません。むしろ、「ちょっと動きのあるWebページを、できるだけ簡単に作りたい！」という人のために生まれたものなのです。近年では他の技術に取って代わられた印象が否めないJSPですが、昔からある巨大なレガシーシステムなどでは現役で、システムの更改案件などではよく目にすることがあります。

このページでは「JSPってそもそも何？」という一番大事な部分から、初心者向けに順を追って１からわかりやすく専門用語を避けて解説します。

JSPとは何か？

JSP（Java Server Pages）は、Javaを使ってWebページを動的に生成するための技術で、通常のHTMLファイルにJavaのコードを埋め込むことで、アクセスするたびに内容が変化するページを作成することを可能にします。

そのため、JSPはJavaをベースとしていますが、HTMLの知識があれば、基本的な使い方は十分に理解することができます。

【前提１】静的なページと動的なページ

Webページには、大きく分けて2種類あります。
1つは「静的なページ」、もう1つは「動的なページ」です。

静的コンテンツ/動的コンテンツの違いを１分で解説【初心者向け】

【初心者向け】「動的」「静的」という言葉の意味とその違いを端的に解説します。本で学習したがイマイチ理解できない、、、結局一言でいうと違いは何？という疑問をお持ちの方に具体例を用いながら分かりやすく解説します。

it-biz.online

2026.04.26

静的なページとは、内容があらかじめ決まっていて、アクセスするたびに同じ内容が表示されるページです。たとえば、自己紹介だけが書かれた会社のホームページや、お知らせ一覧だけが載っているページなどが該当します。

一方、動的なページは、アクセスした時点の情報や、閲覧しているユーザーの状態に応じて内容が変わります。たとえば、ショッピングサイトで商品が表示されたり、ログイン中のユーザー名が画面に表示されたりするページがそうです。

静的なページはHTMLだけで作成できますが、動的なページを作るには、プログラムによってページの内容を生成する仕組みが必要です。JSPは、そのような仕組みの一つです。

もちろんJSP以外にも同じようなことを実現することが可能で、現代ではほとんどJSP以外が主役です。なのですが、レガシーシステムでは今でも現役で動いていることが多いので「まあ知っておいて損はないかな」というのがJSPの位置づけです。

JSPとはどのような技術か

JSPは、JavaのコードをHTMLに埋め込むことで、Webサーバー上で動的にHTMLを生成する技術です。拡張子が .jsp であるファイルを使ってページを作成します。

JSPファイルは、Webサーバー（通常はTomcat）に配置され、ユーザーがアクセスすると、サーバー側でJavaのコードが実行されます。その結果として生成されたHTMLが、ブラウザに送信され、画面に表示されます。

つまり、JSPは「動的にHTMLを生成する仕組み」であり、「HTMLの中にJavaの処理を一部書き足せる形式のファイル」と言えます。

JSPの動作のしくみ

JSPファイルは、ユーザーがアクセスしたときに、サーバー側で一度「Javaのクラス（Servlet）」に変換されます。変換されたクラスはコンパイルされ、Javaプログラムとして実行されます。このとき、JSPファイルに書かれたHTMLの部分はそのままHTMLとして出力され、Javaのコード部分は処理されて結果が埋め込まれます。最終的に生成されたHTMLがブラウザに送信され、ユーザーに表示されます。

このしくみによって、JSPは1枚のファイルで「HTMLの見た目」と「動的な処理」を両立させることができます。

JSPの動き方の流れ

1. ユーザーが .jsp ファイルをリクエストする（例：hello.jsp）
2. Tomcat がその .jsp を読んで、中の Java を実行
3. 結果として HTML を作り出し、ブラウザに返す
4. ブラウザには、あたかも普通のHTMLのように見える

この一連の流れによって、「動きのあるページ」がリクエスト元に返却されることになります。

JSPを動かすための準備

JSPファイルは、通常のHTMLファイルと違い、単独では動作しません。JSPはサーバー側でJavaのコードを実行する仕組みのため、その処理を受け持つ「Webサーバー」や「Javaの開発環境」が必要です。

この章では、JSPを動かすために必要なソフトウェアや環境を、1つずつ順を追って準備していきます。

JSPの動作に必要なもの

JSPを動作させるには、次の3つが必要です。ここでは、それってそもそも何？みたいな説明＋実際にあなたのPCにインストールする手順をメモ程度に記載しておきますので、この辺の知識がすでにあるよ！という方は読み飛ばしてください。

JDKのインストール

まず、Javaの開発環境であるJDKをインストールします。JDKがインストールされていないと、JSPも動作しません。

Javaの開発環境構築の３ステップ解説（JDK/JRE/JVMの仕組みを１から解説）

【超・初心者向け】Javaの開発環境を初心者向けに簡単に設定する方法をわかりやすく解説します。JDKのインストール、IDEの選択、開発のスタートまで、スムーズにJavaプログラミングを始める方法をご説明します。

it-biz.online

2026.04.16

手順

1. Oracleの公式サイトまたはOpenJDKのサイトから、JDKをダウンロード。
2. お使いのOSに合ったインストーラを選び、画面の指示に従ってインストール。
3. インストール後、コマンドプロンプト（またはターミナル）を開き、↓のコマンドを入力。

java -version

バージョンが表示されれば、正常にインストールされています。

Tomcatのインストール

JSPファイルを処理するために、Tomcatをインストールします。TomcatはJavaで動作するWebサーバーで、JSPの実行に適した軽量なサーバーです。

手順

1. Apache Tomcat の公式サイトにアクセス。
2. zip ファイル（Windows の場合）または tar.gz ファイル（Mac/Linux の場合）をダウンロード。
3. ダウンロードしたファイルを任意の場所に展開（解凍）。
   →C:\tomcat や ~/tomcat などが一般的ですが、どこでもOK。
4. binフォルダにある startup.bat（Windows）または startup.sh（Mac/Linux）を実行。
5. ブラウザを開き、次のURLにアクセスします：

無効なURLです

localhost

Tomcatのトップページが表示されれば、インストールは成功です。

JSP用のフォルダを作る

Tomcatでは、webapps フォルダの中にあるプロジェクトが自動的に読み込まれます。自分でJSPファイルを作って表示するには、ここに新しいフォルダを作成します。

手順

1. Tomcatフォルダ内の webapps に移動。
2. 新しくフォルダを作成し、たとえば jsp-demo という名前をつける。
3. jsp-demo フォルダの中に、最初のJSPファイルを作成します。ファイル名は hello.jsp など。

エディタの準備

JSPファイルは、普通のテキストファイルとして作成できますが、プログラミングに適したエディタを使うと効率が上がります。以下のいずれかのエディタを使用するのが一般的です。

• Visual Studio Code（無料で軽量、拡張機能が豊富）
• IntelliJ IDEA（Javaに特化した統合開発環境）
• Eclipse（Java開発で定番のIDE）

初心者の方には、Visual Studio Codeが扱いやすくおすすめです。必要に応じて「Java Extension Pack」などを追加すると、補完機能や構文チェックも利用できます。

最初のJSPファイルを作ってみよう

前の章で、JSPを動かすための準備が整いました。この章では、実際にJSPファイルを1つ作成し、それをブラウザで表示するところまで進めます。

ここでは、「JSPとはどういうものか」を実際に体験しながら、基本的な書き方や仕組みを理解していきます。

JSPファイルとはどんなファイルか

JSPファイルは、基本的にはHTMLっぽく見えるコードで、この中の必要な部分にJavaのコードを差し込むことで、表示内容を動的に変えることができるようにしています。たとえば、「現在の日時を表示する」などの処理が可能になります。

JSPファイルの拡張子は .jsp です。ファイルの中には、通常のHTMLタグと、Javaのコードが組み合わさって記述されます。

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Hello JSP</title>
</head>
<body>
  <h1>こんにちは、JSPの世界へようこそ！</h1>
  <p>現在の時刻は：<%= java.time.LocalDateTime.now() %></p>
</body>
</html>

上記のJSPファイルの中では、JavaのコードとHTMLが組み合わさっています。それぞれの部分について説明します。

• <%@ page contentType="text/html; charset=UTF-8" %>
  → この行は「ページ全体の設定」です。文字コードをUTF-8にすることで、文字化けを防ぎます。
• <%= java.time.LocalDateTime.now() %>
  → この部分がJSPの特徴です。「現在の時刻を表示する」Javaのコードが入っています。
  <%= と %> で囲まれた中はJavaの「式」として実行され、結果がそのままHTMLに差し込まれます。

上記のファイルをブラウザで表示するためにエディタで編集して保存しましょう。

1. Tomcatの webapps フォルダの中にある、前章で作成した jsp-demo フォルダに移動。
2. hello.jsp という名前の新しいファイルを作成。
3. ファイルをエディタで開き、↑の内容を記述し保存！

ブラウザで表示してみる

ファイルを保存したら、Tomcatが起動していることを確認し、ブラウザで次のURLにアクセスしてみましょう。

無効なURLです

localhost

画面に「こんにちは、JSPの世界へようこそ！」という見出しと、現在の時刻が表示されていれば成功です。

ブラウザでページを更新するたびに、時刻が変化するはずです。これは、JSPがアクセスされるたびにJavaのコードを実行して、ページの中身を動的に作っているということを意味します。

JSPの基本構文

前の章では、JSPファイルを作成し、Javaのコードを埋め込むことで「現在の時刻を表示する」ページを作成しました。ここからは、JSPファイルで使われる代表的な構文について解説します。どのようにJavaのコードをHTMLに差し込むのか、そしてJSP特有の書き方にはどんな種類があるのかを、順を追って学習していきましょう。

JSPの構成要素

JSPでは、以下の4種類の記述形式が用意されています。これらを使い分けることで、Javaの処理とHTMLの表示を同時に扱うことができます。

ディレクティブ

ディレクティブは、JSPファイル全体に関する設定を行うものです。最もよく使われるのは page ディレクティブです。

<%@ page contentType="text/html; charset=UTF-8" %>

この記述によって、出力するHTMLの文字コードがUTF-8になります。日本語を正しく表示するために必須です。

スクリプトレット

スクリプトレットは、JSPファイル内にJavaの処理を書くための領域です。

<%
  int year = java.time.LocalDate.now().getYear();
  String message = "今年は " + year + " 年です。";
%>
<p><%= message %></p>

この例では、Javaで現在の年を取得し、それを文字列として作成しています。そして <%= ... %> を使って、結果をHTMLに出力しています。

スクリプトレットの中ではJavaの文法がそのまま使えます。ただし、後述するようにスクリプトレットは新しい開発ではなるべく使わない方向にあります。

式（Expression）

式は、値をそのままHTMLとして出力したいときに使います。

<p>こんにちは、<%= "JSPユーザー" %>さん！</p>

上の例では、"JSPユーザー" という文字列がHTMLに挿入され、ブラウザには次のように表示されます。

こんにちは、JSPユーザーさん！

この書き方は非常にシンプルで、値を表示するだけであれば便利ですが、複雑な処理は向きません。

宣言

宣言は、JSPファイルの中でメソッドや変数を定義したい場合に使います。

<%! 
  private String getGreeting(String name) {
    return "こんにちは、" + name + "さん！";
  }
%>
<p><%= getGreeting("太郎") %></p>

このように、JSPファイルの中で小さな関数を定義して、それを式の中で呼び出すこともできます。ただし、JSPファイルに処理を詰め込みすぎると保守が難しくなるため、このような記述はできるだけ避け、外部のJavaクラスに処理を分けることが望まれます。

コメントの書き方

JSPには、HTMLのコメントと、JSP用のコメントの2種類があります。

<!-- これはHTMLのコメントです（ブラウザの「ページのソース」に表示されます） -->

<%-- これはJSPのコメントです（ブラウザには一切表示されません） --%>

HTMLのコメントはWebページに送信されるため、内容を見られる可能性があります。
一方、JSPのコメントはサーバー側で処理が止まるため、セキュリティ的に重要なコメントや開発者向けのメモはJSPのコメントで書くのが安全です。

スクリプトレットはなるべく使わない

JSPの構文として紹介しましたが、スクリプトレット（<% ... %>）の使用は、今では非推奨とされています。理由は以下の通り。

• HTMLとJavaのロジックが混ざることで、読みづらくなる
• 保守性が下がり、エラーが起きやすくなる
• JSTL（JSP標準タグライブラリ）やEL（式言語）の方がシンプルで安全に書ける

そのため、今後はJSTLやELを使って、できるだけ「Javaコードを書かずに表示を制御する方法」を覚えていくことが大切です。

次の章では、JSTLとEL（式言語）を使った“スクリプトレットを使わない”JSPの書き方を学びます。より読みやすく、安全なJSPの記述方法を習得していきましょう。

ELとJSTLでスクリプトレットのないJSPへ

ここまでの解説では、JSPの基本構文としてスクリプトレット（<% ... %>）などを紹介しました。
しかし近年のJSP開発では、スクリプトレットを使わない記述スタイルが主流となっています。

この章では、EL（Expression Language）とJSTL（JSP Standard Tag Library）という2つの仕組みを使って、JSPファイルの中にJavaコードを書かずに動的な表示を行う方法を学んでいきます。

EL（式言語）とは

EL（Expression Language）は、JSPの中でJavaの値を簡潔に記述するための言語です。
スクリプトレットのように <%= で囲む必要がなく、シンプルに ${変数名} と書くだけで値を出力できます。

<p>こんにちは、${userName} さん。</p>

このコードでは、Javaのサーバー側で userName という名前のデータ（属性）が用意されていれば、自動的にその値が表示されます。

JSTL（JSP標準タグライブラリ）とは

JSTLとは、JSP上で使える共通の処理をあらかじめタグ化したライブラリです。
たとえば、以下のような処理が可能です。

• 条件分岐（if）
• 繰り返し処理（forEach）
• 値のフォーマット（日付や数値）
• URLの生成

JSTLを使うことで、複雑なJavaの処理をわかりやすいタグで書くことができるようになります。

JSTLを使う準備

JSTLを使うには、JSTLライブラリの .jar ファイルを JSPプロジェクトの中に追加する必要があります。

手順

1. JSTLの最新版（Jakarta標準）をダウンロード
   → https://jakarta.ee/specifications/tags/
2. ダウンロードした jakarta.servlet.jsp.jstl-api-x.x.x.jar などの .jar ファイルを、Tomcatの lib フォルダ、またはプロジェクトの WEB-INF/lib フォルダにコピーします。
3. JSPファイルの先頭に、以下のようにタグライブラリを読み込む宣言を記述します。

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>

この設定により、<c:if> や <c:forEach> などのJSTLタグが使えるようになります。

JSTLで条件分岐をする

スクリプトレットで if 文を書かなくても、JSTLの <c:if> タグを使うことで簡単に条件分岐ができます。

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>
<c:if test="${loginUser != null}">
  <p>ようこそ、${loginUser.name} さん</p>
</c:if>

このように、loginUser という属性が null でなければ、挨拶文が表示されます。

JSTLで繰り返し表示をする

リストや配列の内容を繰り返し表示するには、<c:forEach> を使います。

サーバー側で、次のようにリストをセットしておきます（Servletなどで）：

List<String> names = List.of("太郎", "花子", "次郎");
request.setAttribute("nameList", names);

JSPファイルでは、次のように記述します：

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>
<ul>
  <c:forEach var="name" items="${nameList}">
    <li>${name}</li>
  </c:forEach>
</ul>

このコードにより、以下のようなHTMLが生成されます：

<ul>
  <li>太郎</li>
  <li>花子</li>
  <li>次郎</li>
</ul>

JSPをすっきり保つために

ELとJSTLを使うことで、JSPファイル内にJavaのコードを書く必要がなくなり、HTMLに近い構造を保ちながら動的な処理を行うことができます。
これは、JSPを読みやすく・保守しやすくする上でも非常に重要です。

また、デザイナーと共同で作業するようなプロジェクトでも、HTMLに近い見た目を保つことで、分業がしやすくなります。

フォームからデータを受け取る

JSPを使ってWebアプリケーションを作成する際、ユーザーの入力に応じて処理を行うことは非常に重要です。この章では、HTMLのフォームを使って入力されたデータを、JSPで受け取って表示する方法を学びます。

フォーム送信の流れ

フォームを使った処理は、次のような流れで行われます。

1. 入力フォームのあるページ（JSP）を表示する
2. ユーザーが名前などの情報を入力し、送信ボタンを押す
3. 入力内容がサーバーに送られる
4. 受け取ったJSPファイルがその情報を読み取り、画面に表示する

JSPではこの一連の流れを、HTMLとJavaの仕組みで簡単に実現できます。

フォームを作るJSP（entry.jsp）

まずは、名前を入力するための簡単なフォームを作成します。

entry.jsp

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>名前の入力</title>
</head>
<body>
  <h2>お名前を入力してください</h2>
  <form action="result.jsp" method="post">
    <label>名前：<input type="text" name="username" /></label>
    <input type="submit" value="送信" />
  </form>
</body>
</html>

このページでは、名前を入力して「送信」ボタンを押すと、result.jsp にPOSTリクエストでデータが送信されます。

データを受け取るJSP（result.jsp）

次に、送信されたデータを受け取って表示するためのJSPファイルを作成します。

result.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>入力結果</title>
</head>
<body>
  <h2>ようこそ！</h2>
  <p>あなたの名前は <strong><%= request.getParameter("username") %></strong> さんですね。</p>
</body>
</html>

ここでは、request.getParameter("username") というコードで、フォームから送られたデータを取得しています。

• request はJSPに自動で用意されているオブジェクト。
• getParameter("username") は、フォームのname="username" に対応した値を取得するメソッド。

ELを使って書き換える

JSTLやELを使えば、result.jsp をもっとすっきり書くこともできます。以下のようにリクエスト属性に値をセットしてから表示することで、式言語を活用できます。

Servlet側（例）

String name = request.getParameter("username");
request.setAttribute("username", name);
request.getRequestDispatcher("/result.jsp").forward(request, response);

result.jsp：

<%@ taglib prefix="c" uri="https://jakarta.ee/taglibs/core" %>
<p>こんにちは、${username} さん！</p>

ただし、Servletを使う方法はこのガイドの後半で詳しく扱いますので、今はまず request.getParameter() による受け取りに慣れることをおすすめします。

セッションとCookieでデータを保持する

JSPでは、ユーザーが入力した情報を「別のページでも使いたい」という場面がよくあります。
たとえば、ログイン状態を維持したり、前の画面で入力された名前を次の画面でも表示したりする場合です。

そのようなときに役立つのが セッション（Session） と クッキー（Cookie） です。
この章では、それぞれの役割と使い方を学びます。

セッションの基本操作

データの保存：

<%
  String name = request.getParameter("username");
  session.setAttribute("userName", name);
%>

このコードは、userName という名前でセッションに値を保存します。

データの取得：

<%
  String name = (String) session.getAttribute("userName");
%>
<p>ようこそ、<%= name %> さん</p>

このようにすれば、前のページで保存した値を、別のページで取り出して使うことができます。

セッションの有効期間と注意点

セッションは、ユーザーがブラウザを閉じるか、一定時間操作をしないと自動的に無効になります。Tomcatの初期設定では、30分間操作がないとセッションが切れます。

また、多くの情報をセッションに保存しすぎると、サーバーのメモリを圧迫する可能性があるため、用途を絞って使うことが大切です。

Cookieとは

Cookie（クッキー）は、情報をユーザーのブラウザに保存する仕組みです。
サーバー側から「この情報を保存しておいてください」と指示すると、ブラウザがその内容を保持し、次回以降のアクセス時にその情報を自動的に送信してきます。

Cookieの基本操作

Cookieの作成と送信：

<%
  String name = request.getParameter("username");
  Cookie cookie = new Cookie("userName", name);
  cookie.setMaxAge(60 * 60); // 1時間（秒単位）
  response.addCookie(cookie);
%>

Cookieの取得：

<%
  String name = "";
  Cookie[] cookies = request.getCookies();
  if (cookies != null) {
    for (Cookie c : cookies) {
      if ("userName".equals(c.getName())) {
        name = c.getValue();
      }
    }
  }
%>
<p>こんにちは、<%= name %> さん</p>

このように、Cookieを使えば、ブラウザに保存された情報を次回のアクセス時にも利用できます。

セッションとCookieの使い分け

一時的な状態保持（ログイン情報など）にはセッション、
ユーザーに関連する設定（言語選択やテーマなど）にはCookieがよく使われます。

JSPで簡単なアンケートアプリを作ろう

JSPを使ってWebアプリケーションを作るには、「複数ページにまたがる処理」を整理することが大切です。
この章では、3画面構成のアンケートアプリを作り、情報の受け渡し、表示の切り替え、セッションの活用を総合的に体験します。

アプリの構成と目的

このアプリでは、以下のような流れでユーザーにアンケートに答えてもらい、最終画面でまとめて表示します。

1. 入力画面：名前と好きな色を入力（form）
2. 確認画面：入力された内容を表示（セッションで一時保持）
3. 完了画面：ありがとうメッセージと入力内容の最終確認

プロジェクト構造

jsp-demo/
├─ input.jsp     （入力画面）
├─ confirm.jsp   （確認画面）
└─ thanks.jsp    （完了画面）

入力画面：input.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>アンケート入力</title></head>
<body>
  <h2>アンケートにご協力ください</h2>
  <form action="confirm.jsp" method="post">
    <p>お名前：<input type="text" name="userName" /></p>
    <p>好きな色：
      <select name="favoriteColor">
        <option value="赤">赤</option>
        <option value="青">青</option>
        <option value="緑">緑</option>
      </select>
    </p>
    <input type="submit" value="確認画面へ" />
  </form>
</body>
</html>

確認画面：confirm.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<%
  String userName = request.getParameter("userName");
  String favoriteColor = request.getParameter("favoriteColor");

  session.setAttribute("userName", userName);
  session.setAttribute("favoriteColor", favoriteColor);
%>
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>確認画面</title></head>
<body>
  <h2>以下の内容でよろしいですか？</h2>
  <p>お名前：<%= userName %></p>
  <p>好きな色：<%= favoriteColor %></p>
  <form action="thanks.jsp" method="post">
    <input type="submit" value="送信する" />
  </form>
</body>
</html>

完了画面：thanks.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<%
  String name = (String) session.getAttribute("userName");
  String color = (String) session.getAttribute("favoriteColor");

  // 必要があればセッションのデータを破棄
  session.invalidate();
%>
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>送信完了</title></head>
<body>
  <h2>ご協力ありがとうございました！</h2>
  <p><strong><%= name %></strong> さんの好きな色は <strong><%= color %></strong> ですね。</p>
</body>
</html>

たとえば、名簿の中から「Sで始まる名前だけ」を取り出して、「大文字」に変えて、「新しいList」にしたいとします。このような処理を、上から順番に読める形で書けるのがStream APIです。

最初から難しい用語を覚える必要はありません。まずは「データを流して、途中で絞り込みや変換をして、最後に結果を受け取る」と考えればOKです。

この記事では、Stream APIの意味、for文との違い、filter・map・collectの読み方を、初心者向けにできるだけかみ砕いて解説します。

なお、この記事で扱うStreamは、java.util.streamのStream APIです。ファイルの読み書きで出てくるInputStreamやOutputStreamとは別物です。ファイル入出力のストリームは、Java.ioを使用したファイルの読み書きで解説しています。

まず結論：Stream APIは「データを順番に加工する書き方」

Stream APIを理解するときは、次の3つだけを先に押さえてください。

• 元になるデータを用意する
• 途中で、必要なものだけ残したり、形を変えたりする
• 最後に、Listなどの結果として受け取る

この流れをコードで書くと、だいたい次の形になります。

元のデータ.stream()
        .途中の処理()
        .途中の処理()
        .最後に結果を受け取る処理();

専門用語では、途中の処理を「中間操作」、最後の処理を「終端操作」と呼びます。ただ、初心者のうちは、まず「途中の処理」と「最後の処理」と考えれば十分です。

何に困ったときにStream APIを使うの？

Stream APIは、複数のデータをまとめて扱うときによく使います。

たとえば、次のような場面です。

• Listの中から条件に合うデータだけ取り出したい
• Listの中身を別の形に変換したい
• 条件に合うデータが何件あるか数えたい
• 最初の1件だけ取り出したい

つまりStream APIは、「データの一覧をどう加工するか」を書くときに便利です。

まだListやMapがあやふやな場合は、先にJavaのListやMapの使い方を読むと理解しやすくなります。

まずはこのコードを読めればOK

Stream APIの基本は、次のコードでかなりつかめます。

List<String> result = names.stream()
        .filter(name -> name.startsWith("S"))
        .map(name -> name.toUpperCase())
        .collect(Collectors.toList());

このコードは、次のように読みます。

この読み方ができれば、最初の一歩としては十分です。

for文で書く場合と比べてみる

Stream APIでできることは、for文でも書けます。まず、for文で書くと次のようになります。

List<String> result = new ArrayList<>();

for (String name : names) {
    if (name.startsWith("S")) {
        result.add(name.toUpperCase());
    }
}

これはこれで分かりやすい書き方です。ただし、処理の流れを読むには、resultを作って、for文で回して、if文で判定して、addする、という手順を追う必要があります。

同じ処理をStream APIで書くと、次のようになります。

List<String> result = names.stream()
        .filter(name -> name.startsWith("S"))
        .map(name -> name.toUpperCase())
        .collect(Collectors.toList());

Stream APIでは、「何をしたいのか」が上から順番に並ぶため、慣れると処理の目的を読み取りやすくなります。

Stream APIは「for文より偉い書き方」ではありません。データを絞り込み、変換し、結果を作る流れを見せたいときに便利な書き方です。

filter・map・collectを1つずつ理解する

初心者が最初に覚えるべきなのは、filter・map・collectの3つです。

filterは「条件に合うものだけ残す」

filterは、条件に合うデータだけを残す処理です。

.filter(name -> name.startsWith("S"))

この例では、「Sで始まる名前だけ残す」という意味です。条件に合わないTanakaのような名前は、次の処理へ進みません。

mapは「別の形に変える」

mapは、データを別の形に変える処理です。

.map(name -> name.toUpperCase())

この例では、名前を大文字に変えています。SatoはSATOになります。

collectは「最後に結果を受け取る」

collectは、途中で処理した結果を最後に受け取るための処理です。

.collect(Collectors.toList())

この例では、処理結果を新しいListとして受け取っています。

ここで出てくるname -> ...の部分はラムダ式です。ラムダ式が分からない場合は、Javaのラムダ式の記事をあわせて読むと理解しやすくなります。

実際に動くサンプルコード

全体のコードは次の通りです。

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

public class StreamSample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Sato", "Suzuki", "Tanaka", "Sasaki");

        List<String> result = names.stream()
                .filter(name -> name.startsWith("S"))
                .map(name -> name.toUpperCase())
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

実行すると、次のように表示されます。

[SATO, SUZUKI, SASAKI]

TanakaはSで始まらないため、filterの時点で除外されています。

初心者がつまずきやすいポイント

Stream APIで最初につまずきやすいポイントを整理します。

特に大事なのは、Streamは元のListを直接書き換えるものではないという点です。

次のコードでは、大文字にした結果はresultに入ります。元のnamesがそのまま大文字に変わるわけではありません。

List<String> result = names.stream()
        .map(name -> name.toUpperCase())
        .collect(Collectors.toList());

また、findFirst()のようなメソッドではOptionalが出てくることがあります。Optionalについては、JavaのOptionalとは？で解説しています。

Stream APIはいつ使う？いつ使わない？

Stream APIは、次のような処理に向いています。

• Listから条件に合うものだけ取り出す
• データを別の形に変換する
• 件数を数える
• 処理の流れを短く、読みやすく見せたい

一方で、処理の途中で複雑な分岐が何度も出てくる場合や、for文の方が素直に読める場合は、無理にStream APIを使う必要はありません。

Stream APIは、コードを短くするためだけの道具ではありません。データをどう加工して、最後に何を得たいのかを見やすくするための道具です。

関連して読みたい記事

Stream APIは、Javaの他の基礎知識とつながっています。

• Java：ListやMapの使い方を3分で1から解説
• Java：ラムダ式（lambda）を3分でわかりやすく
• Javaの関数型インターフェースを1分でわかりやすく
• JavaのOptionalとは？nullを安全に扱う基本
• Java学習ロードマップ完全版

まとめ

JavaのStream APIは、Listなどのデータを「処理の流れ」として書くための仕組みです。

初心者のうちは、まず次の3つだけ覚えてください。

• filterは、条件に合うものだけ残す
• mapは、別の形に変える
• collectは、最後に結果を受け取る

最初から難しいメソッドを全部覚える必要はありません。まずは、names.stream().filter(...).map(...).collect(...)という流れを読めるようになればOKです。

初心者のうちは「コードを実行できる形にする作業」と考えるとつかみやすいです。ただし実務では、それだけではありません。コンパイルは、文法ミスや型の不一致を実行前に見つけたり、プログラムを効率よく動かすための準備をしたりする大事な工程でもあります。

たとえばJavaで `HelloWorld.java` というファイルを書いたあと、`javac HelloWorld.java` を実行すると `HelloWorld.class` というファイルができます。この「.java から .class へ変換する」作業がコンパイルです。Javaの作成から実行までの具体的な手順は、関連する Javaプログラムの作成から実行まで でも整理されています。

コンパイルは「翻訳」よりも「実行前の整備」に近い

コンパイルはよく「翻訳」に例えられます。人間が読めるプログラミング言語を、コンピュータが扱いやすい言葉に変換する、という説明です。この例えはかなり分かりやすいのですが、実務で使える理解にするなら、もう一歩だけ足すとよいです。

コンパイルは単なる翻訳ではなく、実行前にコードを整え、間違いを検査し、実行環境へ渡せる形にする工程です。つまり、書いたコードをそのまま走らせる前に「この書き方で本当に大丈夫か」「実行に必要な形へ変換できるか」を確認してくれる関門だと考えると、エラーの意味も読みやすくなります。

たとえば、次のようなJavaコードを書いたとします。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

このコードは人間には読めますが、Java仮想マシンが実行するには、まず `javac` によってバイトコードへ変換されます。ここでクラス名、括弧、セミコロン、型などの基本ルールも確認されます。

まず全体の流れを図で見る

コンパイルを最初に理解するときは、定義だけを読むよりも、何が何に変わるのかを見た方が早いです。次の図は、ソースコードがコンパイラを通り、実行用の形になり、最後に結果を確認するまでの流れを示しています。

この図で見てほしいのは、コンパイルが「コードを書く」と「プログラムを実行する」の間にあることです。初心者は、コードを書いたらすぐ動くと思いがちですが、多くの言語ではその間に変換や検査の工程があります。

実務では、この途中で止まることがよくあります。たとえば、コンパイルの段階で止まれば「実行前に見つかった問題」です。一方、コンパイルは通ったのに動かすと落ちる場合は「実行時に起きた問題」です。この切り分けができるだけで、エラー対応はかなり楽になります。

コンパイルで実際に何が作られるのか

コンパイル後に何が作られるかは、言語や実行環境によって違います。すべてがCPUの機械語になる、という理解だけだと少し狭すぎます。

代表的には、次のような変換があります。

ここで大切なのは、コンパイル後の形が必ずしも「最終的な機械語」とは限らないことです。Javaのように、いったんバイトコードへ変換し、その後JVMが実行する言語もあります。TypeScriptのように、JavaScriptへ変換してから実行するケースもあります。

Javaの開発環境で出てくるJDK、JRE、JVMの関係は、Javaの開発環境構築 と合わせて読むと整理しやすいです。コンパイルという言葉は、こうした実行環境の話とセットで出てくることが多いからです。

コンパイルエラーはどこで起きるのか

コンパイルエラーとは、コンパイラがコードを変換できないと判断した状態です。言い換えると、プログラムを動かす前に「このままでは実行用の形にできません」と止めてくれている状態です。

たとえば、次のJavaコードにはセミコロンがありません。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!")
    }
}

この状態でコンパイルすると、環境によって表現は少し異なりますが、次のようなエラーになります。

HelloWorld.java:3: error: ';' expected
        System.out.println("Hello, world!")
                                           ^
1 error

この出力で見るべきポイントは3つです。`HelloWorld.java:3` はファイル名と行番号、`';' expected` は「セミコロンが必要です」という意味、`^` はコンパイラが怪しいと見ている位置です。

コンパイルエラーは、初心者にとっては怖く見えます。ですが、実務ではかなりありがたい存在です。なぜなら、ユーザーに見せる前、本番環境に出す前、あるいはチームの共有ブランチへ入れる前に、基本的なミスを止めてくれるからです。

ビルド・リンク・実行との違い

コンパイルを理解するときに、混同しやすい言葉がいくつかあります。特に「ビルド」はかなり近い言葉です。

ざっくり言うと、ビルドは完成品を作る一連の作業、コンパイルはその中に含まれる変換作業です。ビルドの全体像は ビルドとは？ の記事でも扱われていますが、ここではコンパイルとの違いに絞って見ておきます。

CやC++では、コンパイルとリンクの違いが特に重要です。あるファイル単体の文法は正しくても、別ファイルにあるはずの関数やライブラリが見つからないと、リンクの段階で止まることがあります。

一方、JavaやTypeScriptでは「ビルド」と言ったときに、コンパイル、型チェック、ファイル変換、依存関係の解決などがまとめて行われることが多いです。実務で「ビルドが落ちた」と言われたら、まずログを見て、それがコンパイルエラーなのか、テスト失敗なのか、依存関係の問題なのかを切り分けます。

コンパイル言語とインタプリタ言語の違い

プログラミング言語の説明では、よく「コンパイル言語」と「インタプリタ言語」という分け方が出てきます。初心者向けには、実行前にまとめて変換するのがコンパイル言語、実行しながら解釈するのがインタプリタ言語、と理解すると入り口としては十分です。

代表例を整理すると、次のようになります。

ただし、現代の実行環境では、この分類はかなり混ざっています。JavaScriptはブラウザ内部でJITコンパイルされることがありますし、Pythonも内部的にはバイトコードを使います。

そのため実務では、「この言語はコンパイルするか、しないか」と単純に覚えるより、どのタイミングで、何に変換され、どんなエラーがその段階で出るのかを見る方が役に立ちます。

コンパイル時と実行時を分けて考える

現場で特に大切なのが、「コンパイル時」と「実行時」を分ける考え方です。コンパイル時は、コードを変換している段階です。実行時は、変換されたプログラムを実際に動かしている段階です。

この違いが分かると、エラーの調べ方が変わります。たとえば、型が合わない、存在しない変数を使っている、文法が崩れている、といった問題はコンパイル時に見つかりやすいです。一方、ファイルが存在しない、ネットワーク接続に失敗する、ユーザー入力が想定外だった、という問題は実行時に起きることが多いです。

たとえば `int age = "20";` のように、数値型に文字列を入れようとすると、Javaではコンパイル時に止まります。これはコンパイラが「この型の組み合わせはおかしい」と実行前に判断できるからです。

一方、ユーザーが入力したファイル名を開こうとして、そのファイルが実際には存在しなかった場合、コンパイル時には分からないことがあります。ファイルがあるかどうかは、プログラムを動かす環境やその瞬間の状態に依存するからです。

この切り分けは、バグ調査でかなり効きます。コンパイル時に落ちているなら、まずコード、型、依存関係、設定ファイルを見ます。実行時に落ちているなら、入力データ、環境変数、ネットワーク、ファイル、DBの状態を見ます。

トランスパイル・JIT・最適化も押さえる

コンパイルの話をしていると、トランスパイル、JIT、最適化という言葉も出てきます。初心者の段階で細部まで暗記する必要はありませんが、現場で言葉を聞いたときに混乱しない程度には整理しておくと安心です。

トランスパイルとは、あるプログラミング言語のコードを、別のプログラミング言語のコードへ変換することです。代表例はTypeScriptです。TypeScriptで書いたコードは、多くの場合JavaScriptへ変換されてからブラウザやNode.jsで実行されます。

// TypeScript
const message: string = "Hello";
console.log(message);

// 変換後のJavaScriptのイメージ
const message = "Hello";
console.log(message);

JITは Just-In-Time の略で、実行中に必要な部分を高速な形へ変換する仕組みです。JavaのJVMやJavaScriptエンジンなどで出てくる考え方です。最初から全部を完全な機械語へ変換して終わり、というより、実行しながらよく使う処理を効率化するイメージです。

最適化とは、プログラムの意味を変えずに、より速く、より無駄なく動くように変換することです。たとえば、不要な計算を減らしたり、同じ結果になる処理を効率よく置き換えたりします。ただし、初心者が最初から最適化を意識しすぎる必要はありません。まずは読みやすく正しいコードを書き、コンパイルエラーを読めるようになる方が大切です。

実務でコンパイルをどう見るか

現場でコンパイルという言葉を聞く場面は、思ったより多いです。たとえばIDEで赤い波線が出る、ターミナルで `mvn package` が失敗する、GitHub ActionsなどのCIでビルドが落ちる、といった場面です。

実務でよく見るコマンドには、次のようなものがあります。

javac HelloWorld.java
mvn package
gradle build
npm run build
tsc
go build
cargo build

これらはすべて同じことをしているわけではありません。`javac` はJavaソースをバイトコードへ変換するコンパイラです。`mvn package` や `gradle build` は、コンパイルだけでなくテストや成果物作成まで含むことがあります。`tsc` はTypeScriptをJavaScriptへ変換しながら型チェックも行います。

現場で大切なのは、コマンド名を丸暗記することではありません。失敗したときに、ログのどこを見るかです。最初のエラー、対象ファイル、行番号、期待された型、見つからなかったライブラリ名。このあたりを拾えるようになると、コンパイルエラーはかなり読みやすくなります。

Javaプロジェクト管理ツールを使う場合は、Mavenとは？ のようなビルドツールの記事も一緒に読むと、コンパイルがプロジェクト全体の流れのどこに入るかを理解しやすくなります。

よくあるミスと読み解き方

コンパイルでつまずく原因は、ある程度パターンがあります。初心者のうちは「全部わからないエラー」に見えますが、実際にはいくつかの型に分けられます。

注意点として、エラーが10個、20個と出ていても、最初の1個が本当の原因であることがよくあります。最初の文法ミスのせいで、後続の行もまとめて間違って見えてしまうからです。

実務では、まず一番上のエラーを直し、もう一度コンパイルします。これを繰り返す方が、全部のエラーを一気に読もうとするより安全です。コンパイルエラーは、プログラムからの拒絶ではなく、修正箇所を教えてくれるログだと考えると気持ちも少し楽になります。

コンパイルを理解すると、開発の流れが見える

コンパイルを理解すると、プログラムが「書いたらすぐ動く魔法」ではなく、いくつかの工程を通って動いていることが見えてきます。

ソースコードを書く、コンパイルする、必要ならリンクする、テストする、実行する。本番環境へ出す前にはCIで同じような確認が走る。こうした流れが分かると、エラーが出たときにも「今どの段階で止まっているのか」を考えられます。

初心者が最初に押さえるべきポイントは、次の3つです。

• コンパイルは、ソースコードを実行環境が扱いやすい形へ変換する作業
• コンパイルエラーは、実行前に見つかった問題
• ビルドは、コンパイルを含むより広い作業全体

この3つが分かっていれば、エラーメッセージやビルドログを読むときの土台になります。最初はすべて理解できなくても大丈夫です。ファイル名、行番号、エラーの種類を一つずつ拾うところから始めれば、コンパイルは怖いものではなくなっていきます。

ステップ１：Javaファイルの作成

まず、ステップ１：Javaのプログラムを書いて保存します。基本的な構文ルールはこちら（関連　Javaの1stステップ：基本的な構文ルールを１分で復習！）を参考にしてみてください。

Javaファイル作成手順

1. テキストエディタを開く
   • メモ帳、VS Code、Eclipseなどのテキストエディタを使用します。どのような手段を使ってもOKで、どの方法でも最終的な結果に影響することはありません。
2. コードを入力する
   • 以下のコードを入力します。これは「Hello World」と表示するシンプルなプログラムです。

// HelloWorld.java

public class HelloWorld {
    public static void main(String[] args) {
        // "Hello, World!" をコンソールに出力します
        System.out.println("Hello, World!");
    }
}

3. ファイルを保存する：
   • HelloWorld.java という名前で保存します。保存する場所はPCのデスクトップでもドキュメントフォルダでもどこでもOK。（Javaプログラムはこの保存したディレクトリ上でコンパイル～実行することになります。）
   • ファイル名とクラス名（この場合は HelloWorld）は同じにする必要があります。

ステップ２：Javaファイルのコンパイル

次に、Javaファイルをコンパイルして、コンピュータが理解できる形（バイトコード）に変換します。

コンパイル手順

1. コマンドラインを開く
   • Windowsの場合は「コマンドプロンプト」、MacやLinuxの場合は「ターミナル」を開きます。
2. 保存したディレクトリに移動する
   • cd コマンドを使って、HelloWorld.java を保存したディレクトリに移動します。
   • 例：ファイルがデスクトップに保存されている場合「cd Desktop」
3. コンパイルコマンドを入力する
   • 以下のコマンドを入力してコンパイルします。
     javac HelloWorld.java
4. バイトコードファイルが生成
   • コンパイルが成功すると、HelloWorld.class というファイルが生成されます。

javac -encoding UTF-8 HelloWorld.java

ステップ３：プログラムの実行

最後に、生成されたバイトコードファイルを実行します。

プログラム実行手順

1. 実行コマンドを入力する
   • 以下のコマンドを入力してプログラムを実行します。
     java HelloWorld
     
   • ここで指定している「HelloWorld」はJavaの「クラス名」です。クラスを指定してjavaコマンドを実行することで.classファイルが動きます。
2. プログラムの出力を確認
   • コンソールに Hello, World! と表示されます。

これで、Javaプログラムの作成～実行までが完了です。

Javaは「文法を覚える言語」ではなく、「文法・設計・実務」の3層で理解すると一気に見通しがよくなります。

このページは、Java理解までの道筋を1本につないだページです。Javaを理解するための全体地図、今の現在地、次に読むべき記事、これから追加すべきテーマまで、Java初心者の方が迷わないように「つながる形」で設計しています。当サイトのJava カテゴリー 77本を土台に、初心者から実務の入口まで迷わず進めるロードマップとしてまとめました。

Java学習でいちばん大事なのは、「全部を一気に理解しよう」としないことです。今いる位置と、次に登る段差が分かれば、学習はかなり進めやすくなります。

先に結論: Javaは「文法」「設計」「実務」の3層で理解すると腹落ちする

Java学習の全体像は、まずこの3層で見るのがおすすめです。

つまり、Java学習は単純な一直線ではありません。「文法だけ終われば理解完了」ではなく、設計と実務までつながったときに初めて「Javaが分かった感覚」になります。

30秒で分かる現在地チェック

今の自分がどこにいるかを先に把握すると、読む順番を決めやすくなります。

• まだ Java を動かしたことがない: 環境構築と最初の一歩から始める段階です
• if や for は何となく分かるが、class が苦手: 文法から設計に上がる途中です
• class や constructor は読めるが、extends や interface で混乱する: オブジェクト指向を固める段階です
• null や try-catch で手が止まる: 実務につながる安全な書き方を学ぶ段階です
• List / Map / Optional / lambda が苦手: Javaらしい実務コードへ進む手前です
• Maven / JUnit / JSP までは出てくるが、全体がつながらない: 知識はあるので、体系化が必要な段階です

Java完全ロードマップ: 9段階で理解する

ここからは、Java学習を9段階に分けて整理します。各段階ごとに、何が分かるようになるか、どこでつまずきやすいか、次に読むべき記事をまとめます。

第1段階: 環境構築と「Javaが動く仕組み」を理解する

この段階のゴールは、Javaのコードを自分のPCで動かし、JDK、JRE、JVM の違いがふんわりでも説明できることです。

• ここで身につけること: Javaを実行する流れ、コンパイルと実行の違い、開発環境の準備
• つまずきやすい点: 「書いたコードがそのまま動く」と思ってしまうこと
• 先に読む記事: Javaの開発環境構築、Javaプログラムの作成から実行まで、Javaコマンドの基本
• 理解できたサイン: javac と java の役割を言葉で説明できる

第2段階: 基本文法と制御構文を身につける

ここは「Javaで処理を書く」ための土台です。if や for が分からないまま先へ進むと、その後の理解がかなり苦しくなります。

• ここで身につけること: 変数、演算子、条件分岐、繰り返し、スコープ
• つまずきやすい点: 条件式は読めても、自分で組み立てると混乱すること
• 先に読む記事: Javaの1stステップ、if文、switch文、for文、while文、演算子
• 理解できたサイン: 「入力値によって処理を分ける」「繰り返して合計を出す」が自力で書ける

第3段階: 型・文字列・データの扱い方を固める

Javaは型を大事にする言語です。ここを曖昧にすると、後で class や collection を読んだときに急に難しく感じます。

• ここで身につけること: プリミティブ型と参照型、String、ラッパークラス、型変換、enum、record
• つまずきやすい点: 「文字列もオブジェクト」「型が違うとできることが違う」という感覚が弱いこと
• 先に読む記事: プリミティブ型と参照型、Stringの基本、StringBuilder、ラッパークラス、enum、record
• 理解できたサイン: 「int と Integer」「String と StringBuilder」の違いを説明できる

第4段階: class・method・constructor を理解する

Javaの大きな山場はここです。class の意味が分かると、「Javaは部品を組み立てる言語なんだ」と見えてきます。

• ここで身につけること: class と instance、method、constructor、this、static、package
• つまずきやすい点: 「クラスは設計図」「インスタンスは実体」という説明が抽象的に感じること
• 先に読む記事: クラス/インスタンス、メソッド、コンストラクタ、this、static、package/import
• 理解できたサイン: 簡単なクラスを自分で作り、フィールドとメソッドを分けて書ける

第5段階: 継承・interface・多態性で設計の考え方を学ぶ

初心者が「急に難しくなった」と感じやすいのがこの段階です。ただ、ここは暗記よりも「なぜ分けるのか」を理解すると進みやすくなります。

• ここで身につけること: 継承、オーバーライド、抽象クラス、インターフェース、カプセル化、内部クラス
• つまずきやすい点: extends と implements の役割が混ざること
• 先に読む記事: extends、override、interface、abstract class、アクセス修飾子、内部クラス
• 理解できたサイン: 「共通化したいもの」と「実装を分けたいもの」を言葉で整理できる

第6段階: 例外・null・安全なコードの書き方を学ぶ

実務で「落ちにくいコード」を書くための入口です。ここを学ぶと、初心者っぽいコードから一段抜けられます。

• ここで身につけること: try-catch、try-with-resources、NullPointerException、Optional、I/O
• つまずきやすい点: エラーが出たあとに対処するのか、最初から避けるのかが混ざること
• 先に読む記事: 例外処理の基本、try-with-resources、NullPointerException、Optional、orElse と orElseGet、of と ofNullable、Java.io
• 理解できたサイン: null 対応を行き当たりばったりではなく、方針を持って書ける

第7段階: コレクション・ジェネリクスで実務コードの読解力を上げる

この段階に入ると、Javaのコードが一気に実務っぽくなります。今のJavaカテゴリでは、この領域が今後さらに強化したいポイントです。

• ここで身につけること: 配列、List / Map の基本、ジェネリクス、比較、コピーの考え方
• つまずきやすい点: <T> の意味と、「複数のデータをどう持つか」が直感的でないこと
• 先に読む記事: 配列、コレクションフレームワーク、ジェネリクス、equals、Comparable、シャローコピーとディープコピー
• 理解できたサイン: 配列・List・Map の役割の違いを、例を使って説明できる

第8段階: lambda・var・sealed class でモダンJavaに慣れる

Java 8 以降のコードを読むには、この段階の理解が重要です。ここを超えると、少し新しめのJavaコードにも抵抗が減ります。

• ここで身につけること: lambda、Functional Interface、var、pattern matching、sealed class
• つまずきやすい点: ラムダ式を「短い書き方」だと思って終わってしまうこと
• 先に読む記事: ラムダ式、関数型インターフェース、var、pattern matching for instanceof、sealed class
• 理解できたサイン: 「なぜこのコードは匿名クラスではなくラムダ式なのか」を説明できる

第9段階: ツール・テスト・Web・内部動作で実務の入口に立つ

最後は、現場でよく出る周辺知識です。ここまで来ると、「Javaを勉強した」ではなく「Javaで仕事の話ができる」状態に近づきます。

• ここで身につけること: Maven、POM、JUnit、Log4j、JSP、リフレクション、メモリ
• つまずきやすい点: 書き方の知識と、ツールの役割が頭の中でつながらないこと
• 先に読む記事: Maven、POMファイル、JUnit、Log4j、JSPファイル超入門、Javaメモリ管理、リフレクション
• 理解できたサイン: 「開発・テスト・実行・保守」の流れの中で各ツールの役割を説明できる

今のJavaカテゴリで強いところと、これから埋めたいところ

現状の77本を俯瞰すると、強いのは次の3つです。

• 基本文法と制御構文
• class / constructor / extends / interface まわりの設計基礎
• null / Optional 周辺の初学者向け解説

逆に、カリキュラムとして完成度をさらに上げるなら、次の4領域が重要です。

• コレクション各論: ArrayList、HashMap、Set、Queue
• モダンJava各論: Stream API、Collectors、メソッド参照、Optional応用
• 例外の深掘り: throw / throws、例外分類、カスタム例外
• 実務導線: JDBC、Servlet、Spring Boot、並行処理

今後作るべきページ一覧

ここでは、「なぜそのページが必要か」が分かるように、優先度別に整理します。

優先度A: 初学者が途中で止まらないために必要なページ

優先度B: 「分かったつもり」を実務読解に変えるページ

優先度C: Javaを実務レベルに伸ばすページ

3か月の制作計画: 何から作ると読者に効くか

制作順も重要です。難しいテーマから増やすより、読者が途中で止まりやすい箇所を先に埋めるほうが、カテゴリ全体の価値が上がります。

運用ルールも先に決めておくと強い

• 新しいJava記事を公開したら、このロードマップと理解ルートガイドの両方を更新する
• 新規記事には最低3本の内部リンクを入れて、孤立記事を作らない
• 似たテーマは連続公開して、クラスターとして読める状態を作る
• 毎月1回、流入と離脱ポイントを見て優先順位を見直す
• 「読者が次に何を読むか」が見えるように、各記事で次の一歩を明示する

このロードマップのゴール

このページのゴールは、Java記事を並べることではありません。読者が「Javaは何をどう学べば分かるのか」をイメージできて、いま自分がどこにいて、次に何を読むべきかが見える状態を作ることです。

実際にどの順で読めば理解がつながるかを見たい方は、Java理解ルートガイド を読むのがおすすめです。ロードマップで全体をつかみ、ルートガイドで実際に進む。この2本をセットで使うと、Java理解までの道筋がかなり見えやすくなります。

画面バリアントとは、その名の通り１つ１つの画面に対して設定するバリアントのことで、画面の表示/非表示や初期値などの項目属性の集合体。画面バリアントの集合体が、トランザクションバリアントです。

この記事では画面バリアントの登録方法までを３分で解説します。

SAPエンジニアであれば常識として知っておきたい超・基本知識です。是非最後までご覧ください。

画面バリアントとは？

画面バリアントとは、画面１つ１つに対する表示・非表示などの項目属性のセットです。

文字の説明だけではイメージを持ちづらいはずなので、早速画面バリアントの設定画面の一例をご覧ください。

ご覧のように、各項目ごとに 値保持 / 出力専用 / 非表示 / 必要 の設定を行えるようになっています。

画面バリアント設定：値保持（W.content）

値保持にチェックを入れることで、内容欄の値を初期値として表示させることができます。

例えば、ビジネスパートナの住所タブの項目に値保持の設定を行っていた場合。以下のような画面が表示されることになります。

あくまでも初期値なので変更は可能です。

画面バリアント設定：出力専用（Output only）

出力専用にチェックすると、当該項目は変更することができなくなります。

画面バリアント設定：非表示（Invisible）

その名の通りです。非表示設定を行うと、当該項目は画面上から見えなくなります。

勘違いしてはいけないのが、あくまでも画面上から「見えなくなるだけ」であって存在自体がなくなるわけではありません。つまり、本来必須入力の項目に対して非表示設定をしてしまうと必ずエラーが出る画面を作成してしまうことにつながります。

画面バリアント設定：必要（Required）

必須入力させたい場合にチェックします。

SHD0：画面バリアントの登録

さて、先に画面バリアントのイメージを掴んでもらうために設定内容の解説から進めてきましたがここからは実際に画面バリアントの登録方法を解説します。

と言っても、実は非常に簡単。

画面バリアントを設定したいトランザクションコードを入力。画面バリアントタブにて画面バリアント名を入力し登録ボタンを押すだけ。

あとは、対象のトランザクションコードが起動され、いつもと同じように画面に値を入力していきます。画面の入力が完了すると、先ほど同様以下の設定画面が表示される仕組みです。

トランザクションバリアントとは？

画面バリアントはあくまでも１つの画面に対する設定値をまとめたものでしかありません。そして、もう少し具体的に言えば画面バリアントは、トランザクションバリアントの１構成要素でしかありません。

実際には、１つ以上の画面バリアントから構成されるトランザクションバリアントをトランザクションコードに割り当てることによって画面の表示制御を行うわけです。

トランザクションコード：SHD0の画面に戻ります。

Transaction Variantタブ でトランザクションバリアント名称を入力。そして、そのトランザクションバリアントを構成する画面バリアントを割り当てていきます。

割り当てる画面バリアントの個数は１つ以上で何個あってもOKです。

バリアントトランザクションの作成

最後に、バリアントトランザクションを作成します。

ややこしいのですが、バリアントトランザクションとはトランザクションコードとトランザクションバリアントの組み合わせです。

つまり、どのトランザクションコードをどのバリアントトランザクションを用いて利用するか？を設定したトランザクションコードを新規に作成するイメージです。

実際のSAPユーザにはバリアントトランザクションを解放することで、表示・非表示設定のされた画面を見せる仕組みとなっているのです。

最後、この章だけ唐突に理解しがたい表現となっているため何度か読み返しをおすすめします。

バリアントトランザクションの作成方法

バリアントトランザクションの作成方法は、以下の記事で解説しております。

トランザクションコードをアドオンで作成する方法も合わせて学べますので是非この機会に合わせてご覧ください。

【SAP】トランザクションコードの新規登録を３分で解説：SE93

【初心者向け】SAPでトランザクションコードを新規に１から登録する方法を画像付きで解説します。また、トランザクションコードにバリアントを紐づける「バリアントトランザクションコード」などの応用知識も合わせて解説します。

it-biz.online

2026.04.26

ABAPを１から勉強したい方は

初めてABAPを勉強するのは結構難しいですよね。

でもその悩みを抱えているのは一人じゃありません。全てのABAP使いが同じ道を進んできました。

ABAPをはじめとするプログラミングスキルを武器に、時間と場所に捉われない自由な生き方を目指してみませんか？

あなたの技術、もっと価値ある場所で活かしませんか？
SAPエンジニアのキャリア支援はこちらから↓

No.1　>　外資系・IT業界などハイクラスの転職なら【アクシスコンサルティング】
4人に1人のコンサルタントが選ぶパートナー！
ビッグ4やアクセンチュアへの転職を実現し年収1000万へ。

No.2　>　IT・Web転職特化エージェント【レバテックキャリア】
サービス利用者数20万人突破。
平均年収アップ率77%であなたの転職成功を保証します。

No.3　>　リクルートエージェント
＼転職支援実績NO.1／
応募が殺到しすぎるが故に・・・非公開にせざるを得ない魅力的な求人が多数！

読者料典　【完全無料】ABAP：学習カリキュラム　←こちらから！