Java sample code 01

#1.Java サンプルプログラム
##[SAMPLE GALLERY](http://blueplace.sakura.ne.jp/index.html)に掲載されたソースを疎通してimport文も付けました。
- Java 基本
  - Hello World（文字をコンソールに出力）
  - for文（ループ）
  - if文（条件分岐）
  - switch文（条件分岐）
  - 簡単な四則演算
  - メソッドの呼び出し
  - メソッドの呼び出し（引数有り）
  - 配列
  - 多次元配列
  - コンソールに入力
  - 文字数の取得
  - Listクラス
  - Mapクラス
  - Setクラス
- Java Stringクラス（文字列）
  - 二つの文字列が同じかどうか判定：equals
  - 大文字小文字区別なく２つの文字列が同じかどうか判定:equalsIgnoreCase
  - 辞書の順序で文字列の大小を比較：compareTo
  - 大文字小文字区別なく辞書の順序で文字列の大小を比較：compareToIgnoreCase
  - 文字列の結合：concat
  - 一文字取得：charAt
  - 文字列の一部を取得：substring
  - 大文字小文字の変換：toLowerCase、toUpperCase
- Java Mathクラス（数値処理）
  - Math.max(int, int) （大きい値を返す）
  - Math.min(int, int) （小さい値を返す）
  - Math.floor(double)（切り捨て）
  - Math.round(double) （四捨五入）
  - Math.ceil(double) （切り上げ）
  - Math.abs(int) （絶対値）
  - Math.abs(double, double) （累乗）
  - Math.random() （乱数）
- Java Calendar、Date、DateFormatクラス（日付処理）
  - 本日（今）のCalendarオブジェクトを作成
  - 年、月、日、時、分、秒を取得
  - 特定の日付のCalendarオブジェクトを作成
  - add(int field, int amount) （Calendarオブジェクトの値を編集）
  - Calendar.before/after （日付比較）
  - java.util.Dateオブジェクトの作成
  - SimpleDateFormat（日時を任意の形式で表示）
- Java File（ファイル処理）
  - ファイルの作成：createNewFile()
  - ファイルの削除：delete()
  - ディレクトリの作成：mkdir()
  - ディレクトリの作成：mkdirs()
  - ファイル名（またはディレクトリ名）の取得：getName()
  - 絶対パスの取得：getAbsolutePath()
  - 親ディレクトリオブジェクトを取得：getParentFile()
  - 親ディレクトリのパスを取得：getParent()
  - ディレクトリかどうか判定：isDirectory()
  - ファイルかどうか判定：isFile()
  - 隠しファイルかどうかを判定：isHidden()
  - ファイル（またはディレクトリ）か存在するかどうか判定：exists()
  - 最終更新日時を取得：lastModified()
  - ディレクトリ直下のファイルとディレクトリをすべて取得：listFiles()
  - ディレクトリ直下のファイルとディレクトリを条件を指定して取得：FilenameFilter
- Java BigDecimalクラス（数値処理）
  - BigDecimalのオブジェクトを作成
  - 加算（足し算）：add(BigDecimal augend)
  - 減算（引き算）：subtract(BigDecimal subtrahend)
  - 乗算（掛け算）：multiply(BigDecimal multiplicand)
  - 除算（割り算）：divide(BigDecimal divisor)
  - 切り捨て：RoundingMode.FLOOR
  - 切り上げ：RoundingMode.CEILING
  - 四捨五入：RoundingMode.HALF_UP
  - 絶対値：abs()
  - 累乗：pow(int n)
  - max(BigDecimal val)
  - min(BigDecimal val)
  - 大小比較：compareTo(BigDecimal val)
  - 除算の余り：remainder(BigDecimal divisor)

##1.Java サンプルプログラム
###1-1.Java 基本
####1-1-1.Hello World（文字をコンソールに出力）
```java
public class SampleJava {

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

}
```
####1-1-2.for文（ループ）
```java
public class SampleJava {

  public static void main(String[] args) {
    int sum = 0;

    //「for (int i = 1; i <= 5; i++) {」に関して
    //int i = 1 ⇒ iを1で初期化
    //i <= 5 ⇒ iが5以下の場合ループの処理を行う
    //i++ ⇒ iに1を足す（ループないの処理が終わった後）
    for (int i = 1; i <= 5; i++) {
      sum += i;//変数sumにiを足す
    }
    System.out.println(sum);//変数sumを表示
  }

}
```
####1-1-3.if文（条件分岐）
```java
public class SampleJava {

  public static void main(String[] args) {
    int a = 11;//ここは自由に変える。

    if (a > 10) {//10より大きいか判定
      System.out.println("aは10より大きいです。");
    } else {
      System.out.println("aは10以下です。");
    }
  }

}
```
####1-1-4.switch文（条件分岐）
```java
public class SampleJava {

  public static void main(String[] args) {
    int score = 4;//ここは1～5までの数字で自由に変えます。
    String result = null;

    switch (score) {
      case 5://scoreが5の時
        result = "A";
        break;
      case 4://scoreが4の時
        result = "B";
        break;
      case 3://scoreが3の時
        result = "C";
        break;
      case 2://scoreが2の時
        result = "D";
        break;
      case 1://scoreが1の時
        result = "E";
        break;
      default://scoreが上記以外の時
        break;
    }

    if (result != null) {
      System.out.println(result + "評価です。");
    }
  }

}
```    
####1-1-5.簡単な四則演算
```java
public class SampleJava {

  public static void main(String[] args) {
    int a = 10;
    int b = 5;

    //加算
    System.out.println(a + b);

    //減算
    System.out.println(a - b);

    //乗算
    System.out.println(a * b);

    //除算
    System.out.println(a / b);
  }

}
```    
####1-1-6.メソッドの呼び出し
```java
public class SampleJava {

  public static void main(String[] args) {
    moring();
    noon();
    evening();
  }

  private static void moring() {
    System.out.println("朝です。");
  }

  private static void noon() {
    System.out.println("昼です。");
  }

  private static void evening() {
    System.out.println("夜です。");
  }

}
```    
####1-1-7.メソッドの呼び出し（引数有り）
```java
public class SampleJava {

  public static void main(String[] args) {
    int output = plus(10, 30);
    System.out.println(output);
  }

  /**
   * 引数を渡せるメソッド。
   * aとbを足した結果を返します。
   * @param a
   * @param b
   * @return
   */
  private static int plus(int a, int b) {
    return a + b;
  }

}
```    
####1-1-8.配列
```java
public class SampleJava {

  public static void main(String[] args) {
    //配列の宣言
    int[] intArray = { 10, 20, 30, 40, 50 };

    //以下の[]の中の数字を指定し、配列の中の任意の値を取り出す。この例では0～4。
    System.out.println(intArray[0]);
  }

}
```    
####1-1-9.多次元配列
```java
public class SampleJava {

  public static void main(String[] args) {
    //多次元配列の宣言
    String[][] testScore = {
      { "国語", "80" }
      , { "算数", "90" }
      , { "社会", "70" }
      , { "理科", "75" }
    };

    System.out.println("教科:" + testScore[1][0] + "、点数:" + testScore[1][1]);
  }

}
```    
####1-1-10.コンソールに入力
```java
import java.util.Scanner;

public class SampleJava {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String inputStr = scan.next();//ここでコンソールに入力したものを取得
        System.out.println("コンソールに入力された文字は、「" + inputStr + "」です。");
    }

}
```    
####1-1-11.文字数の取得
```java
public class SampleJava {

  public static void main(String[] args) {
    String str = "おはよう";
    System.out.println(str.length());//length()で文字数を取得
  }

}
```    
####1-1-12.Listクラス
```java
import java.util.ArrayList;
import java.util.List;

public class SampleJava {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("10");
        list.add("15");
        list.add("20");
        System.out.println(list.get(1));//list.get(index)でlistの値を取得します。一番最初は0
    }

}
```    
####1-1-13.Mapクラス
```java
import java.util.HashMap;
import java.util.Map;

public class SampleJava {

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        //以下map.put(key, value)で値をセット
        map.put("A", "100");
        map.put("B", "80");
        map.put("C", "60");
        map.put("D", "40");
        map.put("E", "20");

        //map.get(key)で指定したkeyのvalueを取得
        System.out.println(map.get("C"));
    }

}
```    
####1-1-14.Setクラス
```java
import java.util.HashSet;
import java.util.Set;

public class SampleJava {

    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        //以下setに値を追加。同じ値は追加されない。以下の例ではAは一つだけ追加される。
        set.add("A");
        set.add("A");
        set.add("B");
        set.add("C");

        for (String val : set) {
            System.out.println(val);
        }
    }
}
```
##1.Java サンプルプログラム
###1-2.Java Stringクラス（文字列）
####1-2-1.二つの文字列が同じかどうか判定：equals
```java
public class SampleString {

  public static void main(String[] args) {
    String str1 = "abcde";
    String str2 = "abcde";
    String str3 = "fghij";

    //「A.equals(B)」でAとBが同じ値かどうかを判定する。
    //str1とstr2は同じ値なので、true。
    System.out.println(str1.equals(str2));

    //str1とstr3は違う値なので、false。
    System.out.println(str1.equals(str3));
  }
}
```    
####1-2-2.大文字小文字区別なく２つの文字列が同じかどうか判定:equalsIgnoreCase
```java
public class SampleString {

  public static void main(String[] args) {
    String str1 = "Abcde";
    String str2 = "abcde";
    String str3 = "fghij";

    //「A.equalsIgnoreCase(B)」で、大文字小文字を区別せずAとBが同じ値かどうかを判定する。
    //str1とstr2は同じ値なので、true（「A」と「a」は同じとみなす）。
    System.out.println(str1.equalsIgnoreCase(str2));

    //str1とstr3は違う値なので、false。
    System.out.println(str1.equalsIgnoreCase(str3));
  }
}
```    
####1-2-3.辞書の順序で文字列の大小を比較：compareTo
```java
public class SampleString {

  public static void main(String[] args) {
    String str1 = "def";
    String str2 = "abc";
    String str3 = "ghi";
    String str4 = "def";

    //「A.compareTo(B)」で、辞書の順序で文字列の大小を比較する。
    //AがBより辞書で先にくる場合は、0以下
    //AとBが同じ場合は、0
    //AがBより辞書で後にくる場合は、0以上
    //になる。

    //str1はstr2より後にくるので0以上になる。
    System.out.println(str1.compareTo(str2));

    //str1はstr3より先にくるので0以下になる。
    System.out.println(str1.compareTo(str3));

    //str1はstr4と同じなので0になる。
    System.out.println(str1.compareTo(str4));
  }
}
```    
####1-2-4.大文字小文字区別なく辞書の順序で文字列の大小を比較：compareToIgnoreCase
```java
public class SampleString {

  public static void main(String[] args) {
    String str1 = "def";
    String str2 = "Def";

    //「A.compareToIgnoreCase(B)」で、辞書の順序で文字列の大小を比較する。
    //大文字小文字の違いは区別しない（同じとみなす）。

    //str1はstr2と同じなので0になる（「d」と「D」は同じとみなす）。
    System.out.println(str1.compareToIgnoreCase(str2));
  }
}
```    
####1-2-5.文字列の結合：concat
```java
public class SampleString {

  public static void main(String[] args) {
    String helloStr = "Hello";
    String spaceStr = " ";
    String worldStr = "World";

    // concat(String str)で文字列を結合
    System.out.println(helloStr.concat(spaceStr).concat(worldStr));
  }
}
```    
####1-2-6.一文字取得：charAt
```java
public class SampleString {

  public static void main(String[] args) {
    String str = "Hello World.";

    //charAt(int index)で文字列の中の一文字を取得する。
    //取得する文字は引数のindexで指定する。
    System.out.println(str.charAt(0));
  }
}
```    
####1-2-7.文字列の一部を取得：substring
```java
public class SampleString {

  public static void main(String[] args) {
    String str = "Hello World.";

    //substring(int beginIndex, int endIndex)で文字列の中の一部を取得する。
    //取得する文字列は引数のindexで指定する。
    System.out.println(str.substring(0, 5));
  }
}
```    
####1-2-8.大文字小文字の変換：toLowerCase、toUpperCase
```java
public class SampleString {

  public static void main(String[] args) {
    String str1 = "HELLO";
    String str2 = "world";

    //toLowerCase()で大文字を小文字に変換する。
    System.out.println(str1.toLowerCase());

    //toUpperCaseで小文字を大文字に変換する。
    System.out.println(str2.toUpperCase());
  }
}
```
##1.Java サンプルプログラム
###1-3.Java Mathクラス（数値処理）
####1-3-1.Math.max(int, int) （大きい値を返す）
```java
public class SampleMath {

  public static void main(String[] args) {
    //以下のaとbの値は任意のものに変える
    int a = 10;
    int b = 20;

    //Math.max(int, int)は、大きいほうの引数を返します。
    System.out.println(Math.max(a, b));
  }
}
```    
####1-3-2.Math.min(int, int) （小さい値を返す）
```java
public class SampleMath {

  public static void main(String[] args) {
    int a = 6;
    int b = 7;

    //Math.min(int, int)は、小さいほうの値を返します。
    System.out.println(Math.min(a, b));
  }
}
```    
####1-3-3.Math.floor(double)（切り捨て）
```java
public class SampleMath {

  public static void main(String[] args) {
    double a = 100.9;

    //Math.floor(double)。小数点以下を切り捨て。
    System.out.println(Math.floor(a));
  }
}
```    
####1-3-4.Math.round(double) （四捨五入）
```java
public class SampleMath {

  public static void main(String[] args) {
    double a = 7.5;

    //Math.round(double)。小数点以下を四捨五入。
    System.out.println(Math.round(a));
  }
}
```    
####1-3-5.Math.ceil(double) （切り上げ）
```java
public class SampleMath {

  public static void main(String[] args) {
    double a = 20.1;

    //Math.ceil(double)。小数点以下を切り上げ。
    System.out.println(Math.ceil(a));
  }
}
```    
####1-3-6.Math.abs(int) （絶対値）
```java
public class SampleMath {

  public static void main(String[] args) {
    int a = -7;

    //Math.abs(int)。絶対値を返す。
    System.out.println(Math.abs(a));
  }
}
```    
####1-3-7.Math.abs(double, double) （累乗）
```java
public class SampleMath {

  public static void main(String[] args) {
    double a = 10;
    double b = 2;

    //Math.abs(double, double)。累乗を返す。この例では10の2乗で100
    System.out.println(Math.pow(a, b));
  }
}
```    
####1-3-8.Math.random() （乱数）
```java
public class SampleMath {

  public static void main(String[] args) {
    //Math.random()。0.0以上1.0未満の数をランダムで返す。
    System.out.println(Math.random());
  }
}
```
##1.Java サンプルプログラム
###1-4.Java Calendar、Date、DateFormatクラス（日付処理）
####1-4-1.本日（今）のCalendarオブジェクトを作成
```java
import java.util.Calendar;

public class SampleCalendar {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
    }
}
```    
####1-4-2.年、月、日、時、分、秒を取得
```java
import java.util.Calendar;

public class SampleCalendar {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.println("年：" + cal.get(Calendar.YEAR));
        System.out.println("月：" + (cal.get(Calendar.MONTH) + 1));//月は0~11のため、+1している。
        System.out.println("日：" + cal.get(Calendar.DATE));
        System.out.println("時：" + cal.get(Calendar.HOUR_OF_DAY));
        System.out.println("分：" + cal.get(Calendar.MINUTE));
        System.out.println("秒：" + cal.get(Calendar.SECOND));
    }
}
```    
####1-4-3.特定の日付のCalendarオブジェクトを作成
```java
import java.util.Calendar;

public class SampleCalendar {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(2010, 0, 1);//2010年1月1日をセット。月は0~11なので、0をセット。

        //「2010/1/1」と表示される。
        System.out.println(cal.get(Calendar.YEAR)
                + "/" + (cal.get(Calendar.MONTH) + 1)
                + "/" + cal.get(Calendar.DATE));
    }
}
```    
####1-4-4.add(int field, int amount) （Calendarオブジェクトの値を編集）
```java
import java.util.Calendar;

public class SampleCalendar {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();

        //本日の日付が表示される
        displayConsole(cal);

        //add(int field, int amount)でCalendarオブジェクトの年、月、日などの各値を増減できます。
        //以下は日を１日減らしています。
        cal.add(Calendar.DATE, -1);
        displayConsole(cal);

        //以下は月を１か月増やしています。
        cal.add(Calendar.MONTH, 1);
        displayConsole(cal);
    }

    private static void displayConsole(Calendar cal) {
        System.out.println(cal.get(Calendar.YEAR)
                + "/" + cal.get(Calendar.MONTH)
                + "/" + cal.get(Calendar.DATE));
    }
}
```    
####1-4-5.Calendar.before/after （日付比較）
```java
import java.util.Calendar;

public class SampleCalendar {

    public static void main(String[] args) {
        Calendar calA = Calendar.getInstance();
        Calendar calB = Calendar.getInstance();
        calB.add(Calendar.DATE, 1);//calBを一日後の値にする。

        //calAがcalBより前の日時であれば、trueを返す。この例ではtrue。
        System.out.println(calA.before(calB));
        //calAがcalBより後の日時であれば、trueを返す。この例ではfalse。
        System.out.println(calA.after(calB));
    }

}
```    
####1-4-6.java.util.Dateオブジェクトの作成
```java
import java.util.Calendar;
import java.util.Date;

public class SampleDate {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date);
    }

}
```    
####1-4-7.SimpleDateFormat（日時を任意の形式で表示）
```java
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class SampleDate {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();

        //「年」を表示するフォーマットを作成。例：2016
        DateFormat format = new SimpleDateFormat("yyyy");
        System.out.println(format.format(date));

        //「月」を表示するフォーマットを作成。例：05
        format = new SimpleDateFormat("MM");
        System.out.println(format.format(date));

        //「日」を表示するフォーマットを作成。例：01
        format = new SimpleDateFormat("dd");
        System.out.println(format.format(date));

        //「時」を表示するフォーマットを作成。例：00
        format = new SimpleDateFormat("HH");
        System.out.println(format.format(date));

        //「分」を表示するフォーマットを作成。例：00
        format = new SimpleDateFormat("mm");
        System.out.println(format.format(date));

        //「秒」を表示するフォーマットを作成。例：00
        format = new SimpleDateFormat("ss");
        System.out.println(format.format(date));

        //「○○/○○/○○」を表示。例：2000/01/01
        format = new SimpleDateFormat("yyyy/MM/dd");
        System.out.println(format.format(date));

        //「○○年○○月○○日 ○○:○○:○○（○○時○○分○○秒）」を表示。例：2000年1月1日
        format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        System.out.println(format.format(date));

    }

}
```
##1.Java サンプルプログラム
###1-5.Java File（ファイル処理）
####1-5-1.ファイルの作成：createNewFile()
```java
import java.io.File;
import java.io.IOException;

public class SampleDate {

    public static void main(String[] args) {
        //ファイルオブジェクトを作成しています。引数には作成するファイルのパスを指定します。
        File file = new File("C:\\sample\\test.txt");
        try {
            //以下でファイルを作成しています。
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
```    
####1-5-2.ファイルの削除：delete()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\test.txt");
        //以下で指定したファイルを削除します。
        file.delete();
    }

}
```    
####1-5-3.ディレクトリの作成：mkdir()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\sampledir");
        //以下で指定したディレクトリを作成します。
        file.mkdir();
    }

}
```    
####1-5-4.ディレクトリの作成：mkdirs()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\sampledir\\sampledir2");
        //以下でディレクトリを作成します。mkdir()と異なり、親ディレクトリで必要なものも作成します。
        //この例では「C:\\sample」というディレクトリがある状態で実行した場合、
        //「sampledir」と「sampledir2」の二つが作成されます。
        file.mkdirs();
    }

}
```    
####1-5-5.ファイル名（またはディレクトリ名）の取得：getName()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\test.txt");
        //指定したファイル（またはディレクトリ）の名称を取得
        System.out.println(file.getName());
    }

}
```    
####1-5-6.絶対パスの取得：getAbsolutePath()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\test.txt");
        //ファイルの絶対パスを取得
        System.out.println(file.getAbsolutePath());
    }

}
```    
####1-5-7.親ディレクトリオブジェクトを取得：getParentFile()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\test.txt");

        //親ディレクトリオブジェクトを取得
        File parent = file.getParentFile();

        System.out.println(parent);
    }

}
```    
####1-5-8.親ディレクトリのパスを取得：getParent()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\test.txt");

        //親ディレクトリのパスを取得
        String parentPath = file.getParent();

        System.out.println(parentPath);
    }
}
```    
####1-5-9.ディレクトリかどうか判定：isDirectory()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample");

        //以下でディレクトリかどうかを判定する。この例ではディレクトリのため、true。
        System.out.println(file.isDirectory());
    }
}
```    
####1-5-10.ファイルかどうか判定：isFile()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample");

        //以下でファイルかどうかを判定する。この例ではディレクトリのため、false。
        System.out.println(file.isFile());
    }
}
```    
####1-5-11.隠しファイルかどうかを判定：isHidden()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\test.txt");

        //以下で隠しファイルかどうかを判定する。
        System.out.println(file.isHidden());
    }
}
```    
####1-5-12.ファイル（またはディレクトリ）か存在するかどうか判定：exists()
```java
import java.io.File;

public class SampleDate {

    public static void main(String[] args) {
        File file = new File("C:\\sample\\test.txt");

        //以下でファイル（またはディレクトリ）か存在するかどうかを判定する
        System.out.println(file.exists());
    }
}
```
##1.Java サンプルプログラム
###1-6.Java BigDecimalクラス（数値処理）
####1-6-1.BigDecimalのオブジェクトを作成
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {
        //以下でBigDecimalのオブジェクトを作成
        BigDecimal obj = new BigDecimal("1");

        System.out.println(obj);
    }
}
```
####1-6-2.加算（足し算）：add(BigDecimal augend)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("1");
        BigDecimal obj2 = new BigDecimal("2");

        //add(BigDecimal augend)で加算を行い、結果を返す。
        BigDecimal result = obj1.add(obj2);

        System.out.println(result);
    }
}
```
####1-6-3.減算（引き算）：subtract(BigDecimal subtrahend)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("5");
        BigDecimal obj2 = new BigDecimal("3");

        //subtract(BigDecimal subtrahend)で減算を行い、結果を返す。
        BigDecimal result = obj1.subtract(obj2);

        System.out.println(result);
    }
}
```
####1-6-4.乗算（掛け算）：multiply(BigDecimal multiplicand)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("2");
        BigDecimal obj2 = new BigDecimal("4");

        //multiply(BigDecimal multiplicand)で乗算を行い、結果を返す。
        BigDecimal result = obj1.multiply(obj2);

        System.out.println(result);
    }
}
```
####1-6-5.除算（割り算）：divide(BigDecimal divisor)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("30");
        BigDecimal obj2 = new BigDecimal("5");

        //divide(BigDecimal divisor)で除算を行い、結果を返す。
        BigDecimal result = obj1.divide(obj2);

        System.out.println(result);
    }
}
```
####1-6-6.切り捨て：RoundingMode.FLOOR
```java
import java.math.BigDecimal;
import java.math.RoundingMode;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("400.545");

        //setScale(int newScale, RoundingMode roundingMode)で桁数と丸め動作を指定。
        //RoundingMode.FLOOR（切り捨て）
        //以下の例では、小数点第一位を切り捨てた結果のオブジェクトを返している。
        obj1 = obj1.setScale(0, RoundingMode.FLOOR);

        System.out.println(obj1);
    }
}
```
####1-6-7.切り上げ：RoundingMode.CEILING
```java
import java.math.BigDecimal;
import java.math.RoundingMode;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("400.545");

        //setScale(int newScale, RoundingMode roundingMode)で桁数と丸め動作を指定。
        //RoundingMode.CEILING（切り上げ）
        //以下の例では、小数点第二位を切り上げた結果のオブジェクトを返している。
        obj1 = obj1.setScale(1, RoundingMode.CEILING);

        System.out.println(obj1);
    }
}
```
####1-6-8.四捨五入：RoundingMode.HALF_UP
```java
import java.math.BigDecimal;
import java.math.RoundingMode;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("400.545");

        //setScale(int newScale, RoundingMode roundingMode)で桁数と丸め動作を指定。
        //RoundingMode.HALF_UP（四捨五入）
        //以下の例では、小数点第三位を四捨五入した結果のオブジェクトを返している。
        obj1 = obj1.setScale(2, RoundingMode.HALF_UP);

        System.out.println(obj1);
    }
}
```
####1-6-9.絶対値：abs()
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj = new BigDecimal("-1");

        //abs()で絶対値を返す
        System.out.println(obj.abs());
    }
}
```
####1-6-10.累乗：pow(int n)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj = new BigDecimal("2");

        //pow(int n)で、値を累乗（n乗）した結果を返す。
        System.out.println(obj.pow(4));
    }
}
```
####1-6-11.max(BigDecimal val)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("4");
        BigDecimal obj2 = new BigDecimal("3");

        //max(BigDecimal val)でオブジェクトを比較し、大きいほうを返す。
        System.out.println(obj1.max(obj2));
    }
}
```
####1-6-12.min(BigDecimal val)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("4");
        BigDecimal obj2 = new BigDecimal("3");

        //min(BigDecimal val)でオブジェクトを比較し、小さいほうを返す。
        System.out.println(obj1.min(obj2));
    }
}
```
####1-6-13.大小比較：compareTo(BigDecimal val)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("1");
        BigDecimal obj2 = new BigDecimal("3");

        //compareTo(BigDecimal val)
        //オブジェクトを引数のものと比較し、
        //大きければ「1」
        //同じならば「0」
        //小さければ「-1」
        //を返す。
        if (obj1.compareTo(obj2) > 0) {
            System.out.println("大きい");
        } else if (obj1.compareTo(obj2) < 0) {
            System.out.println("小さい");
        } else {
            System.out.println("同じ");
        }
    }
}
```
####1-6-14.除算の余り：remainder(BigDecimal divisor)
```java
import java.math.BigDecimal;

public class SampleBigDecimal {

    public static void main(String[] args) {

        BigDecimal obj1 = new BigDecimal("11");
        BigDecimal obj2 = new BigDecimal("3");

        //remainder(BigDecimal divisor)で除算を行い、余りを返す。
        BigDecimal result = obj1.remainder(obj2);

        System.out.println(result);
    }
}
```