标准库巡礼

var p = Path.of("src", "app", "main.py");
System.out.println(p);  // => src/app/main.py
System.out.println(p.getFileName());  // => main.py
System.out.println(p.getParent());    // => src/app

import kotlin.io.path.*

val p = Path("src") / "app" / "main.py"
println(p)            // => src/app/main.py
println(p.name)       // => main.py
println(p.extension)  // => py
println(p.parent)     // => src/app

var text = "2026-10-30";
var m = Pattern.compile("(\\d+)-(\\d+)")
    .matcher(text);
m.find();
System.out.println(m.group(1));  // => 2026
var r = text.replaceAll("-", "/");
System.out.println(r);  // => 2026/10/30

val text = "2026-10-30"
val m = Regex("""(\d+)-(\d+)""").find(text)
println(m?.groupValues?.get(1))  // => 2026
val all = Regex("""\d+""").findAll(text)
println(all.map { it.value }.toList())  // => [2026, 10, 30]
println(text.replace("-", "/"))  // => 2026/10/30

var client = HttpClient.newHttpClient();
var req = HttpRequest
    .newBuilder(URI.create("https://example.com"))
    .build();
var resp = client.send(req,
    HttpResponse.BodyHandlers.ofString());
System.out.println(resp.statusCode());  // => 200

import java.net.URI

val body = URI("https://example.com")
    .toURL().readText()

println("Example" in body)  // => true

var d = LocalDate.of(2026, 10, 30);
System.out.println(d.plusDays(7));  // => 2026-11-06
var fmt = DateTimeFormatter
    .ofPattern("yyyy/MM/dd");
System.out.println(d.format(fmt));  // => 2026/10/30

var end = LocalDate.of(2027, 1, 1);
var days = ChronoUnit.DAYS.between(d, end);
System.out.println(days);           // => 63

val d = LocalDate.of(2026, 10, 30)
println(d.plusDays(7))  // => 2026-11-06
val fmt = DateTimeFormatter
    .ofPattern("yyyy/MM/dd")
println(d.format(fmt))  // => 2026/10/30

val end = LocalDate.of(2027, 1, 1)
println(ChronoUnit.DAYS.between(d, end))  // => 63

var results = new ConcurrentLinkedQueue<Integer>();
var threads = new ArrayList<Thread>();

for (int i = 0; i < 3; i++) {
    int n = i;
    var t = new Thread(() -> results.add(n * n));
    t.start();
    threads.add(t);
}
for (var t : threads) {
    t.join();
}

var sorted = new TreeSet<>(results);
System.out.println(sorted);  // => [0, 1, 4]

import java.util.concurrent.ConcurrentLinkedQueue
import kotlin.concurrent.thread

val results = ConcurrentLinkedQueue<Int>()

val threads = (0 until 3).map { n ->
    thread { results.add(n * n) }
}
threads.forEach { it.join() }

println(results.sorted())  // => [0, 1, 4]

var pool = Executors.newFixedThreadPool(4);
var tasks = new ArrayList<Future<Integer>>();
for (int n : List.of(1, 2, 3)) {
    tasks.add(pool.submit(() -> n * n));
}
for (var task : tasks) {
    System.out.println(task.get());
}
pool.shutdown();

// 使用 kotlinx.coroutines
val results = runBlocking {
    listOf(1, 2, 3).map { n ->
        async(Dispatchers.Default) { n * n }
    }.awaitAll()
}
println(results)  // => [1, 4, 9]

static CompletableFuture<Integer> fetch(int n) {
    return CompletableFuture.supplyAsync(
        () -> n * n);
}

var tasks = List.of(fetch(1), fetch(2), fetch(3));
var results = tasks.stream()
    .map(CompletableFuture::join)
    .toList();
System.out.println(results);  // => [1, 4, 9]

// 使用 kotlinx.coroutines
suspend fun fetch(n: Int): Int {
    delay(10)
    return n * n
}

fun main() = runBlocking {
    val results = listOf(1, 2, 3)
        .map { async { fetch(it) } }
        .awaitAll()
    println(results)  // => [1, 4, 9]
}

private static final Logger log =
    LoggerFactory.getLogger(App.class);

log.info("端口 {}", 8080);
log.warn("磁盘快满了");

private val log =
    LoggerFactory.getLogger("App")

log.info("端口 {}", 8080)
log.warn("磁盘快满了")

var a = new BigDecimal("0.1");
var b = new BigDecimal("0.2");
System.out.println(a.add(b));  // => 0.3

var price = new BigDecimal("2.675")
    .setScale(2, RoundingMode.HALF_UP);
System.out.println(price);     // => 2.68

import java.math.RoundingMode

val a = "0.1".toBigDecimal()
val b = "0.2".toBigDecimal()
println(a + b)  // => 0.3

val price = "2.675".toBigDecimal()
    .setScale(2, RoundingMode.HALF_UP)
println(price)  // => 2.68

class MathTest {
    @Test
    void add() {
        assertEquals(2, 1 + 1);
    }

    @Test
    void zero() {
        assertThrows(ArithmeticException.class,
            () -> { int x = 1 / 0; });
    }
}

class MathTest {
    @Test
    fun add() {
        assertEquals(2, 1 + 1)
    }

    @Test
    fun zero() {
        assertFailsWith<ArithmeticException> {
            1 / 0
        }
    }
}