Java 速查表

所有開發工具

免費

可搜尋、可列印的 Java 參考：型別、字串、集合、串流、record、模式比對、並行與檔案 I/O。免費。

Basics & types

var list = new ArrayList<String>();

Local variable type inference

int x = 42; double d = 3.14;

Primitive declarations

long big = 9_000_000_000L;

Digit separators + long literal

char c = 'A'; boolean ok = true;

Char and boolean primitives

final int MAX = 100;

Constant (cannot be reassigned)

int i = (int) 3.99;

Explicit narrowing cast (→ 3)

double d = x;

Implicit widening conversion

int n = Integer.parseInt("42");

String → int

String s = String.valueOf(42);

Number → string

Integer boxed = 42; int y = boxed;

Auto-boxing and unboxing

Strings & text blocks

s.length(); s.charAt(0);

Length and character access

s.substring(1, 3)

Slice (end index exclusive)

s.contains("x"); s.startsWith("a");

Search checks

s.replace("a", "b")

Replace all occurrences

s.strip()

Trim whitespace (Unicode-aware)

s.split(",")

Split into a String[]

String.join(", ", parts)

Join with a separator

"ab".repeat(3)

Repeat a string ("ababab")

s.isBlank(); s.isEmpty();

Whitespace-only / zero-length

"%s: %d".formatted(key, count)

Inline printf-style formatting

String html = """\n <p>Hi</p>\n """;

Multi-line text block

new StringBuilder().append(a).append(b)

Efficient string building in loops

Collections

List<String> l = List.of("a", "b");

Immutable list factory

Map<String, Integer> m = Map.of("a", 1);

Immutable map factory

Set<Integer> s = Set.of(1, 2, 3);

Immutable set factory

new ArrayList<>(List.of("a", "b"))

Mutable copy of a list

List.copyOf(list)

Immutable defensive copy

map.getOrDefault(key, 0)

Read with a fallback value

map.computeIfAbsent(k, x -> new ArrayList<>())

Lazily create grouped values

map.merge(key, 1, Integer::sum)

Increment a counter map

list.removeIf(s -> s.isBlank())

Bulk remove matching items

list.sort(Comparator.naturalOrder())

Sort a list in place

for (var e : map.entrySet())

Iterate map entries

list.forEach(System.out::println)

Iterate with a method reference

Streams & lambdas

list.stream().map(String::toUpperCase).toList()

Transform every element

.filter(n -> n > 0)

Keep matching elements

.sorted(Comparator.comparing(User::name))

Sort by a key extractor

.distinct().limit(10).skip(5)

Dedupe and paginate a stream

.collect(Collectors.groupingBy(User::city))

Group into Map<K, List<V>>

.collect(Collectors.joining(", "))

Join strings with a separator

.collect(Collectors.toMap(User::id, u -> u))

Build a map from a stream

.flatMap(List::stream)

Flatten nested collections

.mapToInt(Order::total).sum()

Numeric stream aggregation

.reduce(0, Integer::sum)

Fold to a single value

.anyMatch(s -> s.isBlank())

anyMatch / allMatch / noneMatch

IntStream.range(0, 10)

Stream of ints 0..9

Records & sealed classes

record Point(int x, int y) {}

Immutable data carrier

var p = new Point(1, 2); p.x();

Construct + generated accessors

equals(), hashCode(), toString()

Generated for free on records

record Range(int lo, int hi) { Range { if (lo > hi) throw new IllegalArgumentException(); } }

Compact constructor validation

record Point(...) implements Shape {}

Records can implement interfaces

static Point origin() { return new Point(0, 0); }

Static factory inside a record

sealed interface Shape permits Circle, Square {}

Restrict allowed subtypes

final class Circle implements Shape {}

Permitted type must be final...

non-sealed class Square implements Shape {}

...or sealed / non-sealed

Pattern matching & switch

if (obj instanceof String s) use(s);

instanceof pattern binds a var

int n = switch (day) { case MON -> 1; default -> 0; };

Switch as an expression

case MON, TUE -> "early week";

Multiple labels per arm

case X -> { ...; yield value; }

Block arm returns via yield

case String s when s.length() > 2 ->

Guarded pattern (when clause)

case Point(int x, int y) -> x + y;

Record pattern deconstruction

case null, default -> "none";

Handle null inside the switch

switch (shape) { case Circle c -> ... }

Exhaustive over sealed types

OOP essentials

interface Greeter { default String hi() { return "hi"; } }

Interface with default method

class Impl implements A, B {}

Implement multiple interfaces

class Admin extends User {}

Single-class inheritance

@Override public String toString()

Mark overridden methods

super.method(); super(args);

Call parent method / constructor

class Box<T> { T value; }

Generic class

<T extends Comparable<T>> T max(...)

Bounded type parameter

List<? extends Number> nums

Covariant wildcard

enum Status { ACTIVE, DONE }

Enum type (can hold methods)

abstract class Base { abstract void run(); }

Abstract class + method

public static User of(String n) { ... }

Static factory method idiom

Optional

Optional.of(v); Optional.empty();

Create (of throws on null)

Optional.ofNullable(maybeNull)

Wrap a possibly-null value

opt.isPresent(); opt.isEmpty();

Presence checks

opt.orElse(defaultValue)

Fallback value

opt.orElseGet(() -> compute())

Lazy fallback (only if empty)

opt.orElseThrow()

Get or throw NoSuchElement

opt.map(User::name).filter(n -> !n.isBlank())

Chain transformations safely

opt.ifPresent(v -> use(v))

Run only when present

opt.ifPresentOrElse(use, this::warn)

Branch on both cases

opt.get()

Avoid: prefer orElseThrow()

Exceptions & try-with-resources

try { ... } catch (IOException e) { ... }

Catch a checked exception

catch (IOException | SQLException e)

Multi-catch in one block

finally { cleanup(); }

Always runs (even on throw)

try (var in = Files.newBufferedReader(p)) { ... }

Auto-close resources

throw new IllegalArgumentException("bad id");

Throw with a message

class AppException extends RuntimeException {}

Custom unchecked exception

RuntimeException vs Exception

Unchecked vs checked (declared)

e.getMessage(); e.getCause();

Inspect an exception

Objects.requireNonNull(x, "x is required")

Fail fast on null arguments

Concurrency

Thread.startVirtualThread(() -> work());

Cheap virtual thread (21+)

Executors.newVirtualThreadPerTaskExecutor()

One virtual thread per task

var pool = Executors.newFixedThreadPool(4);

Bounded platform thread pool

Future<T> f = pool.submit(task); f.get();

Submit and await a result

CompletableFuture.supplyAsync(() -> fetch())

Async computation

.thenApply(r -> parse(r))

Transform the async result

.thenCombine(other, (a, b) -> a + b)

Join two futures

.exceptionally(e -> fallback)

Recover from async failure

CompletableFuture.allOf(f1, f2).join();

Wait for all to finish

new AtomicInteger().incrementAndGet()

Lock-free counter

new ConcurrentHashMap<K, V>()

Thread-safe map

synchronized (lock) { ... }

Mutual exclusion block

I/O & files (java.nio)

Path p = Path.of("data", "file.txt");

Build a platform-safe path

String s = Files.readString(p);

Read a whole file as text

Files.writeString(p, text);

Write text (creates/truncates)

List<String> lines = Files.readAllLines(p);

Read all lines

try (var st = Files.lines(p)) { ... }

Stream lines lazily

Files.exists(p); Files.size(p);

Existence and size checks

Files.createDirectories(dir);

mkdir -p equivalent

Files.copy(src, dst); Files.move(src, dst);

Copy / move files

Files.deleteIfExists(p);

Delete without throwing

try (var files = Files.list(dir)) { ... }

List directory entries

Files.walk(dir)

Recursive directory stream

Files.createTempFile("up-", ".tmp")

Temporary file

Build & CLI

javac Main.java && java Main

Compile then run

java Main.java

Run a source file directly

java -jar app.jar

Run an executable jar

java -Xmx512m -jar app.jar

Cap the max heap size

jshell

Interactive Java REPL

mvn clean package

Maven: build the artifact

mvn test

Maven: run the test suite

mvn dependency:tree

Maven: inspect dependencies

./gradlew build

Gradle: full build via wrapper

./gradlew test --tests "UserTest"

Gradle: run selected tests

jar tf app.jar

List a jar's contents

java --version

Show the JDK version

沒有條目符合「:q」。

關於 Java 速查表

這份 Java 速查表把現代 Java 濃縮成一個可搜尋的頁面：基礎與型別、字串與文字區塊、集合、串流與 lambda、record 與 sealed class、模式比對與 switch、物件導向要點、Optional、例外與 try-with-resources、並行、使用 java.nio 的檔案 I/O，以及建置與命令列指令。

它同時涵蓋您每天都會寫的基礎（List、HashMap、for-each 迴圈、try-with-resources 區塊），以及改變 Java 讀起來樣貌的新語言功能，包括 record、sealed 型別、搭配模式比對的 switch 運算式與文字區塊。

此速查表免費且在用戶端執行：用搜尋框即時篩選列、用固定的目錄在各段落間跳轉、一鍵複製任何程式碼片段，並可列印頁面放在鍵盤旁參考。

如何使用 Java 速查表

瀏覽各段落，從「基礎與型別」、「集合」到「並行」，再到「建置與命令列」。
搜尋 stream、record 或 Optional 等關鍵字，即時篩選每一列。
需要現代語法時，跳到「模式比對與 switch」或「串流與 lambda」。
點選程式碼片段或其複製圖示，即可將 Java 程式碼複製到剪貼簿。
列印速查表，取得離線的 Java 參考。

常見問題

共十二個段落：基礎與型別、字串與文字區塊、集合、串流與 lambda、record 與 sealed class、模式比對與 switch、物件導向要點、Optional、例外與 try-with-resources、並行、java.nio 檔案 I/O，以及建置與命令列指令。

涵蓋。record、sealed class、文字區塊、var、增強的 switch 運算式與模式比對，都與傳統語法並列，各自有獨立的列。

它是圍繞您實際會寫的內容而建：List、Set、Map 與 Deque 的建立與迭代，以及 map、filter、collect、groupingBy、reduce 和常用的 collector。

可以。點選任一程式碼片段或滑過時出現的複製圖示，就會複製到剪貼簿，並顯示簡短確認。

是的，完全免費：可搜尋、可列印，在瀏覽器中呈現，無需註冊。

Java 速查表

Basics & types

Strings & text blocks

Collections

Streams & lambdas

Records & sealed classes

Pattern matching & switch

OOP essentials

Optional

Exceptions & try-with-resources

Concurrency

I/O & files (java.nio)

Build & CLI

關於 Java 速查表

如何使用 Java 速查表

常見問題

Java 速查表包含哪些內容？

它涵蓋現代 Java 的功能嗎？

集合與串流段落實用嗎？

可以一鍵複製程式碼嗎？

Java 參考免費嗎？

相關工具

熱門搜尋

嵌入此工具