1
2
3
4
5
6
7
Animal animal = new Dog(); // 向上转型
animal.run();

if (animal instanceof Dog) {
    Dog dog = (Dog) animal; // 向下转型
    dog.swim();
}

1
2
3
4
5
6
7
8
list.add(index, element);
list.addAll(index, collection);
list.get(index);
list.set(index, element);
list.remove(index);
list.indexOf(element);
list.lastIndexOf(element);
list.subList(fromIndex, toIndex); // 左闭右开

1
2
3
4
5
6
7
8
9
10
11
12
for (String value : list) {
    System.out.println(value);
}

for (int index = 0; index < list.size(); index++) {
    System.out.println(list.get(index));
}

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

1
2
3
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

1
2
3
4
5
6
7
8
9
10
11
public class Box<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

1
2
3
4
5
6
7
8
9
10
public interface Converter<S, T> {
    T convert(S source);
}

public class StringToInteger implements Converter<String, Integer> {
    @Override
    public Integer convert(String source) {
        return Integer.valueOf(source);
    }
}

1
2
3
public static <T> T first(List<T> values) {
    return values.get(0);
}

1
2
3
4
5
Class<String> first = String.class;
Class<?> second = Class.forName("java.lang.String");
Class<? extends String> third = "hello".getClass();

System.out.println(first == second); // true

1
2
3
4
5
Class<User> type = User.class;

Constructor<User> constructor = type.getDeclaredConstructor();
Field field = type.getDeclaredField("name");
Method method = type.getDeclaredMethod("setName", String.class);

1
2
3
4
5
6
7
8
9
10
11
12
13
Class<User> type = User.class;

Constructor<User> constructor = type.getDeclaredConstructor();
constructor.setAccessible(true);
User user = constructor.newInstance();

Field nameField = type.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(user, "Alice");

Method sayHello = type.getDeclaredMethod("sayHello", String.class);
sayHello.setAccessible(true);
Object result = sayHello.invoke(user, "Java");

1
2
3
4
5
6
7
8
class DownloadThread extends Thread {
    @Override
    public void run() {
        System.out.println("download");
    }
}

new DownloadThread().start();

1
2
3
4
5
6
7
8
9
class DownloadTask implements Runnable {
    @Override
    public void run() {
        System.out.println("download");
    }
}

Thread thread = new Thread(new DownloadTask());
thread.start();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class SellTicketTask implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (tickets <= 0) {
                    break;
                }

                System.out.println(
                    Thread.currentThread().getName() + " 卖出第 " + tickets + " 张票"
                );
                tickets--;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Worker implements Runnable {
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    @Override
    public void run() {
        while (running && !Thread.currentThread().isInterrupted()) {
            // 执行任务
        }
    }
}

1
2
3
4
5
6
7
8
9
10
private final Lock lock = new ReentrantLock();

public void update() {
    lock.lock();
    try {
        // 修改共享数据
    } finally {
        lock.unlock();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
String url = "jdbc:mysql://localhost:3306/app"
    + "?useUnicode=true&characterEncoding=utf8"
    + "&serverTimezone=Asia/Shanghai";

try (
    Connection connection = DriverManager.getConnection(
        url,
        System.getenv("DB_USERNAME"),
        System.getenv("DB_PASSWORD")
    );
    PreparedStatement statement = connection.prepareStatement(
        "select id, name, email from user where id = ?"
    )
) {
    statement.setLong(1, 1L);

    try (ResultSet resultSet = statement.executeQuery()) {
        while (resultSet.next()) {
            long id = resultSet.getLong("id");
            String name = resultSet.getString("name");
            String email = resultSet.getString("email");
            System.out.println(id + ", " + name + ", " + email);
        }
    }
}

1
2
3
4
5
6
7
8
9
String sql = "insert into user(name, email) values (?, ?)";

try (PreparedStatement statement = connection.prepareStatement(sql)) {
    statement.setString(1, "Alice");
    statement.setString(2, "[email protected]");

    int affectedRows = statement.executeUpdate();
    System.out.println("affected rows: " + affectedRows);
}

1
2
3
4
5
6
7
8
9
10
11
12
public final class JdbcUtils {
    private static final String URL = System.getenv("DB_URL");
    private static final String USERNAME = System.getenv("DB_USERNAME");
    private static final String PASSWORD = System.getenv("DB_PASSWORD");

    private JdbcUtils() {
    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USERNAME, PASSWORD);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Connection connection = null;

try {
    connection = dataSource.getConnection();
    connection.setAutoCommit(false);

    updateAccount(connection, fromAccount, -amount);
    updateAccount(connection, toAccount, amount);

    connection.commit();
} catch (Exception exception) {
    if (connection != null) {
        connection.rollback();
    }
    throw exception;
} finally {
    if (connection != null) {
        connection.setAutoCommit(true);
        connection.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
String sql = "insert into user(name, email) values (?, ?)";

try (PreparedStatement statement = connection.prepareStatement(sql)) {
    for (int index = 0; index < users.size(); index++) {
        User user = users.get(index);
        statement.setString(1, user.getName());
        statement.setString(2, user.getEmail());
        statement.addBatch();

        if ((index + 1) % 500 == 0) {
            statement.executeBatch();
            statement.clearBatch();
        }
    }

    statement.executeBatch();
}

1
2
3
4
5
6
try (
    Connection connection = dataSource.getConnection();
    PreparedStatement statement = connection.prepareStatement(sql)
) {
    // 执行数据库操作
}

1
2
3
4
5
6
7
QueryRunner queryRunner = new QueryRunner(dataSource);

User user = queryRunner.query(
    "select id, name, email from user where id = ?",
    new BeanHandler<>(User.class),
    1L
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public abstract class BaseDao {
    private final QueryRunner queryRunner = new QueryRunner();

    protected int update(Connection connection, String sql, Object... args)
        throws SQLException {
        return queryRunner.update(connection, sql, args);
    }

    protected <T> T queryOne(
        Connection connection,
        Class<T> type,
        String sql,
        Object... args
    ) throws SQLException {
        return queryRunner.query(
            connection,
            sql,
            new BeanHandler<>(type),
            args
        );
    }

    protected <T> List<T> queryList(
        Connection connection,
        Class<T> type,
        String sql,
        Object... args
    ) throws SQLException {
        return queryRunner.query(
            connection,
            sql,
            new BeanListHandler<>(type),
            args
        );
    }

    protected <T> T queryScalar(
        Connection connection,
        String sql,
        Object... args
    ) throws SQLException {
        ScalarHandler<T> handler = new ScalarHandler<>();
        return queryRunner.query(connection, sql, handler, args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
private static final ThreadLocal<Connection> CONNECTION_HOLDER =
    new ThreadLocal<>();

public static Connection currentConnection() throws SQLException {
    Connection connection = CONNECTION_HOLDER.get();
    if (connection == null) {
        connection = dataSource.getConnection();
        CONNECTION_HOLDER.set(connection);
    }
    return connection;
}

1
2
3
4
5
6
try {
    CONTEXT.set(context);
    handleRequest();
} finally {
    CONTEXT.remove();
}

1
2
3
4
5
6
7
8
String username = "java_user";
boolean validUsername = username.matches("[A-Za-z][A-Za-z0-9_]{2,15}");

String number = "-12.50";
boolean validNumber = number.matches("-?\\d+(\\.\\d+)?");

String chineseText = "学习Java";
boolean containsChinese = chineseText.matches(".*[\\u4e00-\\u9fa5].*");

1
2
3
4
5
6
Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher("订单 101，总价 299");

while (matcher.find()) {
    System.out.println(matcher.group());
}

1
2
3
4
text.matches(regex);
text.replaceAll(regex, replacement);
text.replaceFirst(regex, replacement);
text.split(regex);

1
2
Integer value = 10; // 装箱
int number = value; // 拆箱

1
2
3
4
5
6
7
8
9
10
11
12
text.length();
text.charAt(index);
text.substring(begin, end);
text.contains(keyword);
text.startsWith(prefix);
text.endsWith(suffix);
text.indexOf(keyword);
text.replace(oldValue, newValue);
text.trim();
text.toUpperCase();
text.toLowerCase();
text.split(regex);

1
2
3
4
5
String result = new StringBuilder()
    .append("Java")
    .append(" ")
    .append("SE")
    .toString();

1
2
3
4
5
6
7
8
Math.abs(-10);
Math.ceil(3.2);
Math.floor(3.8);
Math.round(3.5);
Math.max(10, 20);
Math.min(10, 20);
Math.pow(2, 10);
Math.random();

1
2
3
4
5
6
Arrays.sort(values);
Arrays.toString(values);
Arrays.binarySearch(values, target);
Arrays.copyOf(values, newLength);
Arrays.equals(first, second);
Arrays.fill(values, defaultValue);

1
2
3
4
5
System.currentTimeMillis();
System.nanoTime();
System.arraycopy(source, 0, target, 0, length);
System.getProperty("java.version");
System.getenv("JAVA_HOME");

1
2
3
BigDecimal price = new BigDecimal("19.90");
BigDecimal count = new BigDecimal("3");
BigDecimal total = price.multiply(count);

1
2
3
4
5
6
7
8
9
10
LocalDate today = LocalDate.now();
LocalDateTime now = LocalDateTime.now();
Instant instant = Instant.now();

DateTimeFormatter formatter =
    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

String formatted = now.format(formatter);
LocalDateTime parsed =
    LocalDateTime.parse("2025-04-20 10:30:00", formatter);

1
2
3
4
5
InetAddress address = InetAddress.getByName("www.example.com");

System.out.println(address.getHostName());
System.out.println(address.getHostAddress());
System.out.println(address.isReachable(3000));

1
2
3
4
5
6
7
8
9
10
try (ServerSocket serverSocket = new ServerSocket(9000)) {
    try (
        Socket socket = serverSocket.accept();
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)
        )
    ) {
        System.out.println(reader.readLine());
    }
}

1
2
3
4
5
6
7
8
9
10
try (
    Socket socket = new Socket("127.0.0.1", 9000);
    BufferedWriter writer = new BufferedWriter(
        new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8)
    )
) {
    writer.write("hello");
    writer.newLine();
    writer.flush();
}

1
2
3
4
5
6
7
8
byte[] data = "hello".getBytes(StandardCharsets.UTF_8);
InetAddress target = InetAddress.getByName("127.0.0.1");
DatagramPacket packet =
    new DatagramPacket(data, data.length, target, 9001);

try (DatagramSocket socket = new DatagramSocket()) {
    socket.send(packet);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

try (DatagramSocket socket = new DatagramSocket(9001)) {
    socket.receive(packet);
    String message = new String(
        packet.getData(),
        packet.getOffset(),
        packet.getLength(),
        StandardCharsets.UTF_8
    );
    System.out.println(message);
}

1
2
3
4
5
6
7
File file = new File("data/example.txt");

System.out.println(file.getName());
System.out.println(file.getAbsolutePath());
System.out.println(file.exists());
System.out.println(file.isFile());
System.out.println(file.length());

1
2
3
4
5
file.createNewFile();
file.delete();

File directory = new File("data/archive");
directory.mkdirs();

1
2
3
4
5
Path path = Path.of("data", "example.txt");

Files.createDirectories(path.getParent());
Files.writeString(path, "hello", StandardCharsets.UTF_8);
String content = Files.readString(path, StandardCharsets.UTF_8);

1
2
3
4
5
try (Stream<Path> paths = Files.walk(Path.of("src"))) {
    paths.filter(Files::isRegularFile)
        .filter(path -> path.toString().endsWith(".java"))
        .forEach(System.out::println);
}

1
2
3
4
5
6
7
8
9
10
11
try (
    InputStream input = new FileInputStream("data/source.bin");
    OutputStream output = new FileOutputStream("data/target.bin")
) {
    byte[] buffer = new byte[8192];
    int length;

    while ((length = input.read(buffer)) != -1) {
        output.write(buffer, 0, length);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
try (
    Reader reader = new FileReader(
        "data/source.txt",
        StandardCharsets.UTF_8
    );
    Writer writer = new FileWriter(
        "data/target.txt",
        StandardCharsets.UTF_8
    )
) {
    char[] buffer = new char[4096];
    int length;

    while ((length = reader.read(buffer)) != -1) {
        writer.write(buffer, 0, length);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
try (
    BufferedReader reader = Files.newBufferedReader(
        Path.of("data", "source.txt"),
        StandardCharsets.UTF_8
    );
    BufferedWriter writer = Files.newBufferedWriter(
        Path.of("data", "target.txt"),
        StandardCharsets.UTF_8
    )
) {
    String line;
    while ((line = reader.readLine()) != null) {
        writer.write(line);
        writer.newLine();
    }
}

1
2
3
4
5
6
7
8
9
Reader reader = new InputStreamReader(
    inputStream,
    StandardCharsets.UTF_8
);

Writer writer = new OutputStreamWriter(
    outputStream,
    StandardCharsets.UTF_8
);

1
2
3
4
5
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
}

1
2
3
4
5
try (ObjectOutputStream output = new ObjectOutputStream(
    new FileOutputStream("data/user.bin")
)) {
    output.writeObject(user);
}

1
2
3
4
5
6
7
8
9
10
Properties properties = new Properties();

try (Reader reader = Files.newBufferedReader(
    Path.of("config", "app.properties"),
    StandardCharsets.UTF_8
)) {
    properties.load(reader);
}

String url = properties.getProperty("db.url");

1
2
3
4
5
6
7
try {
    execute();
} catch (IOException exception) {
    logger.error("读取失败", exception);
} finally {
    releaseResource();
}

1
2
3
try (InputStream input = Files.newInputStream(path)) {
    // 使用资源
}

1
2
3
public String read(Path path) throws IOException {
    return Files.readString(path);
}

1
2
3
4
5
6
7
8
9
public class BusinessException extends RuntimeException {
    public BusinessException(String message) {
        super(message);
    }

    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}

1
2
3
4
5
public enum OrderStatus {
    CREATED,
    PAID,
    CANCELLED
}

1
2
3
4
5
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Audit {
    String value() default "";
}

1
2
3
4
5
JButton button = new JButton("提交");

button.addActionListener(event -> {
    System.out.println("按钮被点击");
});