【Java入門】プリミティブ型完全ガイド！参照型との違いから実践的な使い方まで解説

1.2 Javaで用意されている8つのプリミティブ型一覧

// 基本的な変数宣言と初期化
byte age = 25;
int count = 1000000;
double price = 199.99;
boolean isValid = true;
char grade = 'A';

// 計算例
int result = count + 50;  // 整数の加算
double total = price * 1.1;  // 浮動小数点数の乗算

// プリミティブ型を使用した場合
int counter = 0;
counter++;  // シンプルなインクリメント

// 参照型を使用した場合
Integer objCounter = new Integer(0);
objCounter = new Integer(objCounter.intValue() + 1);  // より複雑

// コンパイル時のチェック
int number = 42;
// boolean result = number;  // コンパイルエラー
boolean result = (number != 0);  // 明示的な変換が必要

// プリミティブ型の例
int primitiveNum = 42;

// 参照型の例
Integer referenceNum = new Integer(42);
String text = "Hello";

// プリミティブ型: 32ビット（4バイト）のみ
int number = 100;

// 参照型: オブジェクトヘッダ（12バイト）+ データ（4バイト）+ パディング（4バイト）
Integer objNumber = 100;  // 合計約20バイト

public class PerformanceTest {
    public static void main(String[] args) {
        // プリミティブ型の処理時間測定
        long start = System.nanoTime();
        int primitive = 0;
        for (int i = 0; i < 10000000; i++) {
            primitive += i;
        }
        long primitiveTime = System.nanoTime() - start;

        // 参照型の処理時間測定
        start = System.nanoTime();
        Integer reference = 0;
        for (int i = 0; i < 10000000; i++) {
            reference += i;  // 自動ボクシング/アンボクシングが発生
        }
        long referenceTime = System.nanoTime() - start;

        System.out.println("プリミティブ型処理時間: " + primitiveTime + "ns");
        System.out.println("参照型処理時間: " + referenceTime + "ns");
    }
}

// プリミティブ型はnullを持てない
int number = 0;  // デフォルト値として0が設定される
// int nullNumber = null;  // コンパイルエラー

// 値の存在確認が必要な場合は参照型を使用する必要がある
Integer nullableNumber = null;  // OK

public class NullSafetyExample {
    // 参照型を使用する場合のnull安全性確保
    public static int calculateLength(String text) {
        // null チェックが必要
        return (text != null) ? text.length() : 0;
    }

    // プリミティブ型は常に値を持つ
    public static int add(int a, int b) {
        // null チェック不要
        return a + b;
    }
}

// Optionalを使用したnull安全なコード例
import java.util.Optional;

public class OptionalExample {
    public static void processValue(Integer value) {
        Optional.ofNullable(value)
            .ifPresent(v -> System.out.println("値: " + v));
    }
}

// 1. 単純な数値計算の場合
public class CalculationExample {
    // プリミティブ型を使用（推奨）
    public static double calculateArea(double width, double height) {
        return width * height;
    }

    // 参照型を使用（非推奨）
    public static Double calculateAreaWithWrapper(Double width, Double height) {
        return width * height;  // 不必要なボクシング/アンボクシングが発生
    }
}

// 2. 大量のデータを扱う場合
public class DataProcessing {
    // 効率的な配列宣言
    private int[] numbers = new int[1000000];  // メモリ効率が良い

    // 非効率な配列宣言
    private Integer[] numberObjects = new Integer[1000000];  // メモリ使用量が多い
}

public class LoopOptimization {
    // 最適化された実装
    public static long sumPrimitive(int max) {
        long sum = 0L;
        for (int i = 0; i < max; i++) {
            sum += i;
        }
        return sum;
    }

    // キャッシュを活用した配列処理
    public static int[] processArray(int[] data) {
        int length = data.length;  // lengthをキャッシュ
        int[] result = new int[length];
        for (int i = 0; i < length; i++) {
            result[i] = data[i] * 2;
        }
        return result;
    }
}

public class MemoryOptimization {
    // ビット演算を使用した効率的なフラグ管理
    private static final byte FLAG_A = 1 << 0;  // 0001
    private static final byte FLAG_B = 1 << 1;  // 0010
    private static final byte FLAG_C = 1 << 2;  // 0100

    private byte flags = 0;  // 1バイトで8個のフラグを管理

    public void setFlag(byte flag, boolean value) {
        if (value) {
            flags |= flag;  // フラグを立てる
        } else {
            flags &= ~flag;  // フラグを下げる
        }
    }
}

public class OverflowHandling {
    public static void main(String[] args) {
        // オーバーフローの例
        int maxInt = Integer.MAX_VALUE;
        System.out.println("最大値: " + maxInt);
        System.out.println("最大値 + 1: " + (maxInt + 1));  // オーバーフロー発生

        // 対処方法1: より大きな型を使用
        long safeResult = (long)maxInt + 1;

        // 対処方法2: オーバーフローチェック
        public static int addSafely(int a, int b) {
            if (b > 0 && a > Integer.MAX_VALUE - b) {
                throw new ArithmeticException("整数オーバーフロー");
            }
            if (b < 0 && a < Integer.MIN_VALUE - b) {
                throw new ArithmeticException("整数アンダーフロー");
            }
            return a + b;
        }
    }
}

public class FloatingPointPrecision {
    public static void main(String[] args) {
        // 精度の問題例
        double a = 0.1 + 0.2;
        System.out.println(a == 0.3);  // false

        // 対処方法1: BigDecimalの使用
        BigDecimal bd1 = new BigDecimal("0.1");
        BigDecimal bd2 = new BigDecimal("0.2");
        BigDecimal result = bd1.add(bd2);

        // 対処方法2: イプシロン値を使用した比較
        public static boolean nearlyEqual(double a, double b) {
            final double EPSILON = 0.00001;
            return Math.abs(a - b) < EPSILON;
        }
    }
}

public class DefaultValueWarnings {
    private int counter;  // デフォルト値は0
    private boolean flag;  // デフォルト値はfalse

    public void processData() {
        // 明示的な初期化を推奨
        int localCounter = 0;  // ローカル変数は初期化が必要

        // 条件分岐での注意点
        if (flag) {  // デフォルト値のfalseが意図した動作か確認
            // 処理
        }
    }
}

public class BoxingExample {
    public static void main(String[] args) {
        // 自動ボクシングの例
        int primitiveNum = 42;
        Integer wrappedNum = primitiveNum;  // 自動ボクシング

        // 内部的には以下のコードと同等
        Integer wrappedNumExplicit = Integer.valueOf(primitiveNum);

        // コレクションでの自動ボクシング
        List<Integer> numbers = new ArrayList<>();
        numbers.add(100);  // int -> Integerに自動ボクシング
    }
}

public class UnboxingExample {
    public static void main(String[] args) {
        // 自動アンボクシングの例
        Integer wrappedNum = new Integer(42);
        int primitiveNum = wrappedNum;  // 自動アンボクシング

        // 内部的には以下のコードと同等
        int primitiveNumExplicit = wrappedNum.intValue();

        // 演算時の自動アンボクシング
        Integer result = wrappedNum + 10;  // アンボクシング→計算→ボクシング
    }
}

public class MemoryUsageComparison {
    public static void main(String[] args) {
        // プリミティブ型配列: 約4MB
        int[] primitiveArray = new int[1_000_000];

        // ラッパークラス配列: 約16MB
        Integer[] wrapperArray = new Integer[1_000_000];

        // メモリ効率の良い実装例
        public class OptimizedClass {
            private int value;  // プリミティブ型を使用

            // nullが必要な場合のみラッパークラスを使用
            private Integer nullableValue;
        }
    }
}

public class PerformanceOptimization {
    // ループ処理での最適化
    public static long sumValues(List<Integer> numbers) {
        // 最適化前
        long sum1 = 0;
        for (Integer num : numbers) {
            sum1 += num;  // 毎回アンボクシングが発生
        }

        // 最適化後
        long sum2 = 0;
        for (int i = 0; i < numbers.size(); i++) {
            sum2 += numbers.get(i).intValue();  // 明示的なアンボクシング
        }

        // さらに最適化（Stream APIを使用）
        long sum3 = numbers.stream()
                          .mapToLong(Integer::longValue)
                          .sum();

        return sum3;
    }
}

public class DatabaseExample {
    public class UserEntity {
        private int id;              // 主キー（非null）はプリミティブ型
        private Integer age;         // null許容フィールドはラッパークラス
        private boolean active;      // フラグはプリミティブ型
        private Boolean verified;    // null可能なフラグはラッパークラス

        // getters and setters
    }

    public List<UserEntity> findActiveUsers(Integer minAge) {
        // minAgeがnullの場合は年齢制限なしの検索
        if (minAge == null) {
            return findAllActiveUsers();
        }
        // 具体的な実装は省略
        return new ArrayList<>();
    }
}

public class ApiExample {
    public class ApiResponse {
        private int statusCode;          // HTTPステータスコード（必須）
        private Double temperature;      // 気温（null可能）
        private boolean success;         // 処理結果（必須）
        private Long timestamp;          // タイムスタンプ（null可能）

        // コンストラクタ
        public ApiResponse(int statusCode, Double temperature) {
            this.statusCode = statusCode;
            this.temperature = temperature;
            this.success = statusCode == 200;
            this.timestamp = System.currentTimeMillis();
        }
    }
}

public class BusinessLogicExample {
    public class Calculator {
        // 計算結果が必ずある場合
        public double calculateTax(double amount, double rate) {
            return amount * rate;
        }

        // 計算結果がない可能性がある場合
        public Double calculateDiscount(Double amount, Double rate) {
            if (amount == null || rate == null) {
                return null;
            }
            return amount * rate;
        }

        // Optional型を使用した例
        public Optional<Double> calculateBonus(Double amount) {
            if (amount == null || amount <= 0) {
                return Optional.empty();
            }
            return Optional.of(amount * 0.1);
        }
    }
}

public class FinancialCalculations {
    // 単利計算（プリミティブ型の精度を考慮）
    public static double calculateSimpleInterest(double principal, double rate, int years) {
        // 金利計算では倍精度浮動小数点数(double)を使用
        return principal * rate * years;
    }

    // 複利計算（より正確な計算が必要な場合）
    public static BigDecimal calculateCompoundInterest(BigDecimal principal, 
                                                     double rate, 
                                                     int years) {
        BigDecimal decimalRate = BigDecimal.valueOf(rate);
        return principal.multiply(
            BigDecimal.ONE.add(decimalRate).pow(years)
            .subtract(principal)
        );
    }

    // パーセント計算の最適化
    public static double calculatePercentage(long value, int percentage) {
        // 整数演算を優先し、最後に浮動小数点数に変換
        return (value * percentage) / 100.0;
    }
}

public class StatisticsCalculator {
    // 配列の平均値計算（プリミティブ型の利点を活用）
    public static double calculateAverage(int[] numbers) {
        long sum = 0;  // オーバーフロー対策でlongを使用
        for (int number : numbers) {
            sum += number;
        }
        return (double) sum / numbers.length;
    }

    // 標準偏差の計算
    public static double calculateStandardDeviation(int[] numbers) {
        double mean = calculateAverage(numbers);
        double sumSquaredDiff = 0.0;

        for (int number : numbers) {
            double diff = number - mean;
            sumSquaredDiff += diff * diff;
        }

        return Math.sqrt(sumSquaredDiff / numbers.length);
    }
}

public class LargeDataProcessor {
    // プリミティブ型配列を使用した効率的なデータ処理
    public static class DataChunk {
        private final int[] data;
        private int size;
        private static final int CHUNK_SIZE = 1024;

        public DataChunk() {
            data = new int[CHUNK_SIZE];
            size = 0;
        }

        public void add(int value) {
            if (size < CHUNK_SIZE) {
                data[size++] = value;
            }
        }

        public double getAverage() {
            if (size == 0) return 0.0;
            long sum = 0;
            for (int i = 0; i < size; i++) {
                sum += data[i];
            }
            return (double) sum / size;
        }
    }

    // ストリーム処理での活用
    public static long processLargeData(int[] data) {
        return Arrays.stream(data)
                    .parallel()  // 並列処理の活用
                    .filter(x -> x > 0)
                    .mapToLong(x -> x)
                    .sum();
    }
}

public class BatchProcessor {
    private static final int BATCH_SIZE = 1000;

    // バッチ処理での効率的なメモリ使用
    public static void processBatch(int[] data) {
        int totalBatches = (data.length + BATCH_SIZE - 1) / BATCH_SIZE;

        for (int batch = 0; batch < totalBatches; batch++) {
            int start = batch * BATCH_SIZE;
            int end = Math.min(start + BATCH_SIZE, data.length);

            // バッチ単位での処理
            processDataBatch(data, start, end);
        }
    }

    private static void processDataBatch(int[] data, int start, int end) {
        // バッチ処理の実装
        for (int i = start; i < end; i++) {
            // データ処理ロジック
            data[i] = data[i] * 2;  // 例: 各要素を2倍に
        }
    }
}

public class BitOperationOptimization {
    // フラグ管理の効率化
    private static final byte FLAG_READ = 1 << 0;    // 0001
    private static final byte FLAG_WRITE = 1 << 1;   // 0010
    private static final byte FLAG_EXECUTE = 1 << 2; // 0100

    private byte permissions = 0;

    public void setPermission(byte permission, boolean value) {
        if (value) {
            permissions |= permission;
        } else {
            permissions &= ~permission;
        }
    }

    public boolean hasPermission(byte permission) {
        return (permissions & permission) != 0;
    }

    // ビット操作を使用した数値処理の最適化
    public static int findNextPowerOf2(int value) {
        value--;
        value |= value >> 1;
        value |= value >> 2;
        value |= value >> 4;
        value |= value >> 8;
        value |= value >> 16;
        value++;
        return value;
    }
}

public class CacheOptimizedCode {
    // キャッシュフレンドリーな配列操作
    public static void processMatrix(int[][] matrix) {
        int rows = matrix.length;
        int cols = matrix[0].length;

        // キャッシュミスを最小限に抑えるループ順序
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                matrix[i][j] *= 2;  // 行優先でアクセス
            }
        }
    }

    // データの局所性を活用した処理
    public static int[] optimizedArrayProcessing(int[] data) {
        int length = data.length;
        int[] result = new int[length];

        // 一時変数を使用してメモリアクセスを削減
        for (int i = 0; i < length; i++) {
            int value = data[i];  // 一度だけ読み込み
            result[i] = value * value;  // 計算結果を格納
        }

        return result;
    }
}

// 回答例：
/*
1. メモリ格納方法
   - プリミティブ型：スタックに直接値を格納
   - 参照型：ヒープにオブジェクトを格納し、スタックに参照を保持

2. null値の扱い
   - プリミティブ型：null不可、デフォルト値あり
   - 参照型：null可能

3. メモリ使用量
   - プリミティブ型：固定サイズで効率的
   - 参照型：オブジェクトオーバーヘッドあり

実装例：
*/
public class TypeComparison {
    private int primitiveValue = 42;        // 4バイト
    private Integer referenceValue = 42;    // 16バイト以上

    public void demonstrateDifference() {
        // プリミティブ型はnullを受け付けない
        // primitiveValue = null;  // コンパイルエラー

        // 参照型はnull可能
        referenceValue = null;  // OK
    }
}

// 回答例：
/*
自動ボクシング：プリミティブ型を対応するラッパークラスに自動変換
アンボクシング：ラッパークラスをプリミティブ型に自動変換

注意点：
- パフォーマンスオーバーヘッドが発生
- 特にループ内での使用は注意が必要
*/

public class BoxingExample {
    public void demonstrateBoxing() {
        // 自動ボクシング
        Integer boxed = 100;  // int → Integer

        // 自動アンボクシング
        int unboxed = boxed;  // Integer → int

        // パフォーマンスの問題例
        Integer sum = 0;
        for (int i = 0; i < 1000000; i++) {
            sum += i;  // 毎回ボクシング/アンボクシングが発生
        }
    }
}

public class PerformanceIssues {
    // 問題のあるコード
    public static Integer[] createArray(int size) {
        Integer[] array = new Integer[size];
        for (int i = 0; i < size; i++) {
            array[i] = i;  // 自動ボクシングのオーバーヘッド
        }
        return array;
    }

    // 最適化されたコード
    public static int[] createOptimizedArray(int size) {
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = i;  // プリミティブ型を直接使用
        }
        return array;
    }
}

public class MemoryLeakPrevention {
    // メモリリークの可能性があるコード
    private List<Integer> numbers = new ArrayList<>();

    public void processNumbers(int[] data) {
        for (int value : data) {
            numbers.add(value);  // ボクシングとメモリ消費
        }
    }

    // 改善されたコード
    private IntArrayList numbers = new IntArrayList();  // プリミティブ特化型

    public void processNumbersOptimized(int[] data) {
        for (int value : data) {
            numbers.add(value);  // プリミティブ型をそのまま使用
        }
    }
}

public class InterviewQuestions {
    // Q: このコードの問題点を指摘してください
    public static class ProblemCode {
        private Integer count = 0;

        public void increment() {
            count++;  // 非効率な実装
        }

        public Integer getCount() {
            return count;
        }
    }

    // 改善された実装
    public static class ImprovedCode {
        private int count = 0;  // プリミティブ型を使用

        public void increment() {
            count++;  // 直接インクリメント
        }

        public int getCount() {
            return count;
        }
    }
}

public class OptimizationExample {
    // Q: このコードを最適化してください
    public static Double calculateAverage(List<Integer> numbers) {
        Double sum = 0.0;
        for (Integer number : numbers) {
            sum += number;
        }
        return sum / numbers.size();
    }

    // 最適化された解答
    public static double calculateAverageOptimized(List<Integer> numbers) {
        double sum = 0.0;
        int size = numbers.size();
        for (int i = 0; i < size; i++) {
            sum += numbers.get(i);  // アンボクシングは1回だけ
        }
        return sum / size;
    }
}

public class ImplementationChoice {
    // Q: 以下のフィールドの型選択の妥当性を評価してください
    public class UserProfile {
        private int id;              // OK: 主キー、null不要
        private Integer age;         // 要検討: nullが必要か?
        private boolean active;      // OK: 2値のフラグ
        private Boolean verified;    // 要検討: nullの必要性
        private long lastLoginTime;  // OK: タイムスタンプ
    }

    // 改善提案
    public class OptimizedUserProfile {
        private final int id;        // 変更不可として定義
        private int age;            // null不要なら基本型
        private boolean active;     // そのまま
        private boolean verified;   // nullが不要なら基本型
        private long lastLoginTime; // そのまま

        // 値の有無を表現する必要がある場合は Optional を使用
        public Optional<Integer> getAge() {
            return age == 0 ? Optional.empty() : Optional.of(age);
        }
    }
}