Java基礎

 String str = null;    //変数
 final String STR = "msg";    //定数
 long l = 1111111111L;    //long型は最後にLで宣言
 float f = 1111.111F;    //float型は最後にFで宣言
 double d = 1111.111;    //小数点はdoubleになる
 char c = 'c';    //char型は''で
 str = "a\na\ta";    //\n:改行 \t:タブ
 String[] ss = {"a", "b"}; // 配列 

 //参照型としてintを宣言する
 Integer I = new Integer(32);
 int n = I.intValue();

 Integer I2 = 2;    // auto boxing
 int i = 1;    // auto unboxing

 if (条件式) {
     //処理
 } else if (条件式) {
     //処理
 } else {
     //処理
 }

 String singou = "red";
 switch (singou) {
     case "red":
            //処理
     break;
     case "yellow":
         //処理
     break;
     case "blue":
         //処理
     break;
     default:
         //処理
 }

 while (条件式) {
     //処理
 }

 do {
     //処理
 } while (条件式);

 for (int i=0; i<5; i++){
     if (i < 2) {
          continue;    //次のループ
     } else {
          break;       //ループ終了
     }
 }

 class Nest {
    public static void main(String[] args) {
        int num[][] = {
                        {0, 1, 2},
                        {3, 4, 5},
                        {6, 7, 8}
                      };
        int i = 0;
        label:
        while(true) {
            int j = 0;
            while(j < 3) {
                System.out.print(num[i][j]);
                j++;
                if(i == 1) break label;
            }
            i++;
        }
    }
}

 public class Animal {
    //コンストラクタ
    Animal(){
        System.out.println("new Animal created");
    }
    //引数付きコンストラクタ
    Animal(String species){
        System.out.println("new " + species + " created");
    }

    void animalMethod() {
        System.out.println("this is animal method!");
    }

    void characteristic() {
        System.out.println("I'm alive!");
    }
}

 //インターフェース宣言
 interface Breath {
    //メンバ変数は勝手にstatic finalになる
    String breath = "Breathing!";
    //インターフェースのメソッドは本文なし
    void breath(String breath);
}

 //継承とインターフェース実装
 public class Dog extends Animal implements Breath{
    //コンストラクタは暗黙的に super() されるが、
    //明示することで親の引数付きコンストラクタを指定できる。
    Dog(){
        super("Dog");
    }

    //オーバーライド
    //インターフェースの抽象メソッドはオーバーライドしないとエラー。
    @Override
    public void breath(String breath) {
        System.out.println(breath);
    }

    //オーバーライド
    @Override
    public void characteristic() {
        System.out.println("I have 4 legs!");
    }
 }

 public class Main {

    public static void main(String[] args) {

        Dog dog = new Dog();        //①new Dog created

        dog.animalMethod();         //②this is animal method!

        //インターフェースのメンバ変数はすべてstatic final
        dog.breath(Breath.breath); //③Breathing!

        dog.characteristic();      //④I have 4 legs!

        Animal dogA = new Dog();  //⑤new Dog created

        //dogA.breath();          //⑥

        dogA.characteristic();    //⑦I have 4 legs!
    }
 }

 class Calc {
    int sum(int a, int b) {
        return a + b;
    }
    //オーバーロード
    int sum(int a, int b, int c) {
        return a + b + c;
    }
 }

void variableLength(String... colors){
        for (String c : colors) {
            System.out.println(c);
        }
    }

/**
 * アウタークラス
 * インナークラスとは相互にprivateなメンバでもアクセスできる
 */
public class Outer {

    private String msg = "hello from outer!";
    private static String stMsg = "hello static from outer!";

    public static void main(String[] args) {
        Outer out = new Outer();
        // インナークラスのコンストラクタはアウタークラスのインスタンスが必要
        Inner in = out.new Inner();
        // staticインナークラスのコンストラクタ Comparatorなどの実装クラスを定義しておくときとかに使える
        StaticInner sIn = new StaticInner();
        in.inner(); // hello from outer! this is inner
        sIn.staticInner(); // hello static from outer! this is static inner
        StaticInner.staticInStatic(); // this is static in static
        out.test(); // hello from outer! this is no name inner
                    // this is no name
                    // this is local
    }
    /**
     * インナークラス
     * アウタークラスのメンバにはアクセスできる
     */
    public class Inner {
        private String inMsg = " this is inner";
        void inner() {
            System.out.println(msg + inMsg);
        }
    }

    /**
     * static インナークラス
     * インナークラスにはstaticをつけることができ、普通にコンストラクタを呼べる。
     */
    static class StaticInner {
        void staticInner() {
            // アウターのクラス変数なら使える
            System.out.println(stMsg + " this is static inner");
        }

        static void staticInStatic() {
            System.out.println("this is static in static");
        }
    }

    /**
     * 関数内のクラスをローカルクラス、無名クラスという
     */
    void test() {
        /*
         * 無名クラス
         * インターフェイスでもクラスでも、その型の実装インスタンスを生成する。
         */
        Inner i = new Inner() {
            void noName() {
                System.out.println("this is no name");
            }

            @Override
            void inner() {
                System.out.println(msg + " this is no name inner");
                noName(); // 定義したものは宣言の中でだけ使える(Innerの定義にはnoNameは含まれないため)
            }

        };
        i.inner();


        /**
         * ローカルクラス
         */
        class Local {
            void local() {
                System.out.println("this is local");
            }
        }

        Local l = new Local();
        l.local();

    }

}

abstract class Animal {
    String name;
 
    Animal(String name){
        this.name = name;
    }
    //具体的な処理を書ける。
    void sleep(){
        System.out.println("sleeping!");
    }
    //abstractメソッドは子クラスに実装を強制
    abstract void speak();
}
 
public interface MyInterface {
    /**
     * java8から、interface でもstatic関数は実装できる
     * ただし呼び出すには必ず、Static.staticFunc()とし、
     * 実装クラス.staticFunc()では呼び出せないし、オーバーライドもできない。
     * (インスタンスの挙動を決めるのがオーバーライドだから当たり前)
     */
    static void staticFunc() {
        System.out.println("this is static func");
    }

    /**
     * default句で実装可能
     * なお、スーパークラスを持つクラスにdefault句を持つインターフェイスを継承し、
     * 同じシグニチャを多重継承してしまった場合、スーパークラスが優先される
     */
    default void defaultFunc() {
        System.out.println(add("this is", " default func"));
    }

    /**
     * privateなinterface関数は実装が可能(default関数で使用するため)
     */
    private String add(String a, String b) {
        return a + b;
    }
}

 //列挙型 プログラム上では一つのクラスとして扱われる
 enum Output {
    OK, NG,
 }
 
 public class Enum {
 
    public static void main(String[] args) {
        Output out;
 
        out = Output.NG;
 
        switch (out) {
        case OK:
            System.out.println("OK!");
            System.out.println(out.ordinal()); // 0
            break;
        case NG:
            System.out.println("NG!");
            System.out.println(out.ordinal()); // 1
            break;
        }
    }
 }

 public class Parser {
 
    private String str = null;
 
    public String getStr() {
        return str;
    }
    private void setStr(String param) {
        str = param;
    }
 }

class StaticClass {
 
    //staticメンバ
    static String staticStr;
    static String getStaticStr(){
        return staticStr;
    }
    //インスタンスメンバ
    String instanceStr;
    String getInstatnceStr() {
        return instanceStr;
    }
 
    //staticイニシャライザ
    static {
        StaticClass.staticStr = "staticStr";
    }
    //インスタンスイニシャライザ
    {
        instanceStr = "instanceStr";
    }
 }
 
 class Main {
 
    public static void main(String[] args) {
 
        //static参照
        StaticClass.staticStr = StaticClass.staticStr + "Main";
        System.out.println(StaticClass.getStaticStr());  //staticStrMain
 
        //インスタンス参照
        StaticClass stsCls = new StaticClass();
        stsCls.instanceStr = stsCls.instanceStr + "Main";
        System.out.println(stsCls.instanceStr);  //instanceStrMain
    }
 }

List<Integer> list = new ArrayList<>();
 
list.add(10);
list.add(20);
System.out.println(list.get(1));  //20

Set<Integer> hashSet = new HashSet<Integer>();
 
hashSet.add(10);
hashSet.add(20);
hashSet.add(10);
System.out.println(hashSet.size());  //2

Map <String, Integer> hashMap = new HashMap<>();
 
hashMap.put("sato", 50);
hashMap.put("ito", 60);
 
System.out.println(hashMap.get("sato"));  //50

Queue<String> queue = new ArrayDeque<>();
queue.add("A");
queue.add("B");

System.out.println(queue.poll()); // A

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("A");
deque.addLast("B");

System.out.println(deque.pollLast()); // B

for (Integer data : list) {
    System.out.println(data);  //10, 20
}
 
//Map.Entry<K,V>はMapの中身の型（インターフェース）
//hashMap.entrySet()の戻り値の型はSet<Map.Entry<K,​V>>
for (Map.Entry<String, Integer> score : hashMap.entrySet()) {
    System.out.println(score.getKey() + " : " + score.getValue());
    //ito : 60
    //sato : 50
}

public class ExceptionSample {
 
    public static void main(String[] args) {
 
        try {
 
            //ここでNumberFormatException発生
            String s = "No.1";
            System.out.println(Integer.parseInt(s));
 
        } catch (ArithmeticException e) {
 
            System.err.println("ArithmeticException: " + e.getMessage());
 
        //NumberFormatExceptionはArithmeticExceptionのサブクラスではないので
        //Exceptionにcatchされる
        } catch (Exception e) {
 
            //Messageを得るときはgetMessage
            System.err.println("Exception: " + e.getMessage());
 
        } finally {
            try {
                //MyExceptionをthrowsさせる
                getErr();
 
            //MyExceptionをcatch
            }catch(MyException e){
                System.err.println(e.getMessage());
            }
        }
    }
 
    //自分でcatchしないときは呼び出しもとにExceptionを返す。
    static void getErr() throws MyException {
        throw new MyException("MyException!");
    }
}
 
//独自Exceptionの定義はextendsで
//コンストラクタで設定できる。
class MyException extends Exception {
    public MyException(String s) {
        super(s);
    }
}

 Exception: For input string: "No.1"
 MyException!

try {
  // 通常処理
} catch (AException | BException e) {
  // 例外処理
}

// 条件式がtrueならば、AssertionErrorを投げず、
// 条件式がfalseならば、与えられたメッセージを持つAssertionErrorが投げられる。
assert name != null : "name is null";

public class Main {
    public static void main(String[] args) {
        Item a = new Item("a", 100);
        Item b = new Item("b", 120);
        Item c = new Item("c", 80);

        List<Item> list = Arrays.asList(a, b, c);

        Collections.sort(list);
        list.forEach(System.out::println);
        // c $80
        // a $100
        // b $120
    }
}

package modern.java;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class With {
    public static void main(String[] args) {
        // try-with-resources構文を使うことでclose省略
        try(
                FileInputStream fi = new FileInputStream("file.csv");
                InputStreamReader is = new InputStreamReader(fi);
                BufferedReader br = new BufferedReader(is);
        ) {
            String line;
            int i = 0;

            while ((line = br.readLine()) != null) {
                if (i == 0) {
                    System.out.println(line);
                } else {
                    Person p = new Person();
                    String[] row = line.split(",");
                        p.setId(row[0]);
                        p.setName(row[1]);

                        // 処理

                        System.out.println(p.getId() + " " + p.getName());

                    System.out.print("\n");
                    i++;
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
 
    //LocalDateTimeの基礎
    LocalDateTime d = LocalDateTime.now();
    System.out.println(d.getYear());
    System.out.println(d.getMonth());
    System.out.println(d.getDayOfMonth());
    System.out.println(d.getHour());
    System.out.println(d.getMinute());
    System.out.println(d.getSecond());
    System.out.println(d.getNano());
 
    //特定日時を指定
    d = LocalDateTime.of(2015, 12, 15, 23, 30, 59);
    System.out.println(d.plusDays(20));       //2016-01-04T23:30:59
    System.out.println(d.minusDays(20));      //2015-11-25T23:30:59
    System.out.println(d.withDayOfMonth(20)); //2015-12-20T23:30:59
 
    //時刻の切り捨て
    LocalDateTime.of(2015, 12, 15, 23, 30, 59).truncatedTo(ChronoUnit.HOURS); // 2015-12-15T23:00
 
    //来月1日の12時
    d =
        LocalDateTime.now()
        .plusMonths(1)
        .withDayOfMonth(1)
        .withHour(12)
        .truncatedTo(ChronoUnit.HOURS);
 
    //文字列へ変換
    DateTimeFormatter f = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    d = LocalDateTime.parse("2015/12/15 23:30:59", f);
    System.out.println(d.format(f));    //2015/12/15 23:30:59
    f = DateTimeFormatter.ofPattern("yyyy/MM/dd");
    System.out.println(d.format(f));    //2015/12/15
}

NumberFormat a = NumberFormat.getInstance();
NumberFormat b = NumberFormat.getIntegerInstance();
NumberFormat c = NumberFormat.getCurrencyInstance();
NumberFormat d = NumberFormat.getPercentInstance();

double num = 1000.1;

System.out.println(a.format(num)); // 1,000.1
System.out.println(b.format(num)); // 1,000
System.out.println(c.format(num)); // ¥1,000
System.out.println(d.format(num)); // 100,010%

package modern.java;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Option {
    public static void main(String[] args) {
        Optional<Integer> optionalValue = IntegerList.get(2);
        //optionalをorElseでnullのときの代替値にできる
        Integer i = optionalValue.orElse(-1) + 100;

        System.out.println(i);
    }
}

/**
 * OptionalはNullになりえる値をラップして返すのに使える
 * Nullチェックを簡潔にし、Nullがあり得ることを明示できる
 */
class IntegerList {
    private final static List<Integer> INTEGER_LIST = Arrays.asList(new Integer[]{1,2,null});

    public static Optional<Integer> get(int index) {
        //ラップして返す
        return Optional.ofNullable(INTEGER_LIST.get(index));
    }
}

 // Accumulate names into a List
 List<String> list = people.stream()
   .map(Person::getName)
   .collect(Collectors.toList());

 // Accumulate names into a TreeSet
 Set<String> set = people.stream()
   .map(Person::getName)
   .collect(Collectors.toCollection(TreeSet::new));

 // Convert elements to strings and concatenate them, separated by commas
 String joined = things.stream()
   .map(Object::toString)
   .collect(Collectors.joining(", "));

 // Compute sum of salaries of employee
 int total = employees.stream()
   .collect(Collectors.summingInt(Employee::getSalary));

 // Group employees by department
 Map<Department, List<Employee>> byDept = employees.stream()
   .collect(Collectors.groupingBy(Employee::getDepartment));

 // Compute sum of salaries by department
 Map<Department, Integer> totalByDept = employees.stream()
   .collect(Collectors.groupingBy(Employee::getDepartment,
                                  Collectors.summingInt(Employee::getSalary)));

 // Partition students into passing and failing
 Map<Boolean, List<Student>> passingFailing = students.stream()
   .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

package modern.java;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * StreamAPIとラムダ式を理解する
 * ラムダとは概念的に関数をJavaが表現できるようにしてくれたもの
 * （関数＝object）
 * Stream操作
 * 1. Stream生成
 * 2. 中間操作 Streamを返す。
 * 3. 終端操作 コレクションや値を返す。
 * ラムダ式はすべて終端操作が実行される時点で実行される（遅延評価）
 * 終端操作メソッドを行うとStreamオブジェクトはクローズされる（使えなくなる）
 */
public class StreamAPI {
    public static void main(String[] args) {
        System.out.println("*無名クラスDEMO*********");
        anonymousClassDEMO();
        System.out.println("*ラムダDEMO*************");
        lambdaDEMO();
        System.out.println("*ConsumerDEMO***********");
        consumerDEMO();
        System.out.println("*SupplierDEMO***********");
        supplierDEMO();
        System.out.println("*PredicateDEMO**********");
        predicateDEMO();
        System.out.println("*FunctionDEMO***********");
        functionDEMO();
        System.out.println("*終端処理DEMO***********");
        streamTerminal();
        System.out.println("*中間処理DEMO***********");
        streamIntermediate();

    }

    /**
     * Funcインターフェースを実装した無名クラスをローカルクラスとして宣言
     */
    static void anonymousClassDEMO() {
        Func f = new Func() {
            public int calc(int x, int y) {
                return x + y;
            }
        };
        System.out.println(f.calc(1, 2));
    }

    /**
     * 無名クラスをラムダ式で書く
     * 左辺から型推論で型を判定、関数型インターフェースなので式まで決定。
     */
    static void lambdaDEMO() {
        Func f = (x, y) -> x + y;
        System.out.println(f.calc(1, 2));
    }

    /**
     * Streamオブジェクトの生成
     * データの集合をラムダ式で処理するためのオブジェクト
     */
    static Stream<String> streamCreate1() {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        Stream<String> stream = list.stream();
        //Filesクラスから行を持つStreamもツクレル
        //直接作るには Stream<String> stream = Stream.of("A", "B");
        return stream;
    }

    static IntStream streamCreate2() {
        int[] arr1 = { 1, 2, 3, 4, 5, 1 };
        IntStream stream = Arrays.stream(arr1);
        //LongStream DoubleStreamもある
        return stream;
    }

    /**
     * 終端操作
     */
    static void streamTerminal() {
        List<String> list = Arrays.asList("A","BC","DEF","GH","I", "A");
        // countはlongで個数を返す
        System.out.println(list.stream().count());
        // min, maxはComparatorを受け取り、次要素を比較し、与えられた式でmax, minを返す
        // 文字数の小さいものは小さいという式
        String max1 = list.stream().max(
                (o1,o2) -> o1.length() - o2.length()
                ).orElse("最大値なし");
        String min1 = list.stream().min(
                (o1,o2) -> o1.length() - o2.length()
                ).orElse("最小値なし");
        System.out.println(max1);
        System.out.println(min1);

        // 戻り型のOptionalはほしい戻り値をラップした型
        // orElseメソッドで中身をとりだせ、nullである場合の戻り値を書ける。(orElseは空のOptionalかを判定している)
        List<String> list2 = Arrays.asList();
        String max2 = list2.stream().max(
                (o1,o2) -> o1.length() - o2.length()
                ).orElse("最大値なし");
        System.out.println(max2);

        int[] arr = {1,2,3,4,5};
        // sumは合計
        System.out.println(Arrays.stream(arr).sum());
        // averageは平均（戻り値OptionalDouble）
        System.out.println(Arrays.stream(arr).average().orElse(0.0));

        // reduceは全てに処理を行う
        //引数１つで戻り値Optional
        Optional<String> optional = list.stream().reduce((x, y) -> x + y);
        System.out.println(optional.orElse("null"));
        //引数２つで戻り値<T> 第一引数は初期値
        String str = list.stream().reduce("Z", (x, y) -> x + y);
        System.out.println(str);

        //<R> r collect(Supplier<R> s, BiConsumer<R,? super T>, a, BiCumsumer<R,R> c)
        // 可変オブジェクトにStream内の要素を集める
        ArrayList<String> list3 =
                list.stream()
                .collect(
                        // Supplierを生成
                        () -> new ArrayList<String>(),
                        // 個々のデータをどう集めるか
                        (l, s) -> l.add(s),
                        // 複数の可変コンテナをどう結合するか(並列処理のため)
                        (l1, l2) -> l1.addAll(l2)
                        );
        list3.forEach(System.out::println);

        // <R,A> R collect(Collector<<? super T, A, R> c) Collectorクラスで簡潔に書ける
        Set<String> set = list.stream().collect(Collectors.toSet());
        set.stream().forEach(System.out::println);
    }

    /**
     * 中間操作
     */
    static void streamIntermediate() {
        List<String> list = Arrays.asList("KLMN", "ABc", "dE", "FGH", "iJ");
        //filterはPredicateを引数にとり、式がTrueのものを集めたStreamを返す。
        list.stream()
            .filter(s -> s.length() >= 3)
            .forEach(System.out::println);

        //mapはFunctionを引数にとり、データを加工してStreamを返す。
        list.stream()
            .map(s -> s.toUpperCase())
            .forEach(System.out::println);
        //mapで型変換
        IntStream iStream =
            list.stream()
                .mapToInt(s -> s.length());
        iStream.forEach(System.out::println);

        //sortedは<T>がComparableなら自然順序でソートしたStreamを返す。
        list.stream()
            .sorted()
            .forEach(System.out::println);
        //Conparatorを引数に入れて、次の要素と比較するソート順もかける
        list.stream()
            .sorted((s1,s2) -> s1.length() - s2.length())
            .forEach(System.out::println);

        Stream<Person> stream = Stream.of(
                new Person("1", "taro"),
                new Person("2", "jiro"),
                new Person("3", "saburo")
                );
        //Comparatorを引数に入れることで<T>のなにを基準にするかを書ける
        stream.sorted(
                    Comparator.comparing(Person::getName) //.reversed() で逆順
             ).forEach(System.out::println);
    }

    /**
     * メソッド参照 class::method
     * 引数なしで書ける
     */
    static void methodRef() {
        List<Integer> l = Arrays.asList(1, 2, 3);
        //l.forEach(i -> System.out.print(i));
        l.forEach(System.out::print);
    }

    /**
     * コンストラクタ参照 class::new
     * オブジェクトを関数型インターフェースに渡せる
     */
    static void constructorRef() {
        Supplier<ArrayList<Integer>> s = ArrayList::new;
        List<Integer> l = s.get();
    }

    /*********************************************
     * java.util.functionパッケージ
     ********************************************/

    /**
     * Consumer<T>.accept(T t)
     * T型を受け取り何かを行う(戻り値なし)
     */
    static void consumerDEMO() {
        List<String> list = Arrays.asList("A", "B", "C");
        //forEachはストリームオブジェクトが持つ要素すべてになんらかの処理を行う
        list.stream().forEach(System.out::println);
        //Tが決まっている IntConsumer, LongConsumer, DoubleConsumerもある
        //2つ引数を受け取れるBiConsumerもある
        //参照型をプリミティブ型を受け取る ObjIntConsumer, ObjLongConsumer, ObjDoubleConsumerもある
    }

    /**
     * Supplier<T>.get()
     * 引数なしでT型の値を返す。
     */
    static void supplierDEMO() {
        Stream
                // generate()がSupplierを求めているので、ラムダ式にできる
                .generate(() -> Math.round(Math.random()))
                //generateは無限にT型（ここではroundの戻り値）の値を生成して保持するので、limitで終わらせる
                .limit(10)
                .forEach(System.out::print);
        System.out.print("\n");
        //Tが決まっている BooleanSupplier, IntSupplier, LongSupplier, DoubleSupplierもある
    }

    /**
     * Predicate<T>.test(T t)
     * T型を受け取りbooleanで返す
     */
    static void predicateDEMO() {
        List<String> list = Arrays.asList("ABC", "DE", "EGHI");
        // TはString 文字が3文字かを判定する
        Predicate<String> p = s -> s.length() >= 3;
        // Streamすべての要素でtest
        boolean all = list.stream().allMatch(p);
        boolean any = list.stream().anyMatch(p);
        boolean none = list.stream().noneMatch(p);
        System.out.println(all);
        System.out.println(any);
        System.out.println(none);
        // Tが決まっている IntPredicate, LongPredicate, DoublePredicateもある
        // 2つの引数を受け取る BiPredicateもある
    }

    /**
     * Function<T,R>.apply(T t)
     * T型で受け取った引数を処理し、R型の値を返す
     */
    static void functionDEMO() {
        /**
         * 〇T型のみ決まっている
         *      IntFunction<R>, LongFunction<R>, DoubleFunction<R>
         * 〇R型のみ決まっている
         *      ToIntFunction<T>, ToLongFunction<T>, ToDoubleFunction<T>
         * 〇T・R型が決まっている
         *      IntToLongFucntion, IntToDoubleFunction, LongToIntFunction, DoubleToIntFunction, DoubleToLongFunction
         * 〇二つの引数を受け取る Rは戻り型
         *      BiFunction<T,U,R>, ToIntBiFunction<T,U>, ToLongBiFunction<T,U>, ToDoubleBiFunction<T,U>
         * 〇受け取りと戻り値の型が同じとき
         *      UnaryOperator<T>
         * 〇二つの引数を受け取り同じ型を返す <T,T,T>
         *      BinaryOperator<T>, IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator
         */

        // iterateはUnaryOperatorを第二引数にとり,第一引数を初期値として繰り返したStreamを返す
        Stream.iterate(1, x -> x * 10)
            .limit(5)
            .forEach(System.out::println);
    }
}

/**
 * Functionパッケージはこうなっている
 * FunctionalInterfaceは1メソッドのインターフェースを厳密に判定
 */
@FunctionalInterface
interface Func {
    int calc(int x, int y);
}

//基本形
Predicate javaChecker = (String s) -> { return s.equals("Java"); };
//引数一つのとき、型省略
Predicate javaChecker = (       s) -> { return s.equals("Java"); };
//型省略したとき、()も省略
Predicate javaChecker =         s  -> { return s.equals("Java"); };
//一行かつreturnがないとき、{}省略
Consumer buyer =         goods     ->   System.out.println(goods + "を購入しました");
//returnも{}と同時省略
Predicate javaChecker =         s  ->          s.equals("Java");

public class SampleThread extends Thread {
    @Override
    public void run() {
        System.out.println("sub");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t = new SampleThread();
        t.start(); // 新スレッドを作成

        System.out.println("main");

    }
}

public class Main {
    public static void main(String[] args) {
        /*
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("sub");
            }
        });
        以上の実装をRunnableが関数型インタフェースなのを利用して↓で書ける
        */
        Thread t = new Thread(() -> {
          System.out.println("sub");
        });
        t.start();
        System.out.println("main");
    }
}

public class Main {
    public static void main(String[] args) {
        // シングルスレッドを生成
        // 固定数の場合,Executors.newFixedThreadPool(3)など
        ExecutorService exec = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            exec.submit(() -> {
                System.out.println(Thread.currentThread().getId());
            });
        }
        
        System.out.println(Thread.currentThread().getId());
    }
}
// 1
// 13
// 13
// 13
// 13
// 13

// ↑execのスレッドプールには1つしかスレッドがないからIDは統一

public class Main {
    public static void main(String[] args) {
      　// 必要に応じてスレッドを増減
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            exec.submit(() -> {
                System.out.println(Thread.currentThread().getId());
            });
        }
        exec.shutdown();
        System.out.println(Thread.currentThread().getId());
    }
}
// 13
// 15
// 14
// 16
// 17
// 1
// 必要に応じてスレッドを増減させている
// 60秒未満であればスレッドは再利用され、それ以上は破棄される新しくスレッドが作成される。

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
        System.out.println(Thread.currentThread().getId());
        // 3秒後に別スレッドで発火
        // 繰り返し実行させる場合はscheduledAtFixedRate
        // ↑起動時間タイミング毎のインターバルを指定できるが、前の処理が長引くとその分遅延する
        // 処理時間に関係なくインターバルを一定にしたい場合はscheduleWithFixedDelay
        exec.schedule(
                () -> {
                    System.out.println(Thread.currentThread().getId());
                    System.out.println("finish");
                    exec.shutdown();
                }, // 実行処理
          3L, // 遅延させる時間
                TimeUnit.SECONDS); // TimeUnit単位
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService exec = Executors.newSingleThreadExecutor();
        // Future<戻り値の型>で結果を受け取る
        Future<String> future = exec.submit(() -> {
            try {
                System.out.println("start");
                Thread.sleep(5000);
                System.out.println("end");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "finish"); // 第二引数で固定の戻り値を設定できる
        exec.shutdown();

        Thread.sleep(5000);
        System.out.println("main start");
        // .get()で結果を受け取る
        // 実行自体はsubmitの段階で別スレッドで開始しているが、結果が受け取れるまでmainスレッドで待つ
        String result = future.get();
        System.out.println("main finish");
        System.out.println(result);
        // start
        // main start
        // end
        // main finish
        // finish
    }
}

    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(2);

        List<Future<Boolean>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            // Callableをsubmitに渡す
            futures.add(exec.submit(() -> Thread.currentThread().getId() % 2 == 0));
        }

        exec.shutdown();
        System.out.println("start");
        futures.forEach(future -> {
            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });
    }

public class Main {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(2);

        List<Future<Boolean>> futures = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            // Callableをsubmitに渡す
            futures.add(exec.submit(() -> {
                if (Thread.currentThread().getId() % 2 == 0) {
                    throw new Exception("My Exception");
                }
                return true;
            }));
        }

        exec.shutdown();
        System.out.println("start");
        futures.forEach(future -> {
            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            // 別スレッドのExceptionはExecutionExceptionとして投げられる
            } catch (ExecutionException e) {
                var e2 = e.getCause();
                System.out.println(e2.getClass().toString()); // class java.lang.Exception
                System.out.println(e.getMessage()); // java.lang.Exception: My Exception
            }
        });
    }
}

/**
 * CyclicBarrierを受け取れるRunnable実装
 */
public class Task implements Runnable {
    private CyclicBarrier barrier;

    public Task(CyclicBarrier barrier) {
        super();
        this.barrier = barrier;
    }

    @Override
    public void run() {
        long id = Thread.currentThread().getId();
        System.out.println("START:" + id);

        int r = new Random().nextInt(10);

        try {
            Thread.sleep(r * 100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("END:" + id);
        try {
            this.barrier.await();  // barrierによって他の処理を待つ。
        } catch (BrokenBarrierException | InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(5);

        CyclicBarrier barrier = new CyclicBarrier(
                5, // awaitが5つ揃うまで待つ
                () -> {
                    System.out.println("all done"); // Runnableの最終処理
                });
        for (int i = 0; i < 5; i++) {
            exec.submit(new Task(barrier));
        }
        exec.shutdown();
        //START:16
        //START:14
        //START:15
        //START:17
        //START:13
        //END:16
        //END:17
        //END:13
        //END:14
        //END:15
        //all done
    }
}

public class ExclusionControl implements Runnable {
    private int num = 100;

    public int getNum() {
        return num;
    }

    /**
     * synchronizedメソッド
     * このクラスのインスタンスについて、同時にこの関数が実行されずに、処理を待たせることができる
     */
    public synchronized void add(int amount) {
        this.num = this.num + amount;
    }

    @Override
    public void run() {
        /*
        synchronizedブロック
        引数で指定したインスタンスについて、synchronizedブロックの処理を同時に進めることはできない。
        メソッド、ブロック両方同じインスタンスについて同期される。
        */
        synchronized (this) {
            add(100);
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ExclusionControl ex = new ExclusionControl();
        ExecutorService exec = Executors.newFixedThreadPool(2);

        for (int i = 0; i < 10; i++) {
            exec.submit(ex);
        }

        Thread.sleep(200);
        System.out.println(ex.getNum());
        exec.shutdown();
    }
}

public class AtomicValue {
  private AtomicInteger num = new AtomicInteger(0);

  public void add(int num) {
    this.num.addAndGet(num);
  }
}

public class ExclusionControl implements Runnable {

    private static final ReentrantLock lock = new ReentrantLock();

    private String s;

    public ExclusionControl(String s) {
        super();
        this.s = s;
    }

    @Override
    public void run() {
        // lockとunlock 必ずfinallyでunlockをすること。
        try {
            lock.lock();
            System.out.println("START:" + s);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("END:" + s);
        } finally {
            lock.unlock();
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(2);

        exec.submit(new ExclusionControl("1"));
        exec.submit(new ExclusionControl("2"));
        exec.submit(new ExclusionControl("3"));

        exec.shutdown();
    }
}
// START:2
// END:2
// START:1
// END:1
// START:3
// END:3

public class Main {
    public static void main(String[] args) {
        try (FileWriter out = new FileWriter("output.txt", true);// trueで追記モード
             BufferedWriter writer = new BufferedWriter(out);) {
            writer.newLine(); // システム定義の改行文字を入れる
            writer.write("buffering write");
            writer.flush(); // バッファに残っている（かも）しれない書き込みをディスクにうつす。

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    // コピーでinputoutput両方使う
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("sample.jpg");
             BufferedInputStream bis = new BufferedInputStream(fis);
             FileOutputStream fos = new FileOutputStream("sample_bk.jpg", false); // falseなら指定する必要もないが、上書きモード
             BufferedOutputStream bos = new BufferedOutputStream(fos);
        ) {
            byte[] data = null;
            while ((data = bis.readNBytes(1024)).length != 0) { // 1024Byteごと書き込み
                bos.write(data);
            }
            // bos.write(bis.readAllBytes()); これでもいい
            bos.flush(); // バッファを使用した書き込みは最後にflush

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
 * Serializableクラス
 */
public class Item implements Serializable {

    private String name;
    private int price;

    public Item(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return name + " $" + price;
    }
}

/**
 * シリアライズサンプル
 */ 
public class Main {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("sample.ser", false);
             ObjectOutputStream oos = new ObjectOutputStream(fos);
        ) {
            Item item = new Item("banana", 10000);
            oos.writeObject(item); // シリアライズ
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
 * デシリアライズサンプル
 */
public class Main {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("sample.ser");
             ObjectInputStream ois = new ObjectInputStream(fis);
        ) {
            Item item = (Item) ois.readObject(); // デシリアライズ
            System.out.println(item); // banana $10000
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}