JDK8到JDK17新特性

try (
    FileInputStream fis = new FileInputStream("d:/1.txt");
    InputStreamReader isr = new InputStreamReader(fis, "utf-8");
    BufferedReader br = new BufferedReader(isr);

    FileOutputStream fos = new FileOutputStream("1.txt");
    OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
    BufferedWriter bw = new BufferedWriter(osw);
) {
    String str;
    while ((str = br.readLine()) != null) {
        bw.write(str);
        bw.newLine();
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

InputStreamReader reader = new InputStreamReader(System.in);
OutputStreamWriter writer = new OutputStreamWriter(System.out);
try (reader; writer) {
    // 主要流程
} catch (IOException e) {
    e.printStackTrace();
}

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

Comparator<Integer> com1 = (Integer o1, Integer o2) -> {
    return o1.compareTo(o2);
};

// 类型推断：类型可以由编译器推理出来，可以不写
Comparator<Integer> com1 = (o1, o2) -> {
    return o1.compareTo(o2);
};

Consumer<String> con = System.out::println;

Supplier<Employee> sup = Employee::new;

Stream<Integer> stream = list.stream();

Stream<String> stream = Arrays.stream(arr); 

Stream<Integer> stream = Stream.of(1,2,3,4,5);

Stream<Integer> stream = Stream.iterate(0, x -> x + 2);
stream.limit(10).forEach(System.out::println);

Stream<Double> stream1 = Stream.generate(Math::random);
stream1.limit(10).forEach(System.out::println);

static <T> Optional<T> empty();				// 创建空的Optional实例
static <T> Optional<T> of(T value);			// 创建Optional实例，value必须非空
static <T> Optional<T> ofNullable(T value);	// 创建Optional实例，value可以为空，也可能为非空

T get()				// 存在则返回值，否则抛异常
T orElse(T other)	// 存在则返回值，为空就用指定的默认值
T orElseGet(Supplier<? extends T> other)	// 存在则返回值，为空就用Supplier接口提供的值
T orElseThrow(Supplier<? extends X> exceptionSupplier) // 存在则返回值，为空就用抛出你指定的异常类型

// 可以
Stream<String> stringStream = Stream.of("AA", "BB", null);
Long num = stringStream.collect(Collectors.counting()); // 3
    
// 不可以
Stream<String> stringStream = Stream.of(null);

// 可以
Stream<String> stringStream = Stream.ofNullable(null);
Long num = stringStream.collect(Collectors.counting()); // 0

// 可以
Stream<String> stringStream = Stream.ofNullable("AA");
Long num = stringStream.collect(Collectors.counting()); // 1

// 以前需要靠limit
Stream.iterate(1,i -> i + 1).limit(10).forEach(System.out::println);

// 现在可以定义终止条件
Stream.iterate(1,i -> i < 100,i -> i + 1).forEach(System.out::println);

public final class String implements java.io.Serializable, 
									Comparable<String>, 
									CharSequence, 
									Constable, 
									ConstantDesc {}

// Constable定义了方法，用于返回Optianl对象
public interface Constable {
	Optional<? extends ConstantDesc> describeConstable();
}

@Override
public Optional<String> describeConstable() {
	return Optional.of(this);
}

Optional<String> optional = str.describeConstable();

public <R> R transform(Function<? super String, ? extends R> f) {
	return f.apply(this);
}

// 有一点类似流中的map
"foo".transform(input -> input + " bar").transform(String::toUpperCase)

// 局部变量
var list = new ArrayList<String>();

// 增强for循环
for (var v : list) {
    System.out.println(v);
}

// 普通for循环
for (var i = 0; i < 100; i++) {
    System.out.println(i);
}

// 返回值类型含复杂泛型结构
//Iterator<Map.Entry<Integer, Student>> iterator = set.iterator();
var iterator = set.iterator();

// 以前
"line1\nline2\nline3\n"
    
// 现在
"""
line1
line2
line3
"""
    
// 如果最后不需要换行
"""
line1
line2
line3"""

String sql2 = """
        SELECT id,NAME,email \
        FROM customers\s\
        WHERE id > 4 \
        ORDER BY email DESC
        """;

Fruit fruit = Fruit.GRAPE;
switch(fruit){
    case PEAR -> System.out.println(4);
    case APPLE,MANGO,GRAPE -> System.out.println(5);
    case ORANGE,PAPAYA -> System.out.println(6);
    default -> throw new IllegalStateException("No Such Fruit:" + fruit);
};

Fruit fruit = Fruit.GRAPE;
int numberOfLetters = switch(fruit){
    case PEAR -> 4;
    case APPLE,MANGO,GRAPE -> 5;
    case ORANGE,PAPAYA -> 6;
    default -> throw new IllegalStateException("No Such Fruit:" + fruit);
};

String x = "3";
int i = switch (x) {
    case "1" -> 1;
    case "2" -> 2;
    default -> {
        yield 3;
    }
};

// 自动完成模式匹配，大大简化代码
return switch (o) {
    case Integer i -> String.format("int %d", i);
    case Long l    -> String.format("long %d", l);
    case Double d  -> String.format("double %f", d);
    case String s  -> String.format("String %s", s);
    default        -> o.toString();
};

if (obj instanceof String) {
    String str = (String) obj; //需要强转
    str.contains(..);
}

if (obj instanceof String str) {
    str.contains(..);
}

//不可以将record定义的类声明为abstract
//不可以给record定义的类声明显式的父类

public record Person(String name,Person partner) {

    //还可以声明静态的属性、静态的方法、构造器、实例方法

    public static String nation;

    public static String showNation(){
        return nation;
    }

    public Person(String name){
        this(name,null);
    }

    public String getNameInUpperCase(){
        return name.toUpperCase();
    }

    // 不可以声明非静态的属性
    // private int id;
}