[備忘録 その７] Java Silver ～基本データ型の型変換～

# 基本データ型の型変換(キャスト)
基本データ型の型変換は、プログラム内でのデータ型を変更するための操作です。Javaでは、データ型の変換には2つの主要な方法があります。
1 \. 暗黙的型変換(自動型変換)　
2 \. 明示的型変換(キャスト)

## 1 \. 暗黙的型変換(自動型変換)
暗黙的型変換は、コンパイラが自動的に行う変換で、変換先の型が変換元の偏りも広い(より大きな範囲を持つ)場合に適用されます。例えば'int'型の値を'long'型の変数に代入する場合などです。

```java
public class Main {
    public static void main(String[] args) {
        int intValue = 100;
        long longValue = intValue;  // intからlongへの自動型変換
        System.out.println("Long value: " + longValue);  // Long value: 100
    }
}
```
この例では、intからlongへの変換は暗黙的に行われます。

## 2 \. 明示的型変換（キャスト）
明示的型変換は、プログラマが自分で型変換を指示する方法です。変換先の型が変換元の型よりも狭い（より小さな範囲を持つ）場合に使用します。これにはキャスト演算子（(type)）を使用します。

```java
public class Main {
    public static void main(String[] args) {
        double doubleValue = 9.78;
        int intValue = (int) doubleValue;  // doubleからintへの明示的型変換（キャスト）
        System.out.println("Int value: " + intValue);  // Int value: 9
    }
}
```
この例では、doubleからintへの変換はキャスト演算子を使って行います。キャストすると、doubleの値が切り捨てられ、整数部分だけが保存されます。

### 基本データ型とその変換

#### 1 \. byte < short < int < long < float < double
* byte (8ビット): -128 から 127
* short (16ビット): -32,768 から 32,767
* int (32ビット): -2,147,483,648 から 2,147,483,647
* long (64ビット): -9,223,372,036,854,775,808 から 9,223,372,036,854,775,807
* float (32ビット浮動小数点): 約 ±1.4E-45 から ±3.4E38
* double (64ビット浮動小数点): 約 ±4.9E-324 から ±1.8E308

##### 型変換の例
intからbyteへの変換（キャストが必要）
```java
public class Main {
    public static void main(String[] args) {
        int intValue = 130;
        byte byteValue = (byte) intValue;  // intからbyteへのキャスト
        System.out.println("Byte value: " + byteValue);  // Byte value: -126
    }
}

```
intの値がbyteの範囲を超えているため、キャストするとオーバーフローが発生し、負の値になります。

##### floatからintへの変換（キャストが必要）
```java
public class Main {
    public static void main(String[] args) {
        float floatValue = 123.45f;
        int intValue = (int) floatValue;  // floatからintへのキャスト
        System.out.println("Int value: " + intValue);  // Int value: 123
    }
}
```
小数部分は切り捨てられ、整数部分だけが保存されます。

### 型変換に関する注意点
1 \. 精度の損失: 大きなデータ型から小さなデータ型への変換では、精度や範囲の損失が発生する可能性があります。

2 \. オーバーフロー: 数値が変換先の型の範囲を超える場合、オーバーフローが発生する可能性があります。

3 \. 非整数型から整数型への変換: floatやdouble型からint型への変換では、小数部分が切り捨てられます。

# ラッパークラスとボクシング/アンボクシング
ラッパークラス（Wrapper Classes）とボクシング（Boxing）/アンボクシング（Unboxing）は、Javaにおいて基本データ型とオブジェクト型を相互に変換するためのメカニズムです。

## ラッパークラス(Wrapper Classes)
ラッパークラスは、基本データ型(プリミティブ型)をオブジェクトがとして扱うためのクラスです。これにより、基本データ型をコレクションなどオブジェクトを扱う場合で利用することができます。
* Byte：byte型のラッパークラス
* Short：short型のラッパークラス
* Integer：int型のラッパークラス
* Long：long型のラッパークラス
* Float：float型のラッパークラス
* Double：double型のラッパークラス
* Character：char型のラッパークラス
* Boolean：boolean型のラッパークラス
```java
public class Main {
    public static void main(String[] args) {
        // 基本データ型
        int num = 10;
        
        // ラッパークラスを使ってオブジェクトを生成
        Integer numObj = Integer.valueOf(num);
        
        // オブジェクトを基本データ型に変換
        int numBack = numObj.intValue();
        
        System.out.println("Original number: " + num);        // Original number: 10
        System.out.println("Boxed number: " + numObj);        // Boxed number: 10
        System.out.println("Unboxed number: " + numBack);     // Unboxed number: 10
    }
}

```
## ボクシング(Boxing)
ボクシングは、基本データ型をラッパークラスのオブジェクトに変換するプロセスです。自動ボクシングという機能により、Javaコンパイラは基本データ型を自動的にラッパークラスのオブジェクトに変換します。
```java
public class Main {
    public static void main(String[] args) {
        int num = 100;
        // 自動ボクシング
        Integer numObj = num;  // intからIntegerへの変換（自動ボクシング）
        System.out.println("Boxed number: " + numObj);  // Boxed number: 100
    }
}
```

## アンボクシング
アンボクシングは、ラッパークラスのオブジェクトを基本データ型に変換するプロセスです。自動ンボクシングは、ラッパークラスのオブジェクトを基本データ型に変換するプロセスです。自動アンボクシング（Auto-unboxing）という機能により、Javaコンパイラはラッパークラスのオブジェクトを自動的に基本データ型に変換します。

```java
public class Main {
    public static void main(String[] args) {
        Integer numObj = 200;
        // 自動アンボクシング
        int num = numObj;  // Integerからintへの変換（自動アンボクシング）
        System.out.println("Unboxed number: " + num);  // Unboxed number: 200
    }
}
```

## ラッパークラスの主なメソッド
### Integerクラスのメソッド
```java
public class Main {
    public static void main(String[] args) {
        String str = "123";
        
        // 文字列を整数に変換
        int num = Integer.parseInt(str);
        System.out.println("Parsed integer: " + num);  // Parsed integer: 123
        
        // 整数を文字列に変換
        String numStr = Integer.toString(num);
        System.out.println("Integer to string: " + numStr);  // Integer to string: 123
        
        // 最大値と最小値を取得
        System.out.println("Max value of int: " + Integer.MAX_VALUE);  // Max value of int: 2147483647
        System.out.println("Min value of int: " + Integer.MIN_VALUE);  // Min value of int: -2147483648
    }
}

```
### Doubleクラスのメソッド
```java
public class Main {
    public static void main(String[] args) {
        String str = "3.14";
        
        // 文字列を浮動小数点数に変換
        double num = Double.parseDouble(str);
        System.out.println("Parsed double: " + num);  // Parsed double: 3.14
        
        // 浮動小数点数を文字列に変換
        String numStr = Double.toString(num);
        System.out.println("Double to string: " + numStr);  // Double to string: 3.14
        
        // 最大値と最小値を取得
        System.out.println("Max value of double: " + Double.MAX_VALUE);  // Max value of double: 1.7976931348623157E308
        System.out.println("Min value of double: " + Double.MIN_VALUE);  // Min value of double: 4.9E-324
    }
}

```
#### ラッパークラスの使用ケース
* コレクション: List, Set, Map などのコレクションには、基本データ型を直接扱うことができないため、ラッパークラスを使用します。

* オートボクシング/アンボクシング: 自動で変換が行われるため、コードがシンプルになります。


最初のページ
[[備忘録 その１] Java Silver ～Javaプログラミング基礎～](https://qiita.com/MagicShowTime/items/9fcf3a2cb4a7162aafcf "[備忘録 その１] Java Silver ～Javaプログラミング基礎～")

前のページ
[[備忘録 その６] Java Silver ～文字列の取り扱いとデータの比較～](https://qiita.com/MagicShowTime/items/6f788fa9e2d525ccdbb0 "[備忘録 その６] Java Silver ～文字列の取り扱いとデータの比較～")

次のページ
[[備忘録 その８] Java Silver ～制御文～](https://qiita.com/MagicShowTime/items/4e98cb55e87555045cf8 "[備忘録 その８] Java Silver ～制御文～")