Java 入门 + 进阶训练

public class Hello {
    public static void main(String[] args) {
        System.out.println("你好，Java！");   // 打印并换行
        System.out.print("2 * 3 = ");
        System.out.println(2 * 3);            // 6
    }
}

javac Hello.java     # 编译：生成 Hello.class（字节码）
java Hello           # 运行（不要写 java Hello.class）

public class Types {
    public static void main(String[] args) {
        int age = 18;
        double price = 9.9;          // 小数默认 double
        char ch = 'A';
        boolean flag = true;
        String name = "小明";         // String 是引用类型（类）
        long big = 1_000_000L;       // 下划线增强可读性，必须加 L
        System.out.println(age + " " + name);
        System.out.println(flag);    // true
    }
}

public class Op {
    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println(a / b);      // 3（整数相除截断小数！）
        System.out.println(a % b);      // 1（取余）
        System.out.println(a == b);     // false（关系运算返回 boolean）

        // 短路与：左边为 false 右边不执行
        boolean r = (b != 0) && (a / b > 2);
        System.out.println(r);          // true

        // 短路或：左边为 true 右边不执行
        boolean r2 = (b == 0) || (a / b > 2);
        System.out.println(r2);         // true

        // 自增
        int i = 0;
        System.out.println(i++);        // 0（先用后加）
        System.out.println(++i);        // 2（先加后用）
    }
}

public class Flow {
    public static void main(String[] args) {
        int n = 7;
        if (n % 2 == 0) {
            System.out.println("偶数");
        } else {
            System.out.println("奇数");
        }

        // 传统 for
        int sum = 0;
        for (int i = 1; i <= 100; i++) sum += i;
        System.out.println("1..100 和=" + sum);

        // while 与 do-while
        int k = 0;
        while (k < 3) { System.out.print(k++ + " "); }
        System.out.println();

        // switch 表达式（Java 14+）
        String level = switch (n % 3) {
            case 0 -> "整除3";
            case 1 -> "余1";
            default -> "其他";
        };
        System.out.println(level);
    }
}

public class Arr {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1};       // 声明并初始化
        System.out.println(a.length); // 4（注意是 .length 不是 ()）
        System.out.println(a[0]);     // 5

        // 二维数组（每行长度可不同，是"数组的数组"）
        int[][] m = {{1, 2}, {3, 4, 5}};
        System.out.println(m[1][2]);   // 5
        System.out.println(m.length);  // 2（两行）

        // 排序、打印、填充用工具类
        java.util.Arrays.sort(a);
        System.out.println(java.util.Arrays.toString(a)); // [1, 2, 5, 9]
        int[] z = new int[3];
        java.util.Arrays.fill(z, 7);
        System.out.println(java.util.Arrays.toString(z)); // [7, 7, 7]
    }
}

public class Str {
    public static void main(String[] args) {
        String s = "hello";
        s = s + " world";              // 生成新对象，原 "hello" 不变
        System.out.println(s);          // hello world

        System.out.println(s.length());         // 11
        System.out.println(s.substring(0, 5));   // hello
        System.out.println(s.contains("world")); // true
        System.out.println(s.startsWith("he"));  // true
        System.out.println(s.equals("hello world")); // true（比内容）
        System.out.println(s.indexOf("world"));  // 6

        String upper = s.toUpperCase();
        System.out.println(upper);      // HELLO WORLD（原 s 仍是小写）
    }
}

String a = new String("hi");
String b = new String("hi");
System.out.println(a == b);        // false（两个不同对象）
System.out.println(a.equals(b));   // true（内容相同）

// 高频拼接用 StringBuilder，避免产生大量中间对象
StringBuilder sb = new StringBuilder();
sb.append("hello").append(" ").append("world");
System.out.println(sb.toString()); // hello world

public class Student {
    private String name;   // 私有字段（封装）
    private int age;

    public Student(String name, int age) {  // 构造器（无返回类型，名同类名）
        this.name = name;   // this 指"当前对象"，区分同名字段与参数
        this.age = age;
    }

    // getter / setter：受控访问私有字段
    public String getName() { return name; }
    public void setAge(int age) {
        if (age >= 0) this.age = age;   // 可在 setter 里加校验
    }
    public void sayHi() {
        System.out.println("我是 " + name + "，今年 " + age);
    }

    public static void main(String[] args) {
        Student s = new Student("小明", 18);  // new 触发构造器
        s.sayHi();                            // 我是 小明，今年 18
    }
}

class Animal {
    protected String name;        // 子类可见
    public Animal(String name) { this.name = name; }
    public void eat() { System.out.println(name + " 在吃"); }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);              // 必须第一行调用父类构造器
    }
    @Override
    public void eat() {           // 重写父类方法
        super.eat();              // 可先调父类版本
        System.out.println(name + " 吃狗粮");
    }
    public void bark() { System.out.println(name + " 汪汪"); }
}

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog("旺财");
        d.eat();                   // 调重写的版本
        d.bark();
    }
}

interface Shape {                 // 接口：抽象方法（Java 8+ 可带 default）
    double area();
    default void desc() { System.out.println("我是一个图形"); }
}

class Circle implements Shape {
    private double r;
    public Circle(double r) { this.r = r; }
    @Override
    public double area() { return 3.14159 * r * r; }
}

class Rect implements Shape {
    private double w, h;
    public Rect(double w, double h) { this.w = w; this.h = h; }
    @Override
    public double area() { return w * h; }
}

public class Test {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);   // 向上转型：用接口类型持有
        System.out.println(s.area()); // 12.56...（实际调 Circle 的）
        Shape[] shapes = {new Circle(1), new Rect(3, 4)};
        for (Shape sh : shapes) sh.desc();   // 接口 default 方法
    }
}

public class Exc {
    static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) throw new ArithmeticException("除零");
        return a / b;
    }

    public static void main(String[] args) {
        try {
            System.out.println(divide(10, 0));
        } catch (ArithmeticException e) {
            System.err.println("出错：" + e.getMessage());  // 出错：除零
        } finally {
            System.out.println("无论成败都会执行");
        }

        // 多个 catch 从具体到宽泛
        try {
            int[] x = {1};
            System.out.println(x[9]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("越界");
        } catch (Exception e) {
            System.out.println("其他异常");
        }

        // 自定义异常
        try {
            throw new MyException("我的错");
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }
    }
}
class MyException extends Exception {
    public MyException(String m) { super(m); }
}

import java.util.*;

public class Coll {
    public static void main(String[] args) {
        // List：有序、可重复
        List<String> list = new ArrayList<>();
        list.add("a"); list.add("b"); list.add("a");
        System.out.println(list.get(0));      // a
        list.remove("a");                      // 删除第一个 "a"

        // Set：自动去重
        Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 2, 3));
        System.out.println(set.size());        // 3（重复被去掉）

        // Map：键值对
        Map<String, Integer> map = new HashMap<>();
        map.put("alice", 90);
        map.put("bob", 80);
        System.out.println(map.get("alice"));  // 90
        for (var e : map.entrySet()) {
            System.out.println(e.getKey() + " -> " + e.getValue());
        }
    }
}

public class Box<T> {        // 泛型类，T 是类型参数
    private T v;
    public void set(T v) { this.v = v; }
    public T get() { return v; }

    // 泛型方法
    public static <E> E pick(E a, E b) { return a; }

    public static void main(String[] args) {
        Box<String> b = new Box<>();
        b.set("hi");
        String s = b.get();    // 无需强转，编译期保证是 String
        System.out.println(s);
        System.out.println(pick(1, 2));   // 1
    }
}

import java.util.*;
import java.util.stream.*;

public class Streams {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6);

        // 过滤偶数并求平方和
        int sum = nums.stream()
                      .filter(n -> n % 2 == 0)   // 偶数
                      .mapToInt(n -> n * n)        // 平方
                      .sum();                      // 4 + 16 + 36 = 56
        System.out.println(sum);

        // 收集成新列表
        List<Integer> evens = nums.stream()
                                  .filter(n -> n % 2 == 0)
                                  .collect(Collectors.toList());
        System.out.println(evens);   // [2, 4, 6]

        // Lambda 简化 Runnable
        new Thread(() -> System.out.println("hello thread")).start();
    }
}

public class Count {
    static int n = 0;
    static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                synchronized (lock) { n++; }   // 加锁，保证原子性
            }
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();                 // 等两个线程结束
        System.out.println(n);                // 期望 2000
    }
}

import java.util.*;

public class Wrap {
    public static void main(String[] args) {
        Integer a = 127, b = 127;
        System.out.println(a == b);          // true（命中缓存区）

        Integer c = 128, d = 128;
        System.out.println(c == d);          // false（超出缓存，新对象）

        // 正确比内容用 equals
        System.out.println(c.equals(d));     // true

        List<Integer> list = new ArrayList<>();
        list.add(5);                         // 自动装箱 int -> Integer
        int x = list.get(0);                 // 自动拆箱 Integer -> int
        System.out.println(x);
    }
}

import java.nio.file.*;
import java.io.*;

public class Io {
    public static void main(String[] args) {
        // 写文件（一行搞定）
        try {
            Files.writeString(Path.of("a.txt"), "你好Java");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 读文件并自动关闭流
        try (BufferedReader br = Files.newBufferedReader(Path.of("a.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {            // 离开 try 块自动关 br
            e.printStackTrace();
        }
    }
}

// 栈溢出示例：无限递归
void rec() { rec(); }   // StackOverflowError
// 堆溢出示例：疯狂创建对象
List<byte[]> list = new ArrayList<>();
while (true) list.add(new byte[1024 * 1024]); // OutOfMemoryError: Java heap space

String a = "abc";
String b = "abc";
System.out.println(a == b);          // true（常量池同一对象）
String c = new String("abc");
System.out.println(a == c);          // false（堆里新对象）
System.out.println(a == c.intern()); // true（intern 返回池里引用）

// 反例：循环里反复装箱，产生大量 Integer 对象
Integer sum = 0;
for (int i = 0; i < 1_000_000; i++) sum += i;  // 每次都 new Integer
// 正例：用基本类型累加
int sum2 = 0;
for (int i = 0; i < 1_000_000; i++) sum2 += i;

class Node<T> {
    public void set(T t) {}
}
class IntNode extends Node<Integer> {
    @Override public void set(Integer t) {}   // 你写的
    // 编译器还会合成：public void set(Object t){ set((Integer)t); }  // 桥接方法
}

// 双重检查单例：volatile 防止指令重排序导致拿到"半初始化"对象
class Singleton {
    private static volatile Singleton instance;
    static Singleton get() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) instance = new Singleton();
            }
        }
        return instance;
    }
}

// 危险：并行流里改共享的非线程安全集合
List<Integer> out = new ArrayList<>();
IntStream.range(0, 1000).parallel().forEach(i -> out.add(i)); // 可能丢数据/报错
// 正确：用 collect 收拢结果
List<Integer> ok = IntStream.range(0,1000).parallel()
                            .boxed().collect(Collectors.toList());

// 多个资源可一行声明，按声明逆序关闭
try (FileInputStream in = new FileInputStream("a.txt");
     FileOutputStream out = new FileOutputStream("b.txt")) {
    // ...
} // in、out 都会自动关闭

Optional<User> u = findUser(id);
// 正确：链式，避免 isPresent/get
String name = u.map(User::getName).orElse("匿名");
// 错误：把它当 if 用，等于没用 Optional
if (u.isPresent()) { String n = u.get().getName(); }

// module-info.java 示例
module com.example.app {
    requires java.sql;
    exports com.example.app.api;   // 只导出 api 包，其余包对外不可见
}

class Student {
    private final String name;
    private final double score;

    public Student(String name, double score) {
        if (score < 0 || score > 100) {
            throw new IllegalArgumentException("分数必须在 0~100：" + score);
        }
        this.name = name;
        this.score = score;
    }
    public String getName() { return name; }
    public double getScore() { return score; }

    @Override
    public String toString() {
        return name + " : " + score;
    }
}

import java.util.*;

public class GradeApp {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("小明", 88));
        students.add(new Student("小红", 95));
        students.add(new Student("小刚", 72));

        // 平均分
        double avg = students.stream()
                             .mapToDouble(Student::getScore)
                             .average()
                             .orElse(0);
        System.out.printf("平均分=%.2f%n", avg);

        // 最高分（Optional 兜底）
        students.stream()
                .max(Comparator.comparingDouble(Student::getScore))
                .ifPresent(top -> System.out.println("最高分：" + top));
    }
}

List<Student> sorted = new ArrayList<>(students);
sorted.sort(Comparator.comparingDouble(Student::getScore).reversed());
sorted.forEach(System.out::println);
// 输出：小红 : 95  小明 : 88  小刚 : 72

import java.nio.file.*;

public class Exporter {
    public static void export(List<Student> list, String path) {
        try {
            List<String> lines = new ArrayList<>();
            lines.add("姓名,分数");
            for (Student s : list) {
                lines.add(s.getName() + "," + s.getScore());
            }
            Files.write(Path.of(path), lines);   // 自动创建/覆盖文件
            System.out.println("已导出到 " + path);
        } catch (java.io.IOException e) {
            System.err.println("导出失败：" + e.getMessage());
        }
    }
}

import java.time.*;
import java.time.format.*;

public class TimeDemo {
    public static void main(String[] args) {
        LocalDate d = LocalDate.now();           // 年月日
        LocalTime t = LocalTime.now();           // 时分秒
        LocalDateTime dt = LocalDateTime.now();   // 两者合一
        System.out.println(d + " " + t);

        // 构造与加减
        LocalDate birth = LocalDate.of(2000, 1, 1);
        LocalDate later = birth.plusDays(10).plusMonths(2);
        System.out.println(later);               // 2000-03-12

        // 计算间隔
        Period p = Period.between(birth, LocalDate.now());
        System.out.println("相差 " + p.getYears() + " 年 " + p.getMonths() + " 月");

        Duration dur = Duration.between(LocalTime.of(8,0), LocalTime.of(9,30));
        System.out.println("时长 " + dur.toMinutes() + " 分钟");

        // 解析与格式化
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy/MM/dd");
        System.out.println(dt.format(fmt));
        LocalDate parsed = LocalDate.parse("2026/08/12", fmt);
        System.out.println(parsed);
    }
}

enum Status {
    PENDING(0, "待处理"),
    RUNNING(1, "进行中"),
    DONE(2, "完成");

    private final int code;
    private final String label;
    Status(int code, String label) { this.code = code; this.label = label; }
    public int code() { return code; }
    public String label() { return label; }
}

public class EnumDemo {
    public static void main(String[] args) {
        Status s = Status.RUNNING;
        System.out.println(s.label());          // 进行中
        System.out.println(s.code());           // 1
        for (Status v : Status.values()) {      // 遍历所有枚举
            System.out.println(v);
        }
        Status byName = Status.valueOf("DONE"); // 按名取
        System.out.println(byName.label());
    }
}

String s = "  Hello Java  ";
System.out.println(s.trim());            // "Hello Java"（去首尾空格）
System.out.println(s.strip());           // 同 trim，但认 Unicode 空白
System.out.println("a,b,c".split(",").length); // 3（拆分）
System.out.println(String.join("-", "a","b","c")); // a-b-c（拼接）
System.out.println("Java".repeat(2));    // JavaJava（Java 11+）

System.out.println(Math.max(3, 7));      // 7
System.out.println(Math.round(3.6));     // 4（四舍五入）
System.out.println(Math.abs(-5));        // 5
System.out.println(Math.pow(2, 10));     // 1024.0
System.out.println(Math.sqrt(16));       // 4.0
// 推荐用 ThreadLocalRandom（并发安全、更快）
int r = java.util.concurrent.ThreadLocalRandom.current().nextInt(1, 101); // 1~100

import java.util.*;

List<Integer> list = Arrays.asList(3, 1, 2);
Collections.sort(list);                  // 原地升序：[1,2,3]
Collections.reverse(list);               // 反转
Collections.shuffle(list);               // 随机打乱
System.out.println(Collections.max(list));   // 最大值
System.out.println(Collections.frequency(list, 1)); // 某元素出现次数

// 不可变集合（Java 9+）
List<String> fixed = List.of("a", "b");
Map<String,Integer> m = Map.of("x", 1, "y", 2);

import java.nio.file.*;
import java.io.*;

// 读全部行
List<String> lines = Files.readAllLines(Path.of("a.txt"));
// 写字符串
Files.writeString(Path.of("b.txt"), "内容");
// 判断是否存在
boolean exists = Files.exists(Path.of("a.txt"));
// 创建/删除
Files.createDirectories(Path.of("dir/sub"));
Files.deleteIfExists(Path.of("b.txt"));

int n = Integer.parseInt("123");        // String -> int
double d = Double.parseDouble("3.14");  // String -> double
String s = String.valueOf(456);         // 任意 -> String
String hex = Integer.toHexString(255);  // "ff"（转进制）

static int binarySearch(int[] a, int target) {
    int lo = 0, hi = a.length - 1;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;   // 防溢出写法
        if (a[mid] == target) return mid;
        else if (a[mid] < target) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

static void reverse(int[] a) {
    for (int i = 0, j = a.length - 1; i < j; i++, j--) {
        int t = a[i]; a[i] = a[j]; a[j] = t;
    }
}

static boolean isPalindrome(String s) {
    int i = 0, j = s.length() - 1;
    while (i < j) {
        if (s.charAt(i++) != s.charAt(j--)) return false;
    }
    return true;
}

static int maxSubArray(int[] a) {
    int best = a[0], cur = a[0];
    for (int i = 1; i < a.length; i++) {
        cur = Math.max(a[i], cur + a[i]);  // 要么接上，要么从头开始
        best = Math.max(best, cur);
    }
    return best;
}

// record：自动生成字段、构造器、getter、equals、hashCode、toString
record Point(int x, int y) {}
Point p = new Point(1, 2);
System.out.println(p.x() + "," + p.y());   // 1,2

// 文本块：多行字符串不用拼 \n
String json = """
    {
      "name": "小明",
      "age": 18
    }
    """;
System.out.println(json);

// 模式匹配 instanceof
Object o = "hi";
if (o instanceof String s) {        // 命中后 s 直接用，无需强转
    System.out.println(s.length());
}

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "s" is null
    at com.demo.App.main(App.java:12)   <-- 看这里，App.java 第 12 行

// 临时调试（提交前删掉）
System.out.println("debug: user=" + user + " step=" + step);

// 正经日志（SLF4J 风格，生产用）
log.info("处理用户 {} 在第 {} 步", userId, step);

enum Config {           // 枚举单例：线程安全、防反射
    INSTANCE;
    public void load() { System.out.println("加载配置"); }
}
// 使用：Config.INSTANCE.load();

interface Shape { void draw(); }
class Circle implements Shape { public void draw(){ System.out.println("画圆"); } }
class Square implements Shape { public void draw(){ System.out.println("画方"); } }

class ShapeFactory {
    static Shape create(String type) {
        return switch (type) {
            case "circle" -> new Circle();
            case "square" -> new Square();
            default -> throw new IllegalArgumentException(type);
        };
    }
}
// 使用：Shape s = ShapeFactory.create("circle");

interface Discount { double apply(double price); }
class NoDiscount implements Discount { public double apply(double p){ return p; } }
class HalfDiscount implements Discount { public double apply(double p){ return p/2; } }

class Checkout {
    Discount strategy;
    Checkout(Discount d){ this.strategy = d; }
    double pay(double price){ return strategy.apply(price); }
}
// 使用：new Checkout(new HalfDiscount()).pay(100); // 50

import java.util.*;

interface Listener { void onEvent(String msg); }
class Publisher {
    private final List<Listener> ls = new ArrayList<>();
    void subscribe(Listener l){ ls.add(l); }
    void publish(String msg){ ls.forEach(l -> l.onEvent(msg)); }
}
// 使用：p.subscribe(m -> System.out.println("收到：" + m));

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class CalcTest {
    @Test
    void add_正数相加_返回和() {
        assertEquals(5, 2 + 3);            // 期望 5
        assertTrue(10 > 0);
        assertThrows(ArithmeticException.class,
            () -> { int x = 1 / 0; });     // 期望抛异常
    }
}