数値の絶対値を返します (int, long, float, double に対応)。
int num = -10;
int absNum = Math.abs(num); // absNum は 10
double dbl = -3.14;
double absDbl = Math.abs(dbl); // absDbl は 3.142つの数値のうち大きい方を返します (int, long, float, double に対応)。
int a = 10;
int b = 20;
int maxVal = Math.max(a, b); // maxVal は 202つの数値のうち小さい方を返します (int, long, float, double に対応)。
int a = 10;
int b = 20;
int minVal = Math.min(a, b); // minVal は 10float または double の値を最も近い整数値 (int または long) に丸めます（四捨五入）。
double d1 = 3.14;
long r1 = Math.round(d1); // r1 は 3
double d2 = 3.75;
long r2 = Math.round(d2); // r2 は 4
float f1 = -2.5f;
int r3 = Math.round(f1); // r3 は -2 (0.5は正の無限大方向に丸められる)double 値の正の平方根を返します。
double val = 9.0;
double sqrtVal = Math.sqrt(val); // sqrtVal は 3.0
double neg = -4.0;
double sqrtNeg = Math.sqrt(neg); // sqrtNeg は NaN (Not a Number)最初の引数を 2 番目の引数で累乗した値を返します (ab)。
double base = 2.0;
double exponent = 3.0;
double result = Math.pow(base, exponent); // result は 8.0 (2の3乗)0.0 以上 1.0 未満の double 型の擬似乱数を返します。
double randomValue = Math.random();
System.out.println(randomValue); // 例: 0.734...
// 1から10までのランダムな整数を生成する例
int randomInt = (int)(Math.random() * 10) + 1;
System.out.println(randomInt);文字列を符号付き10進数整数 (int) として解析します。数値形式でない場合は NumberFormatException が発生します。
String strNum = "123";
int number = Integer.parseInt(strNum); // number は 123
try {
Integer.parseInt("abc");
} catch (NumberFormatException e) {
System.out.println("数値形式エラー: " + e.getMessage());
}文字列を double 型の浮動小数点数として解析します。数値形式でない場合は NumberFormatException が発生します。
String strDbl = "3.14159";
double pi = Double.parseDouble(strDbl); // pi は 3.14159BigDecimal オブジェクトの値に引数の値を加算した結果を新しい BigDecimal として返します。金融計算などで正確な計算が必要な場合に使用します。
import java.math.BigDecimal;
BigDecimal val1 = new BigDecimal("10.5");
BigDecimal val2 = new BigDecimal("20.3");
BigDecimal sum = val1.add(val2); // sum は 30.8
// 文字列コンストラクタを使うのが推奨される
System.out.println(sum);文字列の長さ（文字数）を int で返します。
String text = "Java Programming";
int len = text.length(); // len は 16文字列の長さが 0 の場合に true を返します。
String s1 = "";
String s2 = " ";
String s3 = "Hello";
System.out.println(s1.isEmpty()); // true
System.out.println(s2.isEmpty()); // false (空白文字がある)
System.out.println(s3.isEmpty()); // false指定されたインデックス位置にある文字 (char) を返します。インデックスは 0 から始まります。
String word = "World";
char firstChar = word.charAt(0); // firstChar は 'W'
char lastChar = word.charAt(word.length() - 1); // lastChar は 'd'文字列の一部（部分文字列）を抽出します。endIndex を省略すると、beginIndex から末尾までを抽出します。
String message = "Hello, World!";
String part1 = message.substring(7); // part1 は "World!" (7番目から末尾まで)
String part2 = message.substring(0, 5); // part2 は "Hello" (0番目から5番目の直前まで)指定された部分文字列が最初に出現するインデックスを返します。見つからない場合は -1 を返します。
String text = "Learn Java, Practice Java";
int index1 = text.indexOf("Java"); // index1 は 6
int index2 = text.indexOf("Java", 7); // index2 は 20 (7番目以降で検索)
int index3 = text.indexOf("Python"); // index3 は -1指定された部分文字列が最後に出現するインデックスを返します。見つからない場合は -1 を返します。
String text = "Learn Java, Practice Java";
int index1 = text.lastIndexOf("Java"); // index1 は 20
int index2 = text.lastIndexOf("Java", 19); // index2 は 6 (19番目以前で検索)文字列の内容が指定されたオブジェクトと等しいかどうかを比較します（大文字小文字を区別）。== 演算子とは異なり、内容を比較します。
String str1 = "Java";
String str2 = new String("Java");
String str3 = "java";
System.out.println(str1.equals(str2)); // true
System.out.println(str1 == str2); // false (オブジェクト参照は異なる)
System.out.println(str1.equals(str3)); // false文字列の内容が指定された文字列と等しいかどうかを、大文字小文字を区別せずに比較します。
String str1 = "Java";
String str3 = "java";
System.out.println(str1.equalsIgnoreCase(str3)); // true文字列が指定された接頭辞 (prefix) で始まるかどうかを判定します。
String filename = "document.pdf";
System.out.println(filename.startsWith("doc")); // true
System.out.println(filename.startsWith("pdf", 9)); // true (9番目から始まる部分が"pdf"か)文字列が指定された接尾辞 (suffix) で終わるかどうかを判定します。
String filename = "document.pdf";
System.out.println(filename.endsWith(".pdf")); // true
System.out.println(filename.endsWith("PDF")); // false文字列の先頭と末尾にある空白（スペース、タブ、改行など）を除去した新しい文字列を返します。
String padded = " Hello World ";
String trimmed = padded.trim(); // trimmed は "Hello World"文字列内の指定された文字または文字列シーケンスを、別の文字または文字列シーケンスに置換した新しい文字列を返します。
String text = "Color is blue.";
String replaced1 = text.replace('o', 'a'); // replaced1 は "Calar is blue."
String replaced2 = text.replace("blue", "red"); // replaced2 は "Color is red."指定された正規表現 (regex) に一致する箇所で文字列を分割し、部分文字列の配列 (String[]) を返します。
String csvLine = "apple,banana,orange";
String[] fruits = csvLine.split(","); // fruits は ["apple", "banana", "orange"]
String spaced = " word1 word2 word3";
String[] words = spaced.trim().split("\\s+"); // words は ["word1", "word2", "word3"] (複数の空白で分割)指定された書式文字列 (format) と引数を使用して、フォーマットされた文字列を生成します。
String name = "Alice";
int age = 30;
String formatted = String.format("Name: %s, Age: %d", name, age);
// formatted は "Name: Alice, Age: 30"
double price = 19.99;
String priceStr = String.format("Price: %.2f", price); // 小数点以下2桁表示
// priceStr は "Price: 19.99"指定された文字列（または他の型の文字列表現）を `StringBuilder` の末尾に追加します。効率的な文字列連結に使用されます。
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
sb.append(123);
String result = sb.toString(); // result は "Hello World123"リストの末尾に指定された要素を追加します。成功した場合は true を返します。
import java.util.ArrayList;
import java.util.List;
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob"); // names は ["Alice", "Bob"]リスト内の指定されたインデックスにある要素を返します。
// 上記 names リストの続き
String firstName = names.get(0); // firstName は "Alice"リスト内の指定されたインデックスにある要素を指定された要素で置き換えます。置き換えられる前の要素を返します。
// 上記 names リストの続き
String oldName = names.set(1, "Charlie"); // oldName は "Bob", names は ["Alice", "Charlie"]リスト内の指定されたインデックスにある要素を削除します。削除された要素を返します。
// 上記 names リストの続き
String removedName = names.remove(0); // removedName は "Alice", names は ["Charlie"]リスト内で指定された要素が最初に現れるものを削除します。要素が見つかり削除された場合は true を返します。
List<String> items = new ArrayList<>(List.of("A", "B", "C", "B"));
boolean removed = items.remove("B"); // removed は true, items は ["A", "C", "B"]リスト内の要素数を返します。
// 上記 items リストの続き
int count = items.size(); // count は 3リストが空（要素数が0）の場合に true を返します。
List<Integer> numbers = new ArrayList<>();
System.out.println(numbers.isEmpty()); // true
numbers.add(1);
System.out.println(numbers.isEmpty()); // false指定されたキーと値をマップに関連付けます。キーが既に存在する場合は、古い値が置き換えられ、その古い値が返されます（存在しない場合は null）。
import java.util.HashMap;
import java.util.Map;
Map<Integer, String> userMap = new HashMap<>();
userMap.put(1, "Tanaka");
userMap.put(2, "Suzuki");
String oldValue = userMap.put(1, "Sato"); // oldValue は "Tanaka"指定されたキーに関連付けられた値を返します。キーが存在しない場合は null を返します。
// 上記 userMap の続き
String name = userMap.get(2); // name は "Suzuki"
String nonExistent = userMap.get(3); // nonExistent は null指定されたキーとそのマッピングをマップから削除します。削除された値が返されます（存在しない場合は null）。
// 上記 userMap の続き
String removedValue = userMap.remove(1); // removedValue は "Sato"マップが指定されたキーを含んでいる場合に true を返します。
// 上記 userMap の続き (キー1は削除済み)
System.out.println(userMap.containsKey(1)); // false
System.out.println(userMap.containsKey(2)); // trueマップに含まれるすべてのキーのセット (Set<K>) を返します。
// 上記 userMap の続き (キー1は削除済み, キー2のみ残る)
Set<Integer> keys = userMap.keySet(); // keys は [2] を含む Set
for (Integer key : keys) {
System.out.println("Key: " + key);
}マップに含まれるすべての値のコレクション (Collection<V>) を返します。
// 上記 userMap の続き (キー1は削除済み, キー2のみ残る)
Collection<String> values = userMap.values(); // values は ["Suzuki"] を含む Collection
for (String value : values) {
System.out.println("Value: " + value);
}指定された要素がセットにまだ含まれていない場合、セットに追加します。要素が追加された場合は true を返します。
import java.util.HashSet;
import java.util.Set;
Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Bob");
boolean added = uniqueNames.add("Alice"); // added は false (既に追加済み)セットが指定された要素を含んでいる場合に true を返します。
// 上記 uniqueNames の続き
System.out.println(uniqueNames.contains("Bob")); // true
System.out.println(uniqueNames.contains("Charlie")); // false指定されたリストの要素を自然順序（昇順）に従ってソートします。
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
List<Integer> numbers = new ArrayList<>(List.of(5, 2, 8, 1));
Collections.sort(numbers); // numbers は [1, 2, 5, 8]指定された配列を基にした固定サイズのリストを返します。元の配列への変更はリストに反映され、逆も同様です。リストのサイズ変更（追加・削除）はできません。
import java.util.Arrays;
import java.util.List;
String[] array = {"A", "B", "C"};
List<String> list = Arrays.asList(array); // list は ["A", "B", "C"]
// list.add("D"); // UnsupportedOperationException が発生する指定されたプリミティブ型またはオブジェクトの配列を昇順にソートします。
import java.util.Arrays;
int[] nums = {5, 2, 8, 1, 9};
Arrays.sort(nums); // nums は [1, 2, 5, 8, 9]
String[] names = {"Charlie", "Alice", "Bob"};
Arrays.sort(names); // names は ["Alice", "Bob", "Charlie"]コレクション（List, Set など）から要素を順次処理するためのストリーム (Stream) を生成します。
import java.util.List;
import java.util.stream.Stream;
List<String> items = List.of("a", "b", "c");
Stream<String> stream = items.stream();
// これ以降、ストリーム操作を連結できるストリームの各要素に対して指定されたアクション（ラムダ式など）を実行します。終端操作です。
List<String> items = List.of("apple", "banana", "cherry");
items.stream().forEach(item -> System.out.println(item));
// またはメソッド参照で: items.stream().forEach(System.out::println);指定された条件 (predicate) を満たす要素のみを含む新しいストリームを返します。中間操作です。
List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
numbers.stream()
.filter(n -> n % 2 == 0) // 偶数のみをフィルタリング
.forEach(System.out::println); // 2, 4, 6 が出力される指定された関数 (mapper) をストリームの各要素に適用し、その結果からなる新しいストリームを返します。中間操作です。
List<String> names = List.of("alice", "bob", "charlie");
names.stream()
.map(String::toUpperCase) // 各要素を大文字に変換
.forEach(System.out::println); // ALICE, BOB, CHARLIE が出力されるストリームの要素を集約して、コレクション（List, Set, Mapなど）や単一の値に変換します。終端操作です。
import java.util.List;
import java.util.stream.Collectors;
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList()); // 結果を List に集約
// evenNumbers は [2, 4]ストリームの要素を初期値 (identity) と累積関数 (accumulator) を使って単一の結果値に畳み込みます。終端操作です。
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b); // 合計を計算 (0+1=1, 1+2=3, ...)
// sum は 15
// メソッド参照を使う: .reduce(0, Integer::sum);ストリーム内の要素数を返します。終端操作です。
List<String> items = List.of("one", "two", "three");
long count = items.stream().count(); // count は 3ストリームの要素を自然順序または指定された比較子 (comparator) に従ってソートした新しいストリームを返します。中間操作です。
List<Integer> numbers = List.of(5, 1, 4, 2, 3);
numbers.stream()
.sorted() // 自然順序でソート
.forEach(System.out::println); // 1, 2, 3, 4, 5 が出力されるシステムのデフォルトタイムゾーンを使用して、現在の日付を取得します。
import java.time.LocalDate;
LocalDate today = LocalDate.now();
System.out.println("今日の日付: " + today); // 例: 2025-04-23システムのデフォルトタイムゾーンを使用して、現在の時刻を取得します。
import java.time.LocalTime;
LocalTime now = LocalTime.now();
System.out.println("現在の時刻: " + now); // 例: 22:42:24.123456789システムのデフォルトタイムゾーンを使用して、現在の日付と時刻を取得します。
import java.time.LocalDateTime;
LocalDateTime currentDateTime = LocalDateTime.now();
System.out.println("現在の日時: " + currentDateTime); // 例: 2025-04-23T22:42:24.123456789システムのデフォルトタイムゾーンを使用して、タイムゾーン情報を含む現在の日付と時刻を取得します。
import java.time.ZonedDateTime;
ZonedDateTime zonedNow = ZonedDateTime.now();
System.out.println("タイムゾーン付き現在日時: " + zonedNow); // 例: 2025-04-23T22:42:24.123456789+09:00[Asia/Tokyo]エポック（1970-01-01T00:00:00Z）からの経過時間をナノ秒精度で表す、現在の瞬間を取得します（通常UTC）。
import java.time.Instant;
Instant currentInstant = Instant.now();
System.out.println("現在のInstant: " + currentInstant); // 例: 2025-04-23T13:42:24.123456789Z2つの時間ベースのオブジェクト（Instant, LocalTime, LocalDateTime など）の間の期間（時間、分、秒、ナノ秒）を計算します。
import java.time.Duration;
import java.time.LocalTime;
LocalTime start = LocalTime.of(9, 0);
LocalTime end = LocalTime.of(10, 30, 15);
Duration duration = Duration.between(start, end);
System.out.println("期間: " + duration); // PT1H30M15S (1時間30分15秒)
System.out.println("分単位: " + duration.toMinutes()); // 902つの日付ベースのオブジェクト（LocalDate）の間の期間（年、月、日）を計算します。
import java.time.Period;
import java.time.LocalDate;
LocalDate startDate = LocalDate.of(2024, 1, 15);
LocalDate endDate = LocalDate.of(2025, 3, 20);
Period period = Period.between(startDate, endDate);
System.out.println("期間: " + period); // P1Y2M5D (1年2ヶ月5日)
System.out.println("月単位: " + period.toTotalMonths()); // 14指定されたパターン文字列に基づいて日付/時刻フォーマッタを作成します。
import java.time.format.DateTimeFormatter;
import java.time.LocalDateTime;
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now();
String formattedDateTime = now.format(formatter);
System.out.println("フォーマットされた日時: " + formattedDateTime); // 例: 2025/04/23 22:42:24テキスト文字列を解析して LocalDate インスタンスを生成します。フォーマッタを指定しない場合は ISO_LOCAL_DATE 形式 (yyyy-MM-dd) を使用します。
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
LocalDate date1 = LocalDate.parse("2025-05-10"); // ISO形式
System.out.println(date1);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate date2 = LocalDate.parse("2025/06/15", formatter);
System.out.println(date2);指定されたフォーマッタを使用して、この LocalDateTime を文字列にフォーマットします。
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
LocalDateTime dateTime = LocalDateTime.of(2025, 12, 25, 18, 30);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH時mm分");
String formatted = dateTime.format(formatter);
System.out.println(formatted); // 2025年12月25日 18時30分指定されたデータ（文字列、数値など）を標準出力（通常はコンソール）に出力し、改行します。
System.out.println("Hello, Java!");
System.out.println(123);指定されたキーに対応するシステムプロパティ（Javaのバージョン、OS名など）の値を返します。
String javaVersion = System.getProperty("java.version");
System.out.println("Java Version: " + javaVersion);
String osName = System.getProperty("os.name");
System.out.println("OS Name: " + osName);指定された名前の環境変数の値を返します。環境変数が定義されていない場合は null を返します。
String pathVariable = System.getenv("PATH");
// System.out.println("PATH: " + pathVariable); // 環境によって非常に長くなる可能性がある
String user = System.getenv("USERNAME"); // Windowsの場合
if (user == null) {
user = System.getenv("USER"); // Linux/macOSの場合
}
System.out.println("Current User: " + user);指定されたオブジェクト参照が null でないことを確認します。null の場合は、指定されたメッセージ（またはデフォルトメッセージ）と共に NullPointerException をスローします。
import java.util.Objects;
public void process(String data) {
String nonNullData = Objects.requireNonNull(data, "入力データは null であってはいけません");
System.out.println("処理データ: " + nonNullData);
}
// process(null); // NullPointerException が発生指定されたオブジェクト参照が null の場合に true を返します。
import java.util.Objects;
String str = null;
if (Objects.isNull(str)) {
System.out.println("文字列は null です。");
}2つのオブジェクトが等しいかどうかを比較します。両方が null なら true、片方だけが null なら false、両方が null でなければ a.equals(b) の結果を返します。NullPointerException を回避できます。
import java.util.Objects;
String s1 = "abc";
String s2 = null;
String s3 = "abc";
System.out.println(Objects.equals(s1, s2)); // false
System.out.println(Objects.equals(s1, s3)); // true
System.out.println(Objects.equals(s2, null)); // truenull である可能性のある値をラップする Optional インスタンスを返します。値が null でない場合はその値を持つ Optional を、null の場合は空の Optional (`Optional.empty()`) を返します。
import java.util.Optional;
String name = possiblyNullName(); // nullかもしれない値
Optional<String> optName = Optional.ofNullable(name);Optional インスタンスが値を含んでいる場合（null でない場合）に true を返します。
// 上記 optName の続き
if (optName.isPresent()) {
System.out.println("名前: " + optName.get()); // .get() で値を取得
} else {
System.out.println("名前は設定されていません。");
}Optional が値を含んでいる場合はその値を返し、含まない場合（空の場合）は指定されたデフォルト値 (other) を返します。
// 上記 optName の続き
String displayName = optName.orElse("ゲスト"); // 値がなければ "ゲスト" を使う
System.out.println("表示名: " + displayName);ランダムなUUID (Universally Unique Identifier) を生成します。一意なIDを生成するのに役立ちます。
import java.util.UUID;
UUID uniqueId = UUID.randomUUID();
System.out.println("生成されたUUID: " + uniqueId.toString());発生した例外やエラーの詳細メッセージ文字列を返します。原因究明に役立ちます。
try {
Integer.parseInt("not a number");
} catch (NumberFormatException e) {
System.err.println("エラーメッセージ: " + e.getMessage());
// 出力例: エラーメッセージ: For input string: "not a number"
}例外のスタックトレース（発生箇所までのメソッド呼び出し履歴）を標準エラー出力に出力します。デバッグ時に非常に重要です。
try {
int result = 10 / 0; // ArithmeticException が発生
} catch (ArithmeticException e) {
System.err.println("例外が発生しました。スタックトレース:");
e.printStackTrace();
/* 出力例:
java.lang.ArithmeticException: / by zero
at YourClassName.yourMethodName(YourClassName.java:XX)
...
*/
}AutoCloseable インターフェースを実装したリソース（ファイル、DB接続など）を自動的に閉じるための構文です。finally ブロックでの close() 呼び出し忘れを防ぎます。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
// try(...) のカッコ内でリソースを初期化
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
// reader.close() は自動的に呼び出されるオブジェクトが特定のクラスまたはインターフェースのインスタンスであるかどうかを判定します。true または false を返します。
Object obj = "Hello";
if (obj instanceof String) {
String str = (String) obj; // キャスト可能
System.out.println("文字列です: " + str);
} else if (obj instanceof Integer) {
System.out.println("整数です。");
}
// Java 16以降のパターンマッチング
if (obj instanceof String s) { // instanceof と同時に変数 s にキャスト
System.out.println("文字列です (パターンマッチング): " + s.toUpperCase());
}プログラムの特定の箇所で条件が真であるべきことを表明します。偽の場合 AssertionError がスローされます。通常、開発・テスト時に有効にし、本番環境では無効にします（-ea VMオプションで有効化）。
public int calculate(int input) {
assert input >= 0 : "入力値は負であってはいけません: " + input; // 条件式 : エラーメッセージ
// ... 本来の処理 ...
return input * 2;
}
// 実行時に assert calculate(-1); などとすると AssertionError が発生する（-ea 付きの場合）java.io.File オブジェクトが示すファイルまたはディレクトリが存在するかどうかを判定します。新しいコードでは Files.exists() の使用が推奨されます。
import java.io.File;
File file = new File("my_document.txt");
if (file.exists()) {
System.out.println("ファイルが存在します。");
} else {
System.out.println("ファイルが存在しません。");
}java.io.File オブジェクトが示すパスに、空の新しいファイルを原子的に作成します。ファイルが既に存在する場合は作成せず false を返します。新しいコードでは Files.createFile() の使用が推奨されます。
import java.io.File;
import java.io.IOException;
File newFile = new File("new_empty_file.txt");
try {
if (newFile.createNewFile()) {
System.out.println("ファイルが作成されました。");
} else {
System.out.println("ファイルは既に存在します。");
}
} catch (IOException e) {
System.err.println("ファイルの作成に失敗しました: " + e.getMessage());
}java.nio.file.Path オブジェクトが示すファイルまたはディレクトリが存在するかどうかを判定します (NIO.2 API)。
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get("config.properties");
if (Files.exists(path)) {
System.out.println("NIO: ファイルが存在します。");
} else {
System.out.println("NIO: ファイルが存在しません。");
}ファイルからすべてのバイトを読み込み、バイト配列 (byte[]) として返します。小さいファイルに適しています。
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;
Path filePath = Paths.get("data.bin");
try {
byte[] fileBytes = Files.readAllBytes(filePath);
System.out.println("読み込んだバイト数: " + fileBytes.length);
} catch (IOException e) {
System.err.println("ファイルの読み込みに失敗: " + e.getMessage());
}ファイルからすべての行を読み込み、文字列のリスト (List<String>) として返します。文字コードを指定できます（デフォルトはUTF-8）。
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.List;
import java.nio.charset.StandardCharsets;
Path textFile = Paths.get("log.txt");
try {
List<String> lines = Files.readAllLines(textFile, StandardCharsets.UTF_8);
for (String line : lines) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("ファイルの読み込みに失敗: " + e.getMessage());
}バイト配列または文字列リストをファイルに書き込みます。既存ファイルへの追記などのオプションも指定できます。
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.List;
import java.nio.file.StandardOpenOption;
Path outputFile = Paths.get("output.txt");
List<String> content = List.of("Line 1", "Line 2", "Line 3");
try {
// ファイルを新規作成または上書きして書き込む
Files.write(outputFile, content);
System.out.println("ファイルに書き込みました。");
// ファイルに追記する
Files.write(outputFile, List.of("Line 4"), StandardOpenOption.APPEND);
System.out.println("ファイルに追記しました。");
} catch (IOException e) {
System.err.println("ファイルへの書き込みに失敗: " + e.getMessage());
}パス文字列またはURIから Path オブジェクトを生成します。複数の文字列を連結してパスを構築することもできます。
import java.nio.file.Path;
import java.nio.file.Paths;
// 単一のパス文字列から
Path p1 = Paths.get("C:/Users/Public/Documents/report.docx"); // Windows例
Path p2 = Paths.get("/home/user/data/image.jpg"); // Linux/macOS例
// 複数の部分を連結して
String baseDir = "/app/data";
String fileName = "config.xml";
Path p3 = Paths.get(baseDir, "settings", fileName); // /app/data/settings/config.xml
System.out.println(p3.toString());テキスト入力ストリームから1行分のテキストを読み込みます。行終端記号（改行など）は含まれません。ストリームの終わりに達した場合は null を返します。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println("読み込んだ行: " + line);
}
} catch (IOException e) {
e.printStackTrace();
}入力ストリームから最大で b.length バイト（または指定された長さ len）のデータを読み込み、バイト配列 b に格納します。実際に読み込んだバイト数を返します。ストリームの終わりに達した場合は -1 を返します。
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
try (InputStream is = new FileInputStream("binary.dat")) {
byte[] buffer = new byte[1024]; // 読み込み用バッファ
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
// buffer の 0 から bytesRead-1 までが有効なデータ
System.out.println("読み込みバイト数: " + bytesRead);
// ここで読み込んだデータ (buffer) を処理する
}
} catch (IOException e) {
e.printStackTrace();
}指定されたバイト配列 b の内容（またはその一部）を出力ストリームに書き込みます。
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
try (OutputStream os = new FileOutputStream("output.bin")) {
String data = "Hello Binary World!";
byte[] bytes = data.getBytes(StandardCharsets.UTF_8); // 文字列をバイト配列に変換
os.write(bytes); // バイト配列を書き込む
System.out.println("バイト配列を書き込みました。");
} catch (IOException e) {
e.printStackTrace();
}int 値または数値を表す String から Integer オブジェクトを返します。パフォーマンスのため、よく使われる値はキャッシュされたインスタンスが返されることがあります（オートボクシングでも内部的に使われます）。
Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf("200");
int primitiveInt = 10;
Integer wrapperInt = primitiveInt; // オートボクシング (内部で valueOf が呼ばれる)double 値または数値を表す String から Double オブジェクトを返します。
Double d1 = Double.valueOf(3.14);
Double d2 = Double.valueOf("2.718");
double primitiveDouble = 1.618;
Double wrapperDouble = primitiveDouble; // オートボクシング文字列を解析して boolean 値を返します。文字列が "true"（大文字小文字無視）であれば true、それ以外は false を返します。
boolean b1 = Boolean.parseBoolean("True"); // b1 は true
boolean b2 = Boolean.parseBoolean("yes"); // b2 は false
boolean b3 = Boolean.parseBoolean("FALSE"); // b3 は true指定された文字が数字 ('0'～'9') であるかどうかを判定します。
char c1 = '5';
char c2 = 'a';
System.out.println(Character.isDigit(c1)); // true
System.out.println(Character.isDigit(c2)); // falseint 型が保持できる最大値 (231-1) および最小値 (-231) を表す定数です。他のラップクラス（Long, Double など）にも同様の定数があります。
System.out.println("int の最大値: " + Integer.MAX_VALUE); // 2147483647
System.out.println("int の最小値: " + Integer.MIN_VALUE); // -2147483648指定された double 値が非数 (NaN - Not a Number) であるかどうかを判定します。NaN は == で比較できないため、このメソッドを使います。インスタンスメソッド isNaN() もあります。
double result1 = Math.sqrt(-1.0); // NaN
double result2 = 0.0 / 0.0; // NaN
double result3 = 5.0;
System.out.println(Double.isNaN(result1)); // true
System.out.println(result1 == Double.NaN); // false (NaN の比較は常に false)
System.out.println(Double.isNaN(result3)); // false新しいスレッドの実行を開始します。Java仮想マシンがこのスレッドの run() メソッドを呼び出します。run() を直接呼び出すのではなく、start() を使います。
class MyTask implements Runnable {
@Override
public void run() {
System.out.println("別スレッドで実行中: " + Thread.currentThread().getName());
}
}
Thread thread = new Thread(new MyTask());
thread.start(); // 新しいスレッドを開始し、MyTask の run() を実行
System.out.println("メインスレッド: " + Thread.currentThread().getName());現在実行中のスレッドを、指定されたミリ秒数だけ一時停止させます。InterruptedException が発生する可能性があります。
System.out.println("処理開始");
try {
Thread.sleep(2000); // 2秒間スリープ
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 割り込みステータスを再設定
System.err.println("スレッドが中断されました。");
}
System.out.println("処理再開");インスタンスがスレッドによって実行されることを意図するクラスによって実装されるべきインターフェースです。run() メソッドを一つ持ちます。ラムダ式での実装が一般的です。
Runnable task = () -> {
System.out.println("Runnable タスク実行中: " + Thread.currentThread().getName());
};
Thread thread1 = new Thread(task);
thread1.start();
// ラムダ式を直接コンストラクタに渡す
Thread thread2 = new Thread(() -> System.out.println("別タスク実行中"));
thread2.start();メソッドまたはコードブロックへのアクセスを一度に一つのスレッドのみに制限するためのキーワード（ロック機構）です。共有リソースへの競合アクセスを防ぎます。
class Counter {
private int count = 0;
// メソッド全体を同期化
public synchronized void increment() {
count++;
}
public void decrement() {
// コードブロックを同期化 (this オブジェクトでロック)
synchronized (this) {
count--;
}
}
public synchronized int getCount() {
return count;
}
}タスク (Runnable または Callable) を実行のためにスレッドプールに送信します。Callable を渡した場合、結果を取得するための Future オブジェクトが返されます。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.Callable;
ExecutorService executor = Executors.newFixedThreadPool(2); // 2つのスレッドを持つプール
// Runnable タスク (戻り値なし)
executor.submit(() -> System.out.println("Runnable 実行"));
// Callable タスク (戻り値あり)
Callable<Integer> callableTask = () -> {
Thread.sleep(1000); // 何か処理
return 123;
};
Future<Integer> future = executor.submit(callableTask);
try {
Integer result = future.get(); // 結果が返るまで待機
System.out.println("Callable の結果: " + result);
} catch (Exception e) {
e.printStackTrace();
}
executor.shutdown(); // プールをシャットダウン指定された完全修飾クラス名に対応する Class オブジェクトを返します。主にJDBCドライバのロードなどで使われますが、リフレクションの起点にもなります。
try {
// JDBCドライバのロード例 (古いスタイル)
// Class.forName("com.mysql.cj.jdbc.Driver");
// クラスオブジェクトの取得
Class<?> stringClass = Class.forName("java.lang.String");
System.out.println("取得したクラス: " + stringClass.getName());
} catch (ClassNotFoundException e) {
System.err.println("クラスが見つかりません: " + e.getMessage());
}ガベージコレクタの実行をJava仮想マシンに要求します。ただし、実行は保証されず、通常は明示的に呼び出す必要はありません（パフォーマンスに悪影響を与える可能性もあります）。
System.out.println("メモリ解放前の空きメモリ: " + Runtime.getRuntime().freeMemory());
// 大量のオブジェクト生成など...
System.gc(); // GC実行を試みる (非推奨)
System.out.println("メモリ解放後の空きメモリ（目安）: " + Runtime.getRuntime().freeMemory());バイト配列をBase64方式でエンコードし、文字列として返します。バイナリデータをテキスト形式で安全に転送・格納する際に使用されます。
import java.util.Base64;
import java.nio.charset.StandardCharsets;
String originalInput = "Hello Base64!";
byte[] inputBytes = originalInput.getBytes(StandardCharsets.UTF_8);
String encodedString = Base64.getEncoder().encodeToString(inputBytes);
System.out.println("エンコード結果: " + encodedString); // 例: SGVsbG8gQmFzZTY0IQ==
// デコード
byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
String decodedString = new String(decodedBytes, StandardCharsets.UTF_8);
System.out.println("デコード結果: " + decodedString); // Hello Base64!== と equals() の違い: == は参照（メモリ上のアドレス）が同じかを比較し、.equals() はオブジェクトの内容が等しいかを比較します。文字列やラッパークラスの比較には基本的に .equals() を使用してください。（例外: enum の比較は == で良い）NullPointerException (ぬるぽ): null のオブジェクト参照に対してメソッド呼び出しやフィールドアクセスを行うと発生します。Optional クラスの使用や事前の null チェック (Objects.isNull() など) で回避しましょう。+ 演算子を使って大量の文字列を連結すると、String オブジェクトが多数生成され非効率です。StringBuilder (単一スレッド環境) や StringBuffer (複数スレッド環境) を使用してください。float や double は2進数表現のため、10進数の小数を正確に表現できない場合があります。金融計算など厳密な精度が必要な場合は BigDecimal を使用し、コンストラクタには文字列 (new BigDecimal("0.1")) を渡すのが安全です。for ループや Iterator を使用してコレクションを反復処理中に、そのコレクションの要素を追加・削除すると ConcurrentModificationException が発生することがあります。Iterator.remove() を使う、Stream API を使う、または反復処理後に変更するなどの対策が必要です。close() メソッドで解放する必要があります。try-with-resources 構文を使用すると、自動的にリソースが解放されるため強く推奨されます。., *, +, ?, [, ], (, ), {, }, ^, $, |, \ など特別な意味を持つ文字（メタ文字）があります。これらを通常の文字としてマッチさせたい場合は、バックスラッシュ \ でエスケープ (\\., \\*, \\+ など) する必要があります。hashCode() と equals() の契約: equals() をオーバーライドする場合は、必ず hashCode() もオーバーライドし、「equals() が true を返す2つのオブジェクトは、hashCode() も同じ値を返さなければならない」という契約を守る必要があります。これを守らないと HashMap や HashSet などが正しく動作しません。static）の乱用: 便利さから多用しがちですが、static なフィールドやメソッドは状態管理が難しくなったり、テスト容易性を損なうことがあります。オブジェクト指向の原則に基づき、インスタンス変数やメソッドの使用を基本としましょう。定数定義 (final static) は有効な使い方です。catch ブロックで例外をキャッチしたにも関わらず、何も処理しない（またはログ出力もしない）のは問題の発見を困難にします。最低限ログに出力するか、ビジネスロジック上意味のあるカスタム例外にラップして再スローするなどの対応が必要です。[]) は固定長でプリミティブ型も格納できますが、メソッドは少ないです。リスト (List) は可変長（ArrayListなど）でオブジェクトのみ格納でき、豊富なメソッドを持ちます。Arrays.asList() で得られるリストは固定長である点にも注意が必要です。java.util.Date や java.util.Calendar は設計上の問題が多く、ミュータブル（変更可能）であるため、現在は非推奨です。新しいプロジェクトでは java.time パッケージ (Java 8以降) を使用することが強く推奨されます。| 機能 / クラス / パッケージ | 導入バージョン | 補足 |
|---|---|---|
基本クラス (Object, String, Math, System) |
JDK 1.0 | Java言語の基礎 |
ラッパークラス (Integer, Double etc.) |
JDK 1.0 | プリミティブ型のオブジェクト表現 |
java.io パッケージ (File, InputStream etc.) |
JDK 1.0 | 基本的な入出力 API (ブロッキングI/O) |
java.util パッケージ (Date, Calendar) |
JDK 1.0 / 1.1 | 古い日付/時刻 API (現在は非推奨) |
Collections Framework (List, Set, Map, ArrayList, HashMap etc.) |
JDK 1.2 | データ構造を扱う標準的な方法 |
synchronized キーワード |
JDK 1.0 | 基本的なスレッド同期メカニズム |
assert キーワード |
J2SE 1.4 | 表明 (デバッグ/テスト用) |
| ジェネリクス (Generics) | Java 5 | 型安全性の向上 (例: List<String>) |
| オートボクシング / アンボクシング | Java 5 | プリミティブ型とラッパー型の自動変換 |
拡張 for ループ (Enhanced for loop) |
Java 5 | 配列やコレクションの簡潔な反復処理 |
StringBuilder, UUID, Scanner |
Java 5 | ユーティリティクラスの追加 |
java.util.concurrent パッケージ (ExecutorService, Future etc.) |
Java 5 | 高レベルな並行処理 API |
java.nio パッケージ (NIO - New I/O) |
J2SE 1.4 | ノンブロッキングI/O、バッファ、チャネル |
try-with-resources 構文 |
Java 7 | リソースの自動クローズ |
NIO.2 (java.nio.file パッケージ - Files, Paths) |
Java 7 | 新しいファイルシステム API |
Objects クラス |
Java 7 | Nullチェックなどのユーティリティメソッド |
| ラムダ式 (Lambda Expressions) | Java 8 | 関数型プログラミングのサポート |
| Stream API | Java 8 | コレクションの関数型操作 |
java.time パッケージ (新しい日付/時刻 API) |
Java 8 | JSR-310 に基づく改善されたAPI |
Optional クラス |
Java 8 | null の可能性を明示的に扱う |
Base64 クラス |
Java 8 | Base64 エンコード/デコード |
| インターフェースのデフォルトメソッド、静的メソッド | Java 8 | インターフェースの拡張性向上 |
| モジュールシステム (Project Jigsaw) | Java 9 | 大規模アプリケーションの構造化 |
var (ローカル変数の型推論) |
Java 10 | コードの簡潔化 |
新しい HttpClient |
Java 11 (Standard) | HTTP/2、WebSocket 対応 |
switch 式 (Switch Expressions) |
Java 14 (Standard) | switch 文の改善 |
| テキストブロック (Text Blocks) | Java 15 (Standard) | 複数行文字列リテラルの簡潔な記述 |
| レコード (Records) | Java 16 (Standard) | 不変なデータクラスの簡潔な定義 |
パターンマッチング (instanceof) |
Java 16 (Standard) | instanceof とキャストの組み合わせを簡略化 |
※上記は主要な変更点の一部です。各バージョンにはさらに多くの機能追加や改善が含まれています。
※LTS (Long-Term Support) バージョン: Java 8, 11, 17, 21 など。