switch(cond) {

	case val1: {
		int x = 1;
	} break;

	case val2: {
		int x = 2; // xを使いまわせる
	} break;

	default {
	} break;
}

String inputFile = null, outputFile = null;
try (BufferedReader br = Files.newBufferedReader(Paths.get(inputFile), Charset.forName("UTF-8"));
		PrintWriter pw = new PrintWriter(outputFile, "UTF-8")) {

	// Streamでいろいろ処理
	br.lines().forEach(l -> pw.println(l));

	pw.flush();

} catch (IOException e) {
	// ファイルが見つからなかった
	throw new UncheckedIOException(e);
}

class Super {
	final String fullName;
	final String shortName;

	Super(String name) {
		this.fullName = name;
		shortName = getShort();
	}
	String getShort() {
		// 表示用の短い名前
		return fullName.length() > 5 ?
				fullName.subString(0,5) :
				fullName;
	}
}


class Sub {
	final int num;

	Sub(String name, int num) {
		super(name);
		this.num = num;
	}
	getShort() {
		// 追加した数字も含める
		return super.getShort() + num;
	}
}

class Super {
	protected Super(String fullName, String shortName) {
		this.fullName = name;
		this.shortName = shortName;
	}
	Super(String name) {
		this(name, getShort());
	}
	...
}

	protected Super(String fullName, String shortName) {
		checkShortName(shortName);
		this.fullName = name;
		this.shortName = shortName;
	}
	private static void checkShortName(String shortName) {
		if(shortName.length() > 5) {
			throw new IllegalArgumentException("shortName : "+shortName);
		}
	}

class Singleton extends CloneableClass implements Serializable {

	// フィールドは全てtransientに
	private transient String field;

	// 外部のクラスからコンストラクタにアクセスさせない
	private Singleton() {
		// 初期化
	}

	// Initialize-on-Demand Holderパターンによる遅延初期化クラス
	private static class SingletonHolder {
		static Singleton singleton = new Singleton();

		Singleton getInstance() {
			return singleton;
		}
	}

	// ファクトリメソッド
	public static Singleton getInstance() {
		return SingletonHolder.getInstance();
	}

	// デシリアライズの結果を上書き
	private Object readResolve() throws ObjectStreamException {
		return getInstance();
	}

	// クローンさせない
	public Object clone() throws CloneNotSupportedException {
		throw new CloneNotSupportedException();
	}
}

enum Singleton { // enumは既にSerializable
	INSTANCE;

	// transientにしなくてよい
	private String field;
}

Files.find(Paths.get(base), 1, (p,a) -> !a.isDirectory())
		.filter(path -> path.File().getName().endsWith(".jar"))
		.forEach(path -> System.out.println(path));

// 直列化対象オブジェクト
String target = "Hello";
// 直列化バイト列
byte[] serialized;
// 復元オブジェクト
String restored;

// バイト列格納用
ByteArrayOutputStream bos = new ByteArrayOutputStream();

ObjectOutputStream out = new ObjectOutputStream(bos);
out.writeObject(target); // 直列化！

// バイト列
serialized = bos.toByteArray();

ByteArrayInputStream bis = new ByteArrayInputStream(serialized);
ObjectInputStream in = new ObjectInputStream(bis);
restored = (String) in.readObject(); // 復元！

System.out.println(target); // Hello
System.out.println(Arrays.toString(serialized)); // [-84, -19, 0, 5, 116, 0, 5, 72, 101, 108, 108, 111]
System.out.println(restored); // Hello

public class Target implements Serializable {
	public static final long serialVersionUID = ...

	...
}

private void writeObject(ObjectOutputStream out) throws IOException
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException

class Foo implements Serializable {
	int bar;
	transient int baz;

	private void writeObject(ObjectOutputStream out) throws IOException {
		out.defaultWriteObject();
		out.writeInt(baz)
	}

	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();
		baz = in.readInt();
	}
}

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

class Foo implements Serializable {
	private final int bar; // 保存したいデータ
	private final int baz; // 保存したいデータ

	private Foo(int bar, int baz) {
		this.bar = bar;
		this.baz = baz;
	}

	... // メソッドとか

	// 以下 Serialization Proxy パターン
	private static class SerializationProxy implements Serializable {
		private long qux; // 実際に保存するデータ

		SerializationProxy(int bar, int baz) {
			qux = (((long) bar) << 32) | baz // 変換
		}

		private Object readResolve() {
			Foo result = new Foo((int) (qux >>> 32), (int) qux); // 逆変換
			return result;
		}

		private static final long serialVersionUID = ...
	}

	Object writeReplace() {
		// 書き込み時は SerializationProxy を書き込む
		return new SerializationProxy<>(this);
	}

	// 無理矢理読み込むの禁止
	private void readObject(ObjectInputStream in) throws InvalidObjectException {
		throw new java.io.InvalidObjectException("Proxy required");
	}
}

x = "x"
f = str -> Stream.of(capitalize(str)) :: String → Stream<String>
g = str -> Stream.of(str.length()) :: Stirng → Stream<Integer>

Stream.of(x).flatMap(f) ≡ f(x)
m.flatMap(Stream::of) ≡ m
m.flatMap(f).flatMap(g) ≡ m.flatMap(str -> f(str).flatMap(g))

Stream.empty().flatMap(f) ≡ Stream.empty()
m.flatMap(Stream::empty) ≡ Stream.empty()
Stream.concat(Stream.empty(), m) ≡ m
Stream.concat(m, Stream.empty()) ≡ m

Function<Integer, String> int2str = String::valueOf;
Function<Stream<Integer>, Stream<String>> sint2sstr = sint -> sint.map(int2str);

func :: α → (β → γ)
arg1 :: α F
arg2 :: β F

func :: α → (β → γ)
func <$> :: α F → (β → γ) F
func <$> arg1 :: (β → γ) F
func <$> arg1 <*> :: β F → γ F
func <$> arg1 <*> arg2 :: γ F

@Override
public TargetClass clone() {
	try {
		TargetClass clone = (TargetClass) super.clone();
		clone.mutableField = mutableField.clone();
		return clone;
	} catch (CloneNotSupportedException e) {
		throw new Error("Implementation defect", e);
	}
}

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

public class CloneTest implements Cloneable {

	int primitive = 1;

	int[] array = new int[]{1};

	List<Integer> mutable = Arrays.asList(1);

	@Override
	public CloneTest clone() {
		try {
			return (CloneTest) super.clone();
		} catch (CloneNotSupportedException e) {
			throw new Error("Implementation defect", e);
		}
	}

	@Override
	public String toString() {
		return "primitive: "+primitive+ 
				", array:"+Arrays.toString(array)+ 
				", mutable: "+mutable;
	}

	public static void main(String[] args) {
		CloneTest original = new CloneTest();
		CloneTest clone = original.clone();

		// originalを出力
		// primitive: 1, array:[1], mutable: [1]
		System.out.println(original);

		// cloneを変更
		clone.primitive = 2;
		clone.array[0] = 2;
		clone.mutable.set(0, 2);

		// originalを出力
		// primitive: 1, array:[2], mutable: [2]
		System.out.println(original);
	}
}

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class StopThread {
	public static void main(String[] args) throws InterruptedException {

		ConsistenceTarget target = new ConsistenceTarget();

		List<WorkingThread> threads = IntStream.range(0, 5)
				.mapToObj(i -> new WorkingThread(target))
				.collect(Collectors.toList());

		threads.forEach(t -> {
			t.start();
			System.out.println("Start thread-"+t.getId());
		});

		Thread.sleep(1000);

		threads.forEach(t -> {
			t.stop();
			System.out.println("Stop thread-"+t.getId());
			try {
				Thread.sleep(100);
			} catch(InterruptedException e) {}
		});
	}
//	Start thread-11
//	Start thread-12
//	Start thread-13
//	Start thread-14
//	Start thread-15
//	Stop thread-11
//	Innconsistent in thread-12
//	Innconsistent in thread-14
//	Innconsistent in thread-15
//	Innconsistent in thread-13
//	Stop thread-12
//	Stop thread-13
//	Stop thread-14
//	Stop thread-15

	static class WorkingThread extends Thread {
		private ConsistenceTarget target;
		public WorkingThread(ConsistenceTarget target) {
			this.target = target;
		}

		@Override
		public void run() {
			while(true) {
				target.doSomething();
			}
		}
	}

	static class ConsistenceTarget {
		private boolean consistency = true;

		public synchronized void doSomething() {
			if(!consistency) {
				System.err.println("Innconsistent in thread-" 
						+Thread.currentThread().getId());
				Thread.currentThread().stop();
			}

			consistency = false;
			for (int i = 0; i < 10000; i++) {
				// 何らかの処理
			}
			consistency = true;
		}
	}
}

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class StopThreadUsingVolatile {
	public static void main(String[] args) throws InterruptedException {

		ConsistenceTarget target = new ConsistenceTarget();

		List<WorkingThread> threads = IntStream.range(0, 5)
				.mapToObj(i -> new WorkingThread(target))
				.collect(Collectors.toList());

		threads.forEach(Thread::start);

		Thread.sleep(1000);

		threads.forEach(t -> {
			t.safeStop();
			try {
				Thread.sleep(100);
			} catch(InterruptedException e) {}
		});
	}
//	Start thread-11
//	Start thread-14
//	Start thread-12
//	Start thread-13
//	Start thread-15
//	Stop thread-11
//	Stop thread-12
//	Stop thread-13
//	Stop thread-14
//	Stop thread-15

	static class WorkingThread extends Thread {
		private ConsistenceTarget target;
		private volatile boolean running;
		public WorkingThread(ConsistenceTarget target) {
			this.target = target;
			this.running = true;
		}

		@Override
		public void run() {
			System.out.println("Start thread-" 
					+Thread.currentThread().getId());
			while(running) {
				target.doSomething();
			}
			System.out.println("Stop thread- "
					+Thread.currentThread().getId());
		}

		public void safeStop() {
			running = false;
		}
	}

	static class ConsistenceTarget {
		private boolean consistency = true;

		public synchronized void doSomething() {
			if(!consistency) {
				System.err.println("Innconsistent in thread-"+
						Thread.currentThread().getId());
				Thread.currentThread().stop();
			}

			consistency = false;
			for (int i = 0; i < 10000; i++) {
				// 何らかの処理
			}
			consistency = true;
		}
	}
}

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class StopThreadUsingInterrupt {
	public static void main(String[] args) throws InterruptedException {

		ConsistenceTarget target = new ConsistenceTarget();

		List<WorkingThread> threads = IntStream.range(0, 5)
				.mapToObj(i -> new WorkingThread(target))
				.collect(Collectors.toList());

		threads.forEach(Thread::start);

		Thread.sleep(1000);

		threads.forEach(t -> {
			t.interrupt();
			try {
				Thread.sleep(100);
			} catch(InterruptedException e) {}
		});
	}
//	Start thread-11
//	Start thread-14
//	Start thread-12
//	Start thread-13
//	Start thread-15
//	Stop thread-11
//	Stop thread-12
//	Stop thread-13
//	Stop thread-14
//	Stop thread-15

	static class WorkingThread extends Thread {
		private ConsistenceTarget target;
		public WorkingThread(ConsistenceTarget target) {
			this.target = target;
		}

		@Override
		public void run() {
			System.out.println("Start thread-" 
					+Thread.currentThread().getId());
			while(true) {
				target.doSomething();
				if(Thread.interrupted()) {
					break;
				}
			}
			System.out.println("Stop thread-" 
					+Thread.currentThread().getId());
		}
	}

	static class ConsistenceTarget {
		private boolean consistency = true;

		public synchronized void doSomething() {
			if(!consistency) {
				System.err.println("Innconsistent in thread-" 
						+Thread.currentThread().getId());
				Thread.currentThread().stop();
			}

			consistency = false;
			for (int i = 0; i < 10000; i++) {
				// 何らかの処理
			}
			consistency = true;
		}
	}
}

interface Node {
	void accept(Visitor visitor);
}

class Branch implements Node {
	public Node left;
	public Node right;

	public void accept(Visitor visitor) {
		visitor.visit(this);
	}
}

class Leaf implements Node {
	public int value;

	public void accept(Visitor visitor) {
		visitor.visit(this);
	}
}

interface Visitor {
	void visit(Branch branch);
	void visit(Leaf leaf);
}

class PrintNode implements Visitor {
	@Override
	public void visit(Branch branch) {
		System.out.println("(");
		accept(branch.left);
		System.out.println(",");
		accept(branch.right);
		System.out.println(")");
	}

	@Override
	public void visit(Leaf leaf) {
		System.out.println(leaf.value);
	}
}

class SumNode implements Visitor {
	int sum = 0;

	@Override
	public void visit(Branch branch) {
		accept(branch.left);
		accept(branch.right);
	}

	@Override
	public void visit(Leaf leaf) {
		sum += leaf.value;
	}
}

abstract class BeginEndVisitor implements Visitor {
	public abstract boolean beginVisit(Branch branch);
	public abstract void endVisit(Branch branch);

	@Override
	public final void visit(Branch branch) {
		if(beginVisit(branch)) {
			visit(branch.left);
			visit(branch.right);
			endVisit(branch);
		}
	}
}

interface Node {
	<R, P, E extends Exception> R accept(FunctionalVisitor<R, P> visitor, P param) throws E;
}

iterface FunctionalVisitor<R, P, E extends Exception> {
	R visit(Branch branch, P param) throws E;
	R visit(Leaf leaf, P param) throws E;
}

package inner;

public class Outer {
	{
		new Inner(1).innerField=0;
	}

	static class Inner {
		private int innerField;
		private Inner(int i) {
			innerField = i;
		};
	}
}

class inner.Outer
{
  public inner.Outer();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=4, locals=1, args_size=1
         0: aload_0
         1: invokespecial #8                  // Method java/lang/Object."<init>":()V
         4: new           #10                 // class inner/Outer$Inner
         7: dup
         8: iconst_1
         9: aconst_null
        10: invokespecial #12                 // Method inner/Outer$Inner."<init>":(ILinner/Outer$Inner;)V
        13: iconst_0
        14: invokestatic  #15                 // Method inner/Outer$Inner.access$1:(Linner/Outer$Inner;I)V
        17: return
}
SourceFile: "Outer.java"
InnerClasses:
     static #26= #10 of #1; //Inner=class inner/Outer$Inner of class inner/Outer

class inner.Outer$Inner
{
  private int innerField;
    descriptor: I
    flags: ACC_PRIVATE

  private inner.Outer$Inner(int);
    descriptor: (I)V
    flags: ACC_PRIVATE
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: invokespecial #10                 // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iload_1
         6: putfield      #13                 // Field innerField:I
         9: return

  inner.Outer$Inner(int, inner.Outer$Inner);
    descriptor: (ILinner/Outer$Inner;)V
    flags: ACC_SYNTHETIC
    Code:
      stack=2, locals=3, args_size=3
         0: aload_0
         1: iload_1
         2: invokespecial #21                 // Method "<init>":(I)V
         5: return

  static void access$1(inner.Outer$Inner, int);
    descriptor: (Linner/Outer$Inner;I)V
    flags: ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: iload_1
         2: putfield      #13                 // Field innerField:I
         5: return
}
SourceFile: "Outer.java"
InnerClasses:
     static #30= #1 of #28; //Inner=class inner/Outer$Inner of class inner/Outer

class inner.Outer$Inner
{
  private int innerField;
    descriptor: I
    flags: ACC_PRIVATE

  private inner.Outer$Inner(int);
    descriptor: (I)V
    flags: ACC_PRIVATE
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: invokespecial #3                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iload_1
         6: putfield      #1                  // Field innerField:I
         9: return

  inner.Outer$Inner(int, inner.Outer$1);
    descriptor: (ILinner/Outer$1;)V
    flags: ACC_SYNTHETIC
    Code:
      stack=2, locals=3, args_size=3
         0: aload_0
         1: iload_1
         2: invokespecial #2                  // Method "<init>":(I)V
         5: return

  static int access$102(inner.Outer$Inner, int);
    descriptor: (Linner/Outer$Inner;I)I
    flags: ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=3, locals=2, args_size=2
         0: aload_0
         1: iload_1
         2: dup_x1
         3: putfield      #1                  // Field innerField:I
         6: ireturn
}
SourceFile: "Outer.java"
InnerClasses:
     static #12; //class inner/Outer$1
     static #16= #4 of #23; //Inner=class inner/Outer$Inner of class inner/Outer

    Parent.super.member

int bitField = 0b10011;

for(int i = bitField & -bitField; i != 0 ; i = bitField & (~bitField + (i << 1))) {
	// i = 0b00001, 0b00010, 0b10000
}

int bitField = 0b10011;

for(int i = 0;;i = (i - bitFiled) & bitFiled) {

	// i = 0b00000, 0b00001, 0b00010, 0b00011, 0b10000, 0b10001, 0b10010, 0b10011

	if (y == bitFiled) break;
}

for(int i = bitFiled;;i = (i - 1) & bitFiled) {

	// i = 0b10011, 0b10010, 0b10001, 0b10000, 0b00011, 0b00010, 0b00001, 0b00000

	if (y == 0) break;
}

t = (a & 0x7ffffff)+(b & 0x7fffffff)
t = a & (b|t) | b&t

public <T> T getArray(int length, T... dummy) {
	return (T[]) Array.newInstance(dummy.getClass().getComponentType(), length);
}

public enum Course {
	BACHELOR("_"),  // 学部生
	MASTER  ("M"),  // 修士課程
	DOCTOR  ("D"),  // 博士課程

	RESEARCH("R");  // 研究生

	private String str;  // 学籍番号の出だし
	private Course(String str) {
		this.str = str;
	}

	public boolean check(String studentId) {
		return studentId.startsWith(str);
	}

	public static Course classify(String studentId) {
		for(Course c: values()) {
			if(c.check(studentId)) {
				return c;
			}
		}
		throw new IllegalArgumentException(
				"studentId: "+studentId);
	}
}

public enum BranchCondition {
	A (0b0000, flag -> true),                // 常に分岐
	VF(0b0001, Flag.VF.is(1)),               // オーバーフローで分岐
	NZ(0b0010, Flag.ZF.is(0)),               // 0以外で分岐
	Z (0b0011, Flag.ZF.is(1)),               // 0で分岐
	ZP(0b0100, Flag.NF.is(0)),               // 0以上で分岐
	N (0b0101, Flag.NF.is(1)),               // 負で分岐
	P (0b0110, Flag.NF.and(Flag.ZF).is(0)),  // 正で分岐
	ZN(0b0111, Flag.NF.or (Flag.ZF).is(1)),  // 0以下で分岐
	...

	private final int lower4;
	private final BitChecker checker;
	private BranchCondition(int lower4, BitChecker checker) { ... }
}

public enum Flag implements BitChecker {
	CF(0b1000),
	NF(0b0100),
	VF(0b0010),
	ZF(0b0001);
	...

	@Override
	public boolean check(int flag) {
		return (flag & mask) != 0;
	}
}

@FunctionalInterface
interface BitChecker {
	/**
	 * 指定したフラグレジスタの状態が条件を満たすか確認する
	 * @param fr フラグレジスタの状態
	 * @return 適合すれば1そうでなければ0
	 */
	boolean check(int fr);

	default BitChecker and(BitChecker target) {
		return fr -> check(fr) && target.check(fr);
	}
	...

	default BitChecker is(int result) {
		if(result != 0 && result != 1) {
			throw new IllegalArgumentException("result: "+result);
		}
		return fr -> !(check(fr)^(result == 1));
	}
}

String[] strs = new String[] {"foo", "bar"};
Object[] objs = strs;
objs[0] = Integer.valueOf(42); // ArrayStoreException

import java.io.IOException;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.FileASTRequestor;
import org.eclipse.jdt.core.dom.MethodInvocation;

public class Main {
	public static void main(String[] args) throws IOException {

		ASTVisitor visitor = new ASTVisitor(){
			@Override
			public boolean visit(MethodInvocation node) {
				System.out.println(node.resolveMethodBinding());
				return false;
			}
		};

		ASTParser parser = ASTParser.newParser(AST.JLS10);
		parser.setResolveBindings(true);
		parser.setBindingsRecovery(true);

		String[] srcDirs = new String[]{"./src"};
		String[] sources = new String[]{"./src/TargetForLevel2.java"};
		String[] libs    = new String[]{ /* no jar files */ };

		parser.setEnvironment(libs, srcDirs, null, true);

		parser.createASTs(sources, null, new String[0], new FileASTRequestor() {
			@Override
			public void acceptAST(String sourceFilePath, CompilationUnit ast) {
				System.out.println("File: "+sourceFilePath);
				ast.accept(visitor);
			}
		}, new NullProgressMonitor());
	}
}

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>DefUse</groupId>
	<artifactId>DefUse</artifactId>
	<version>0.0.1</version>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>10</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.eclipse.platform</groupId>
			<artifactId>org.eclipse.core.jobs</artifactId>
			<version>3.10.0</version>
		</dependency>
		<dependency>
			<groupId>org.eclipse.platform</groupId>
			<artifactId>org.eclipse.core.resources</artifactId>
			<version>3.13.0</version>
		</dependency>
		<dependency>
			<groupId>org.eclipse.platform</groupId>
			<artifactId>org.eclipse.core.runtime</artifactId>
			<version>3.14.0</version>
		</dependency>
		<dependency>
			<groupId>org.eclipse.platform</groupId>
			<artifactId>org.eclipse.equinox.app</artifactId>
			<version>1.3.500</version>
		</dependency>
		<dependency>
			<groupId>org.eclipse.jdt</groupId>
			<artifactId>org.eclipse.jdt.core</artifactId>
			<version>3.14.0</version>
		</dependency>
		<dependency>
			<groupId>org.eclipse.platform</groupId>
			<artifactId>org.eclipse.osgi</artifactId>
			<version>3.13.0</version>
		</dependency>
	</dependencies>

	<build>
		<sourceDirectory>src</sourceDirectory>
		<resources>
			<resource>
				<directory>src</directory>
				<excludes>
					<exclude>**/*.java</exclude>
				</excludes>
			</resource>
		</resources>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>${java.version}</source>
					<target>${java.version}</target>

				</configuration>
			</plugin>
		</plugins>
	</build>
</project>