【Oracle試験対策】Java Gold見直しポイント

// 定義
class Outer {
  static class Inner {}
}

// 呼び出し
Outer.Inner inner = new Outer().Inner();
// staticなのでOuterは省略可能
Inner inner = new Inner();

// 定義
class Outer {
  void method() {
    class Inner {}
  }
}

// 呼び出し
Outer.Inner inner = new Outer().new Inner();
// 型宣言のOuterは省略可能
Inner inner = new Outer().new Inner();

// 定義
class Outer {
  void method() {
    new Inner() {}
  }
}

// 呼び出し
Outer.Inner inner = new Outer().new Inner();
// 型宣言のOuterは省略可能
Inner inner = new Outer().new Inner();

public class ObjectSample {
  public static void main(String[] args) {
    // Object型にはtestメソッドは存在しないため型推論に失敗
    Object obj = new Object() {
      public void test() {}
    }
    // 代わりにvarを使って型推論する
    var obj = new Object() {
      public void test() {}
    }
  }
}

public class ListSample {
  public static void main(String[] args) {
    List<String> = new ArrayList<String>() {
      {
        super.add("initial")
      }
    };
  }
}

public abstract class Sample {
  static int x = 0;
  static void test() {
    System.out.println("A");
  }
}

public class Main {
  public class SampleImpl extends Sample {
    // SampleImplに紐づくstaticなフィールド
    static int x = 10;
    // SampleImplに紐づくstaticなメソッド
    static void test() {
      System.out.println("B");
    }
    // staticなメソッドはオーバーライドできないためコンパイルエラー
    @Override
    static void test() {
      System.out.println("C");
    }
  }

  public static void main(String[] args){
    System.out.println(Sample.x);     // 0
    System.out.println(SampleImpl.x); // 10
    Sample.test();                    // A
    SampleImpl.test();                // B
  }
}

interface A {
  default void test() {
    System.out.println("A")
  }
}

interface B {
  default void test() {
    System.out.println("B")
  }
}

public class Impl implements A, B {
  @Override
  public void test() {
    A.super.test(); // A
    B.super.test(); // B
  }
}

public enum Colors {
  RED, BLUE, GREEN;
}

public class Sample {
  public static void main(String[] args) {
    Colors color = Colors.GREEN;
    switch(color) {
      case RED:
        System.out.println("RED");
        break;
      case BLUE:
        System.out.println("BLUE");
        break;
      case GREEN:
        System.out.println("GREEN");
        break;
    }
  }
}

public enum Colors {
  RED("red"), BLUE("blue"), GREEN("green");
  private Colors(String lower) {
    System.out.print(lower + " ");
  }
}

public class Sample {
  public static void main(String[] args) {
    System.out.print(Colors.GREEN); // red blue green GREEN
  }
}

public class Outer {
  public static void main(String[] args) {
    Inner inner = new Inner();
    inner.data = 100; // OuterからInnerのprivateにアクセス可能
  }
  private static class Inner {
    private int data;
  }
}

public class Sample {
  private Test test(String value) {
    class A implements Test {
      // 外側のvalueを参照するためvalueは実質的にfinalでなければならない
      System.out.println(value);
    }
    // valueは実質的にfinalでなければならないためコンパイルエラー
    value = "sample";
  }
}

public interface A {
  static void test() {}
}

public interface B extends A {}

public interface C implements A {}

public class D implements A {
  public static void main(String[] args) {
    // OK
    A.test();
    // NG
    B.test();
    C.test();
    test();
  }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public class Main {
  public static void main(String[] args) {
    // ラムダ式
    Supplier<List<String>> supplier1 = () -> new ArrayList();
    List<String> list1 = supplier1.get();

    // コンストラクタ参照
    Supplier<List<String>> supplier2 = ArrayList::new;
    List<String> list2 = supplier2.get();
  }
}

import java.util.function.Consumer;

public class Main {
  public static void main(String[] args) {
    // ラムダ式
    Consumer<String> consumer1 = (str) -> System.out.println(str);
    consumer1.accept("Hello, consumer.");

    // メソッド参照
    Consumer<String> consumer2 = System.out::println;
    consumer2.accept("Hello, consumer.");
  }
}

import java.util.function.BiConsumer;

public class Main {
  public static void main(String[] args) {
    var map = new HashMap<String Integer>();

    // ラムダ式
    BiConsumer<String, Integer> biConsumer1 = (k, v) -> map.put(k, v);
    biConsumer1.accept("apple", 2);
    biConsumer1.accept("banana", 3);

    // メソッド参照
    BiConsumer<String, Integer> biConsumer2 = map::put;
    biConsumer2.accept("apple", 2);
    biConsumer2.accept("banana", 3);
  }
}

import java.util.function.Predicate;

public class Main {
  public static void main(String[] args) {
    Predicate<String> predicatePrefix = (str) -> str.startsWith("a");
    Predicate<String> predicateSuffix = (str) -> str.endsWith("e");
    Predicate<String> predicateAnd = predicatePrefix.and(predicateSuffix);
    Predicate<String> predicateOr = predicatePrefix.or(predicateSuffix);

    System.out.println(predicateAnd.test("apple"));  // true
    System.out.println(predicateAnd.test("orange")); // false

    System.out.println(predicateOr.test("apple"));  // true
    System.out.println(predicateOr.test("orange")); // true
  }
}

import java.util.function.BiPredicate;

public class Main {
  public static void main(String[] args) {
    BiPredicate<String, String> biPredicate = (str, suffix) -> str.endsWith(suffix);
    System.out.println(biPredicate.test("apple", "a"));  // false
    System.out.println(biPredicate.test("apple", "e"));  // true
  }
}

import java.util.function.Function;

public class Main {
  public static void main(String[] args) {
    Function<Integer, Integer> plus = (x) -> x + 2;
    Function<Integer, Integer> times = (x) -> x * 2;
    System.out.println(plus.andThen(times).apply(5)); // (5 + 2) * 2 = 14
    System.out.println(plus.compose(times).apply(5)); // (5 * 2) + 2 = 12
  }
}

import java.util.function.BiFunction;

public class Main {
  public static void main(String[] args) {
    BiFunction<Integer, Integer, Integer> plus = (x, y) -> x + y;
    System.out.println(plus.apply(5, 2)); // 5 + 2 = 7
  }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.UnaryOperator;

public class Main {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>(List.of("a", "b", "c"));
    list.replaceAll(x -> x.toUpperCase());
    for (String str : list) {
      System.out.println(str); // A, B, C
    }
  }
}

import java.util.function.BinaryOperator;

public class Main {
  public static void main(String[] args) {
    BinaryOperator<String> binaryOperator = (str, suffix) -> str.concat(suffix);
    System.out.println(binaryOperator.apply("test", ".txt")); // test.txt
  }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class Main {
  public static void main(String[] args) {
    Predicate<String> predicate = (str) -> str.startsWith("a");
    // 唯一の抽象メソッドを使っていないためコンパイルエラー
    // predicate.test("apple")とするべき
    System.out.println(predicate("apple"));
  }
}

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

public class Main {
  public static void main(String[] args) {
    // 方法1
    Thread t1 = new SubThread();
    t1.start();

    // 方法2 (匿名クラス)
    Thread t2 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("subThread");
      }
    });
    t2.start();

    // 方法2 (ラムダ式)
    Thread t3 = new Thread(() -> System.out.println("subThread"));
    t3.start();
  }
}

public class Main {
  public static void main(String[] args) {
    Thread t = new Thread(() -> System.out.println("sub"));
    t.start();
    // main -> subの順番
    System.out.println("main");
  }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
  public static void main(String[] args) {
    ExecutorService exec = Executors.newFixedThreadPool(3);
    // 12, 13, 14
    for (int i = 0; i < 3; i++) {
      exec.submit(() -> System.out.println(Thread.concurrentThread().getId()));
    }
  }
}

ExecutorService exec = Executors.newSingleThreadExecutor();
Future future = exec.submit(...);

String result = future.get()

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
  public static void main(String[] args) throws Exception {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    
    Callable<Boolean> task = new Callable<Boolean>() {
      @Override
      public Boolean call() throws Exception {
        return new Random().nextInt() % 2 == 0;
      }
    };

    List<Future<Boolean>> futures1 = new ArrayList<>();
    List<Future<Boolean>> futures2 = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
      // 方法1: submitの第二引数を指定
      futures1.add(exec.submit(() -> {}, true));
      // 方法2: callableインタフェースを実装したtaskを渡す
      futures2.add(exec.submit(task));
    }

    // 全てtrue
    for (Future<Boolean> future : futures1) {
      System.out.println(future.get());
    }
    System.out.println("-----");
    // ランダム出力
    for (Future<Boolean> future : futures2) {
      System.out.println(future.get());
    }
  }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
  public static void main(String[] args) throws Exception {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    List<Future<Boolean>> futures1 = new ArrayList<>();
    List<Future<Boolean>> futures2 = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
      // 方法1: 戻り値がないためRunnable。第二引数で戻り値を指定するしかない。
      futures1.add(exec.submit(() -> {}, false));
      // 方法2: 戻り値があるためCallable。
      futures2.add(exec.submit(() -> true));
    }

    // 全てfalse
    for (Future<Boolean> future : futures1) {
      System.out.println(future.get());
    }
    System.out.println("-----");
    // 全てtrue
    for (Future<Boolean> future : futures2) {
      System.out.println(future.get());
    }
  }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
  public static void main(String[] args) throws Exception {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    List<Future<Boolean>> futures = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
      futures.add(exec.submit(() -> {
        if (new Random().nextInt() % 2 != 0) throw new Exception("odd number");
        return true;
      }));
    }

    for (Future<Boolean> future : futures) {
      try {
        System.out.println(future.get());
      } catch (ExecutionException e) {
        System.out.println(e.getMessage());        
      }
    }
  }
}

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Task implements Runnable {
  private CyclicBarrier barrier;
  public Task(CyclicBarrier barrier) {
    super();
    this.barrier = barrier;
  }

  @Override
  public void run() {
    // CyclicBarrierの仕様からInterruptedExceptionとBrokenBarrierExceptionを処理する必要がある
    try {
      this.barrier.await();
    } catch (InterruptedException e) {
      // スレッドが割り込まれた場合の処理
      Thread.currentThread().interrupt(); // 割り込みステータスを再設定
      System.out.println("Thread was interrupted");
    } catch (BrokenBarrierException e) {
      // バリアが壊れた場合の処理
      System.out.println("Barrier was broken");
    }
  }
}

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
  public static void main(String[] args) {
    // 3つのCyclicBarrierを作るため最低限3つのスレッドを含むpoolを作成
    ExecutorService exec = Executors.newFixedThreadPool(3);
    CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("sync done"));
    for (int i = 0; i < 3; i++) {
      exec.submit(new Task(barrier));
    }
  }
}

private static volatile int count = 0;

private AtomicInteger num = new AtomicInteger(0);

import java.util.concurrent.locks.ReentrantLock;

public class LockSample {
  private final ReentrantLock lock = new ReentrantLock();

  public void lock() {
    this.lock.lock();
  }

  public void unlock() {
    this.lock.unlock();
  }

  public void first() {
    System.out.println(Thread.currentThread().getId() + ": 1");
  }
  public void second() {
    System.out.println(Thread.currentThread().getId() + ": 2");
  }
  public void third() {
    System.out.println(Thread.currentThread().getId() + ": 3");
  }
}

public class Task implements Runnable {
  private LockSample lock;
  public Task(LockSample lock) {
    super();
    this.lock = lock;
  }
  @Override
  public void run() {
    // try-finallyでlock-unlockを実現する
    try {
      lock.lock();
      lock.first();
      lock.second();
      lock.third();
    } finally {
      lock.unlock();
    }
  }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
  public static void main(String[] args) {
    LockSample lock = new LockSample();
    ExecutorService exec = Executors.newFixedThreadPool(3);
    exec.submit(new Task(lock));
    exec.submit(new Task(lock));
    exec.submit(new Task(lock));
  }
}

12: 1
12: 2
12: 3
13: 1
13: 2
13: 3
14: 1
14: 2
14: 3

// 空のOptionalを生成
Optional<String> sample = Optional.empty();
// 引数に空を許容せずにOptionalを生成
Optional<String> sample = Optional.of("sample");
// 引数に空を許容してOptionalを生成
Optional<String> sample = Optional.ofNullable(null);

Optional<String> sample = Optional.empty();
System.out.println(sample.orElse("empty"));          // empty
System.out.println(sample.orElseGet(() -> "empty")); // empty

Optional<String> sample = Optional.empty();
// Exception in thread "main" java.lang.Exception
System.out.println(sample.orElseThrow(() -> new Exception()));

Optional<String> sample1 = Optional.of("present");
Optional<String> sample2 = Optional.empty();
// present
sample1.ifPresent((str) -> System.out.println(str));
// (何もしない)
sample2.ifPresent((str) -> System.out.println(str));

// 値が存在する場合は引数を受け取るConsumer，存在しない場合は引数を受け取らないRunnableを実行する
ifPresentOrElse​(Consumer action, Runnable emptyAction)

Optional<String> before = Optional.of("present");
Optional<String> after = before.map(str -> str.toUpperCase());

// mapは値が空でも新しい空のOptionalを生成して参照を返す
Optional<String> beforeNull = Optional.ofNullable(null);
Optional<String> afterNull = before.map(str -> str.toUpperCase());

import java.util.stream.Stream;

List<Integer> list1 = List.of(1, 2, 3, 4, 5);
Integer[] list2 = {1, 2, 3, 4, 5};
int[] list3 = {1, 2, 3, 4, 5};

// Collectionインタフェースにはデフォルトメソッドとしてstream()が定義されている
Stream<Integer> stream1 = list1.stream();
// 配列からストリームを作成するにはArraysクラスのstreamメソッドを利用する
Stream<Integer> stream2 = Arrays.stream(list2);

// プリミティブ型のStreamは通常のStreamとは別のインタフェースで定義されている
IntStream stream3 = Arrays.stream(list3);
// Stream型の変数にArrays.stream(int[])の戻り値を格納するとコンパイルエラーとなる
Stream<Integer> stream3 = Arrays.stream(list3);

import java.util.stream.Stream;

List<Integer> list1 = List.of(1, 2, 3, 4, 5);
Integer[] list2 = {1, 2, 3, 4, 5};

Stream<Integer> stream1 = list1.parallelStream();
Stream<Integer> stream2 = Arrays.stream(list2).parallel();

List<Integer> list = Arrays.asList(1,2,3,4,5);

Optional<Integer> result1 = list.stream().reduce((a, b) -> a + b);
int result2 = list.stream().reduce(100, (a, b) -> a + b);

System.out.println(result1); // 15
System.out.println(result2); // 115

List<Integer> list = Arrays.asList(1,2,3,4,5);

Optional<Integer> result1 = list.stream().reduce((a, b) -> a + b);
int result2 = list.stream().reduce(100, (a, b) -> a + b);

System.out.println(result1); // Optional<Integer>
System.out.println(result2); // int

List<Integer> numbers = List.of(1, -1, -3, 4, -4, 10, 2, -6, 2, 1, 6);
List<Integer> result = numbers.stream()
                         .filter(x -> x > 0)
                         .collect(Collectors.toList());
System.out.println(result); // [1, 4, 10, 2, 2, 1, 6]

List<Integer> numbers = List.of(1, -1, -3, 4, -4, 10, 2, -6, 2, 1, 6);
Map<Integer, Integer> resultMap = numbers.stream()
                                    .filter(x -> x > 0)
                                    .distinct()
                                    .collect(Collectors.toMap(
                                      number -> number,
                                      number -> Math.abs(number)));
resultMap.keySet().stream().forEach(System.out::println); // [1, 2, 4, 6, 10]

@Override
public Set<Characteristics> characteristics() {
  // return Collector.Characteristics.CONCURRENT; とか
  return EnumSet.noneOf(Characteristics.class);
}

List<String> list = Arrays.asList({"A", "B", "C", "D", "E"});
// 抽象メソッドを独自でカスタマイズしたい場合はcollectの引数にCollectorインタフェースの実装を渡す
String result = list.stream().collect(new SampleCollector());
System.out.println(result);

List<String> list = Arrays.asList("a", "b", "c");
// A a aB b bC c c
list.stream()
  .map(str -> str.toUpperCase())
  .peek(str -> SYstem.out.println(str + " "))
  .map(str -> str.toLowerCase())
  .peek(str -> SYstem.out.println(str + " "))
  .forEach(System.out::println);

.stream()
.collect(Collectors.toList());

.stream()
.collect(
  Collectors.groupingBy(
    Item::getTitle,
    Collectors.summingInt(Item::getPrice)
  )
);

FileReader fr = new FileReader("sample.txt");
BufferedReader reader = new BufferedReader(fr);
try (reader){
  reader.lines().forEach(System.out::println);
}

// 上書きモード
FileWriter fw = new FileWriter("output.txt");
FileWriter fw = new FileWriter("output.txt", false);

// 追記モード
FileWriter fw = new FileWriter("output.txt", true);

Console console = System.console();
char[] password = console.readPassword();

FileInputStream fis = new FileInputStream(file);
Scanner scanner = new Scanner(fis);
// |で複数の区切り文字を指定可能
scanner.useDelimiter(",|\n")

// try-with-resourceでcloseを担保
try (scanner) {
  while (scanner.hasNext()) {
    ...
  }
}

FileOutputStream fos = new FileOutputStream("sample.ser");
ObjectOutputStream out = new ObjectOutputStream(fos);
try (out) {
  Item item = new Item("banana", 100);
  out.writerObject(item);
}

FileInputStream fis = new FileInputStream("sample.ser");
ObjectInputStream in = new ObjectInputStream(fis);
try (in) {
  Object obj = in.readObject();
  Item item = (Item) obj;
}

import java.io.File
import java.nio.file.Path;
import java.nio.file.Files;

Path path = Paths.get("dir/sample.txt");     // PathsからPathを抽出。OK。
Path path = Paths.get("dir", "sample.txt");  // PathsからPathを抽出。OK。
Path path = new File("sample.txt").toPath(); // 従来のFileからPathを抽出。OK。
Path path = Files.get("sample.txt");         // nioのFilesからPathを抽出。NG。

Path p1 = Paths.get("dir1/dir2");
Path p2 = Paths.get("dir3/sample.txt");
Path p3 = p1.resolve(p2); // dir1/dir2/dir3/sample.txt

Path base = Paths.get(".");

// baseディレクトリ直下のファイル一覧
Files.list(base).forEach(System.out::println);
// srcディレクトリの下にあるファイルを再帰的に一覧化
Files.walk(base.resolve("src")).forEach(System.out::println);

import java.nio.file.attribute.BasicFileAttributes
import java.util.function.BiPredicate;

BiPredicate<Path, BasicFileAttributes> bp = (p, attr) -> {
  p.toFile().getName().endsWith(".jpg");
}
// baseディレクトリから3階層下までbpでtrueを返すものを一覧化
Files.find(base, 3, bp).forEach(System.out::println);

// jdbc:{DBエンジンの種類}://{サーバのIPアドレス}:{ポート番号}/{データベースの場所}
jdbc:mysql://localhost/test

import java.sql.Connection
import java.sql.DriverManager

Connection con = DriverManager.getConnection("jdbc:mysql://localhost/test");

import java.sql.PreparedStatement

PreparedStatement ps = con.prepareStatement("select * from items");

// 実行時にSQLException
ps.setInt(0, 1);
// 1番目の?に1を代入
ps.setInt(1, 1);

// rsを受け取るが、next()でカーソルを進めずにrs.getXXするとSQLExceptionが発生するため注意
ResultSet rs = ps.executeQuery();
while(rs.next()) {
  // カーソルが当たっている行の1番目のカラムに格納された値をintとして抽出
  System.out.print(rs.getInt(1) + ":");
  // カーソルが当たっている行のnameカラムに格納された値をStringとして抽出
  System.out.println(rs.getString("name"));
}

String[] names = {"apple", "banana", "cherry"};
var sql = "insert into item values(?,?)";
try (PreparedStatement ps = con.prepareStatement(sql)) {
  int i = 10;
  for (String name : names) {
    ps.setInt(1, i);
    ps.setString(2, name);
    // batchに登録
    ps.addBatch();
    i++;
  }
  // [1, 1, 1]が返る
  int[] results = ps.executeBatch();
}

// 引数を二つ取るメソッドをUPDARE_ITEMという名前を付けてストアドプロシージャに登録したと仮定
String proc = "CALL UPDARE_ITEM(?, ?)";
try (CallableStatement cs = con.prepareCall(proc)) {
  cs.setInt(1, 1);
  cs.setString(2, "sample");
  cs.execute();
}

public class Value<T> {
  T val;
  public Value(T val) {
    super();
    this.val = val;
  }
  public T getVal() {
    return val;
  }
  public void setVal(T val) {
    this.val = val;
  }
}

public class Main {
  public static void main(String[] args) {
    // ダイアモンド演算子でStringを指定
    Value<String> v1 = new Value("sample");
    String x1 = v1.getVal();

    // ダイアモンド演算子がないためObject型として認識
    // 「"sample"をTとみなしてTが返る」と誤解しないように注意
    Value v2 = new Value("sample");
    Object x2 = v2.getVal();
  }
}

// コンパイルエラー
// list.add(100)のようなObject型のサブクラスの代入を許してしまうと不都合であるため
List<Object> list = new ArrayList<String>();

// OK
List<String> list = new ArrayList<String>();

// AクラスまたはAのサブクラスに制限
public class Sample<T extends A> {
  public void test(T t) {
    // AクラスまたはAのサブクラスが持つメソッドを利用可能
    // extendsで制約しないとそのメソッドを持つか不明であるためコンパイルエラーとなる
  }
}

private void printAll(Collection<?> collection) {
  collection.stream().forEach(System.out::println)
}

public class Value<T> {
  T val;
  public Value(T val) {
    super();
    this.val = val;
  }
  public T getVal() {
    return val;
  }
  public void setVal(T val) {
    this.val = val;
  }
}

public class Main {
  public static void main(String[] args) {
    // ダイアモンド演算子でStringを指定した場合は問題ない
    Value<String> v1 = new Value("sample");
    String x1 = (String) v1.getVal();
    v1.setVal("fixed");

    // ダイアモンド演算子で?を指定した場合は要注意
    Value<?> v2 = new Value("sample");
    // ジェネリクスはObject型になるためStringへのダウンキャストは成功
    String x2 = (String) v2.getVal();
    // メソッドにはnullリテラルしか渡せないためコンパイルエラー
    v2.setVal("fixed");
    // これはOK
    v2.setVal(null);
  }
}

// 拡張for文で使うパターン
Map.Entry<Integer, String> entry : map.entrySet() {...}
// Streamで使うパターン
map.entrySet().stream().forEach(...)

// Comparableを実装して比較可能であることを示す
public class Item implements Comparable<Item> {
  private String name;
  private int price;

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

  // 自身と他のクラスを比較するため引数は1つ
  @Override
  public int compareTo(Item other) {
    if (this.price < other.price) return -1;
    if (this.price > other.price) return 1;
    return 0;
  }

  public String getName() {
    return name;
  }

  public int getPrice() {
    return price;
  }

  @Override
  public String toString() {
    return String.format("Item [name=%s, price=%s]", this.name, this.price);
  }
}

import java.util.Comparator;

public class ItemNameComparator implements Comparator<Item> {
  @Override
  public int compare(Item a, Item b) {
    return a.getName().compareTo(b.getName());
  }
}

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Main {
  public static void main(String[] args) {
    Item a = new Item("apple", 100);
    Item b = new Item("banana", 200);
    Item c = new Item("cherry", 50);
    List<Item> list = Arrays.asList(a, b, c);

    Collections.sort(list);
    list.forEach(System.out::println);

    System.out.println("---");

    list.sort(new ItemNameComparator());      
    list.forEach(System.out::println);
  }
}

Item [name=cherry, price=50]
Item [name=apple, price=100]
Item [name=banana, price=200]
---
Item [name=apple, price=100]
Item [name=banana, price=200]
Item [name=cherry, price=50]

list.sort((x, y) -> x.getPrice() - y.getPrice());
list.forEach(System.out::println);

public @interface NotNull {}

// public @interface NotNull {} をコンパイルすると下記となる
public interface NotNull extends java.lang.annotation.Annotation {}

public @interface NotNull {
  String message();
}

public class Sample {
  // 注釈パラメータが1つの場合は @NotNull("name is not allowed null") のように省略可能
  @NotNull(message = "name is not allowed null")
  private String name;
}

public @interface NotNull {
  String message() default "not allowed null";
}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
  String message();
}

import java.lang.annotation.Target;

// フィールドへの付与を指定
@Retention(ElementType.FIELD)
public @interface NotNull {
  String message();
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// このアノテーションはフィールドにしか付けられない
@Target(ElementType.FIELD)
// 実行時にも有効なアノテーション
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
  // 違反したときのメッセージを格納するフィールド
  String message();
}

public class Sample {
  // TargetにFIELDを指定しているためOK
  @NotNull(message = "name is not allowed null.")
  private String name;
  // コンストラクタ
  public Sample(String name) {
    this.name = name;
  }
  // getter
  public String getName() {
    return this.name;
  }
}

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class NotNullValidator {
  public static List<String> validate(Object target) {
    try {
      // 違反したフィールドが存在した場合のメッセージを格納する配列
      List<String> messages = new ArrayList<String>();
      // リフレクションにより得られたClassクラス
      Class clazz = target.getClass();
      // Classクラスからフィールド一覧を配列として取得
      Field[] fields = clazz.getDeclaredFields();
      // それぞれのフィールドについて走査
      for (Field field : fields) {
        // privateの場合は一時的にアクセス権を変更
        field.setAccessible(true);
        // NotNullアノテーションを取得
        // NotNullは同一パッケージのためimport不要
        NotNull annotation = field.getAnnotation(NotNull.class);
        // NotNullアノテーションが付いていなければスキップ
        if (annotation == null) continue;
        // NotNullアノテーションは付いているがnullでない場合もスキップ
        if (field.get(target) != null) continue;
        // NottNullアノテーションが付いていてnullの場合はmessageを格納
        messages.add(annotation.message());
      }
      return messages;
    } catch (IllegalArgumentException | IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }
}

import java.util.List;

public class Main {
  public static void main(String[] args) {
    // NotNullのフィールドにnullを格納
    Sample sample = new Sample(null);
    List<String> messages = NotNullValidator.validate(sample);
    if (messages.isEmpty()) {
      System.out.println("this is a valid object.");
    } else {
      for (String message : messages) {
        System.out.println(message);
      }
    }
  }
}

this is a valid object

annotation @SuppressWarnings is missing a default value for the element 'value'

catch (IOException|SQLException e) {
  logger.log(e);
  throw e;
}

The exception BException is already caught by the alternative AException

// SampleResourceのclose処理でExceptionをthrowするように定義
try (SampleResource resource = new SampleResource();) {
  throw new Exception();
} catch (Exception e) {
  for(Throwable t : e.getSuppressed()) {
    // close処理で定義されたExceptionが取り出される
    System.out.println(t);
  }
}

public void setName(String name) {
  assert name != null : "name is null";
  this.name = name;
}

public void setPrice(int price) {
  assert price > 0 : "invalid price"
  this.price = price;
}

java -Duser.country=US -Duser.language=en Sample

// ({language}, {country})
Locale locale = new Locale("ja", "JP");

// languageやcountryが自動で設定される
Locale locale = Locale.JAPAN

// ja-JP-u-ca-japanese-x-lvariant-JP
locale.toLanguageTag();

Locale locale = Locale.forLanguageTag("ja-JP-u-ca-japanese-x-lvariant-JP");

import java.util.Properties;

public class PropertiesExample {
  public static void main(String[] args) {
    Properties properties = new Properties();
    properties.setProperty("key1", "value1");
    
    // 戻り値はObject
    Object value1 = properties.get("key1"); // value1
    Object value2 = properties.get("key2"); // null

    // 戻り値はString
    String propValue1 = properties.getProperty("key1"); // value1
    String propValue2 = properties.getProperty("key2"); // null    
    String propValue3 = properties.getProperty("key2", "default_value"); // default_value
  }
}

prop.list(System.out)

Locale locale = new Locale.Builder().setLanguage("ja").setRegion("JP").build();

// 方法1
native2ascii from.txt to.properties

// 方法2
prop.load(new FileReader("sample.properties", Charset.forName("UTF-8")));

// 方法3
prop.load(new InputStreamReader(new FileInputStream("sample.properties"), "utf-8"));

// 方法4
ResourceBundle resource = ResourceBundle.getBundle("sample");
// 方法4でtestというpropertyをgetするには
System.out.println(resource.getString("test"));

// 第二引数にロケール定数を指定
ResourceBundle resource = ResourceBundle.getBundle("sample", Locale.JAPAN);

DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE;
System.out.println(formatter.format(LocalDate.now()));

// ロケール情報に応じて指定した詳細度でformatする
DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);

NumberFormat formatter1 = NumberFormat.getInstance(); // 3桁区切り
NumberFormat formatter2 = NumberFormat.getIntegerInstance(); // 3桁区切り&最も近い整数に丸める
NumberFormat formatter3 = NumberFormat.getCurrencyInstance(); // 3桁区切り&通過フォーマット
NumberFormat formatter4 = NumberFormat.getPercentInstance(); // パーセント表示

System.out.println(formatter1.format(1234.5)); // 1,234.5
System.out.println(formatter2.format(1234.5)); // 1,234
System.out.println(formatter3.format(1234.5)); // ¥1,234
System.out.println(formatter4.format(0.1));    // 10%

NumberFormat formatter1 = NumberFormat.getInstance(Locale.JAPAN);

// A.coreのリフレクションをBに許可
module com.sample.A {
  opens com.sample.A.core to com.sample.B
}

Automatic-Module-Name: Lib

// java --module-path {モジュールパス} --module {モジュール名/実行したい完全修飾クラス名}
java --module-path modules --module App/com.sample.Main

// META-INF/services配下のファイルから実装クラスを探したいインタフェースであるSampleを探す
// Sampleというファイルに書かれている完全修飾クラス名の実装クラスのインスタンスを生成する (DI的なやつ)
Iterator<Sample> samples = ServiceLoader.load(Sample.class).iterator();

module app {
  exports app;
  uses app.Sample; // app.SampleインタフェースをSPIとして利用する
}

module lib {
  exports lib;
  requires app;
  provides app.Sample with lib.SampleImpl; // Sampleインタフェースを実装したSampleImplを提供
}

// java.security.PolicyをextendsしてSamplePolicyクラスを定義しているとする
Permissions permissions = new Permissions();
permissions.add(new FilePermission("/", "read"));
Policy.setPolicy(new SamplePolicy(permissions));
System.setSecurityManager(new SecurityManager());

// example.policyでpermissionのgrantを設定する
java -Djava.security.manager -Djava.security.policy=example.policy Sample

grant {
  permission java.security.AllPermission;
}

grant codeBase "file:/path/to/lib.jar" {
  permission java.io.FilePermission "/", "read";
}

AccessController.doPrivileged(new PrivilegedAction<Object>(){
  @Override
  public Object run() {
    // ここに特権で実行した処理を書く
  }
})

ServiceLoader<Test> loader = ServiceLoader.load(Test.class)
for (Test test : loader) {
  test.execute();
}

// loaderにはTestインタフェースの実装クラスが格納されているためNG
loader.execute();

// loader.servicesというメソッドを実行する必要はないためNG
for (Test test : loader.services()) {
  test.execute();
}

public class A implements Comparator {
  @Override
  public int compare(Object o1, Object o2) {}
}

// ジェネリクスを指定すると下記のように書ける
public class A implements Comparator<String> {
  @Override
  public int compare(String s1, String s2) {
    return s1.compareTo(s2);
  }
}

// 匿名クラスを用いてもOK
new Comparator<String> () {
  public int compare(String s1, String s2) {
    return s1.compareTo(s2);
  }
}

List<Integer> list = List.of(0, 1, 2, 3, 4);
// IntegerからDoubleというラッパークラス型の変換であるため不適切
Double a = list.get(0);

public interface Test {
  public default void execute(String str) {
    System.out.println("A");
  }
}

public abstract class AbstractTest {
  private void execute(String str) {
    System.out.println("B");
  }
}

public class Main extends AbstractTest implements Test {
  public static void main(String[] args) {
    // java.lang.IllegalAccessError
    new Sample().execute("hello");
  }
}

Stream itemStream = items.stream();
// itemはObject型になるためgetPrice()が呼び出せずコンパイルエラー
itemStream.filter(item -> item.getPrice() > 200);

// コンパイルエラー
.stream().collect(Collectors.toSet()).count();

// OK
var r = new Random();
IntStream.generate(r::nextInt);

// NG
IntStream.generate(Random.nextInt);
IntStream.generate(Random::nextInt);

// ({カテゴリ指定}, {Locale定数})
Locale.setDefault(Locale.Category.FORMAT, Locale.JAPANESE)

// 第一引数がカテゴリではないためコンパイルエラー
Locale.setDefault("en", Locale.JAPANESE)

Paths src = Paths.get("a/sample.txt");
Paths dest = Paths.get("dest");
// a/sample.txtをdestという名前で移動させようとしている
Files.move(src, dest);

// OK
Comparator<Integer> a = new Comparator<> {}

// NG (左辺の時点でObject型と推論するため)
Comparator<> a = new Comparator<Integer> {}

Consumer c = (var s) -> System.out.println(s);
Consumer c = System.out::println;