new Thread(new Runnable(){
    @Override
    public void run(){
        System.out.println("Hello World");
    }
}).start();

//相当于创建了一个Runnable接口实例，并传入
new Thread(()->{System.out.println("Hello World");}).start();

//这样也是可以的
Runnable runnable = ()->{System.out.println("Hello World");};

@FunctionalInterface  //这个标注不是必须的，符合函数式接口定义即可
public interface MyFunctionInterface {
    public abstract void print();
    public default void print1(){} //函数式接口允许多个非抽象方法
    public default void print2(){}
}

//java Lambda
(int x, int y)->{return x+y;};                           //显式声明参数类型，是个好习惯，方便阅读
(x, y)->{return x+y;};                                   //不声明参数类型，根据对应函数式接口判断
x->{return x+1;};                                        //单参数时，不用圆括号
x->x+1;                                                  //单语句时，不用花括号，此时默认返回值即语句返回值，不能使用return语句
()->"Hello World";                                       //无参数
()->System.out.println("Hello world");                   //无返回值

Runnable r = System.out::println;
//等效于
Runable r = ()->System.out.println();

Consumer<String> consumer = System.out::println;
//等效于
Consumer<String> consumer = (String s)->System.out.println(s);

{
    /*
    * 下面代码三个子线程依次输出1、2、3。若主线程使用notifyAll()，那么子线程之间将会进行竞争，由于优先级一致，会有不同的顺序可能。
    */
    String flag = "";
    new Thread(()->{ 
        synchronized(flag) {
            try {
                flag.wait(); //子线程1获得flag的锁，被放入等待队列，然后临时释放拥有的锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(1);
        }
    }).start();
    new Thread(()->{
        synchronized(flag) {
            try {
                flag.wait();//子线程2获得flag的锁，被放入等待队列，然后临时释放拥有的锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(2);
        }
    }).start();
    new Thread(()->{
        synchronized(flag) {
            try {
                flag.wait();//子线程3获得flag的锁，被放入等待队列，然后临时释放拥有的锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(3);
        }
    }).start();
    synchronized(flag) {//主线程获得对象flag的锁
        flag.notify();//子线程1被放出，进入flag的同步队列，此时flag的锁在主线程手中
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < 1000);
    }//主线程释放对象flag的锁
    Thread.sleep(5000);//主线程休眠，让优先级较低的子线程1获取flag的锁
    synchronized(flag) {//主线程获得对象flag的锁
        flag.notify();//子线程2被放出，进入flag的同步队列，此时flag的锁在主线程手中
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < 1000);
    }//主线程释放对象flag的锁
    Thread.sleep(5000);/主线程休眠，让优先级较低的子线程2获取flag的锁
    synchronized(flag) {
        flag.notify();
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < 1000);
    }//主线程释放对象flag的锁，子线程3获取flag的锁
}

public final synchronized void join(final long millis)
throws InterruptedException {
    if (millis > 0) {
        if (isAlive()) {
            final long startTime = System.nanoTime();
            long delay = millis;
            do {
                wait(delay);
            } while (isAlive() && (delay = millis -
                    TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
        }
    } else if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        throw new IllegalArgumentException("timeout value is negative");
    }
}

Lock lock = new ReentrantLock();
lock.lock();//取锁
.....//相当于synchronized的代码块中同步内容，此时的锁的对象正是lock实例，当某个线程获得锁时，其他线程也就卡在了lock.lock()这里。
lock.unlock();//放锁

List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());//结果是true，因为在字节码中只有List原生类型

//泛型类，这是java.util.ArrayList<E>的源码声明，泛型声明<E>紧靠类名
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

//泛型方法，泛型类型由泛型参数推断，因此必须有泛型参数，否则这个泛型没有意义
public <T> T get(T t) {
    return t;
}

//泛型接口，这是java.util.List<E>的源码声明，格式与泛型类一致
public interface List<E> extends Collection<E> 

//泛型方法可以在泛型类中同时存在，若泛型参数相同，泛型方法使用自身的泛型参数而隐藏类泛型参数
class Vector<E> extends java.util.ArrayList<E> {
    public <E> void print(E r) {
        System.out.println(r.getClass().getName());
    }
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.print(1);//输出是java.lang.Integer而不是java.lang.String
    }
}

//泛型声明还可以通过extends关键字约束泛型声明的上限，其实默认上限就是Object，同类的继承一样。
//extends声明的上限也决定了类型擦除后的具体类型，详见下文
class Vector<E extends Integer> extends java.util.ArrayList<E>

class Vector<E> extends java.util.ArrayList<E> {
    public static <E> void print(E r) {//静态泛型方法，通过编译
        System.out.println(r.getClass().getName());
    }
    public static void print2(E r) {//静态普通方法，使用类泛型参数无法通过编译
        System.out.println(r.getClass().getName());
    }
}

ArrayList<Number> array1 = new ArrayList<>();
ArrayList<Integer> array2 = new ArrayList<>();

array1 = array2;//无法通过编译，会报错。纵然Number是Integer的超类。

ArrayList<?> array3= array2;//编译通过，代价时无法进行与泛型相关的操作，如array3.add()方法需要传入泛型实例，只能用array3.size()这种。 
array3.add(1);//编译不通过，当然通过反射机制能够绕开这个限制
array3.size();//编译通过
//编译通过，利用反射机制绕过限制，原因在于类型擦除，但一般没谁闲得慌干这个骚操作，这个操作同时跳脱了array2本身的泛型类型限制
array3.getClass().getMethod("add", Object.class).invoke(array3, 1);

//extends决定通配符的上限（包括），此案例不通过编译
ArrayList<? extends Integer> array4 = new ArrayList<Object>();

//super决定通配符的下限（包括），此案例不通过编译
ArrayList<? super Number> array4 = new ArrayList<Integer>();

//泛型源码
class Generics<E extends Number> {
    public E print(E r) {
        System.out.println(r.getClass().getName());
        return r;
    }
    public static void main(String[] args) {
        Generics<Integer> v = new Generics<>();
        int res = v.print(10);
    }
}

//擦除后的等效源码，当没有声明extends Number，默认是extends Object，因此会替换为Object
class Generics {
    public Number print(Number r) {
        System.out.println(r.getClass().getName());//输出java.lang.Integer
        return r;
    }
    public static void main(String[] args) {
        Generics v = new Generics();
        //根据<Integer>指定，施行强制转换，类型安全就由泛型而得到保障，泛型带来最直接的优势也就是不用我们自己去转换
        int res = (Integer) v.print(10);
    }
}

class Generics<E extends Number> {
    E infoE = null;
    public static void main(String[] args) {
        Generics<Integer> v = new Generics<>();
        try {
            System.out.println(v.getClass().getDeclaredField("infoE").getType().getName());//输出为java.lang.Number
        } catch (NoSuchFieldException | SecurityException e) {
            e.printStackTrace();
        }
    }
}

class Data<T extends Number> {
    private T value;
    public Data(T value) throws Exception {
        this.value = value;
        // 编译正常
        T c = value;
        // 编译报错：Cannot instantiate the type T
        T d = new T();
        // 编译正常，利用反射机制掉取构造器创建新类，前提是对该类型构造器清楚
        T f = (T) value.getClass().getConstructor(String.class).newInstance("2000");
        // 编译正常
        System.out.println(value.getClass().getName())；
        // 编译报错：Illegal class literal for the type parameter T
        System.out.printlnt(T.class);
    }
}

//这是java.until.ArrayList<E>的writeObject源码，通过自定义writeObject，实现只序列化我们的元素，而不序列化整个elementData数组。
transient Object[] elementData;
....
@java.io.Serial
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioral compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

//对应的`java.until.ArrayList<E>` readObject方法，与writeObject逻辑对应。
@java.io.Serial
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // like clone(), allocate array based upon size not capacity
        SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Object[].class, size);
        Object[] elements = new Object[size];

        // Read in all elements in the proper order.
        for (int i = 0; i < size; i++) {
            elements[i] = s.readObject();
        }

        elementData = elements;
    } else if (size == 0) {
        elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new java.io.InvalidObjectException("Invalid size: " + size);
    }
}

public final class Void {
    /*
    * The Void class cannot be instantiated.
    */
    private Void() {}

public class arrayParam {
    String hello() {return "";}
    void print(Object... args) {
        System.out.println(args.length);
    }
    public static void main(String[] args) {
        for (Method method: arrayParam.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType());
            if (method.getReturnType().equals(Void.TYPE)) {
                System.out.println(method.getName());
            }
        }
    }
}

/* 这是getPrimitiveClass方法的源码
* Return the Virtual Machine's Class object for the named
* primitive type.
*/
static native Class<?> getPrimitiveClass(String name);

//这是所有常见封装类的TYPE属性声明
public static final Class<Integer>   TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
public static final Class<Void>      TYPE = (Class<Void>) Class.getPrimitiveClass("void");
public static final Class<Long>      TYPE = (Class<Long>) Class.getPrimitiveClass("long");
public static final Class<Double>    TYPE = (Class<Double>) Class.getPrimitiveClass("double");
public static final Class<Float>     TYPE = (Class<Float>) Class.getPrimitiveClass("float");
public static final Class<Byte>      TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");
public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");
public static final Class<Boolean>   TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");

public class nativeHelloWorld{
    public static void main(String[] args) {
        print("Hello world");
    }
    public static native void print(String args);
    static {
        System.load("D:/zhang/userfile/office/Study/IDRB/Java/java_test/libnativeHelloWorld.dll");
    }
}

Process p = Runtime.getRuntime().exec(new String[]{
    "jupyter-lab",
    "--allow-root",
    "--port", "8080",
    "--ip", "0.0.0.0"
});
BufferedReader br = null;
br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line = null;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();

public Process exec(String[] cmdarray, String[] envp, File dir)
    throws IOException {
    return new ProcessBuilder(cmdarray)
        .environment(envp)
        .directory(dir)
        .start();
}

ProcessBuilder pb = new ProcessBuilder(new String[]{
    "jupyter-lab",
    "--allow-root",
    "--port", "8080",
    "--ip", "0.0.0.0"
});
pb.redirectOutput(ProcessBuilder.Redirect.INHERIT); //重定向输出到当前终端
pb.redirectError(ProcessBuilder.Redirect.INHERIT);  //重定向错误到当前终端
Process p = pb.start();
p.waitFor(); //阻塞当前线程以观察输出。

try (
    FileInputStream fis = new FileInputStream("input.txt");
    FileOutputStream fos = new FileOutputStream("output.txt");
) {
    ...
} catch (IOException e) {
    ...
} finaly {
    ...
}