Java 速查表

所有工具

免费

可搜索、可打印的 Java 参考——类型、字符串、集合、streams、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 压缩到一个可搜索的页面上：基础知识和类型、字符串和文本块、集合、Stream 和 Lambda、Record 和 Sealed 类、模式匹配和 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”或“Stream 和 Lambda”。
点击代码片段或其复制图标，将 Java 代码复制到剪贴板。
打印本速查表获取离线 Java 参考。

常见问题

十二个章节：基础知识和类型、字符串和文本块、集合、Stream 和 Lambda、Record 和 Sealed 类、模式匹配和 Switch、面向对象要点、Optional、异常和 try-with-resources、并发、java.nio 文件 I/O，以及构建和命令行工具。

是的。Record、Sealed 类、文本块、var、增强的 Switch 表达式和模式匹配各有专门的行，与经典语法并列展示。

它围绕你实际编写的代码构建：List、Set、Map 和 Deque 的创建与遍历，然后是 map、filter、collect、groupingBy、reduce 和常用的收集器。

可以。点击任何代码片段或其悬停复制图标，即可复制到剪贴板并显示简短确认。

是的，完全免费——可搜索、可打印，在浏览器中渲染，无需注册。

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 特性吗？

集合和 Stream 部分实用吗？

可以一键复制代码吗？

Java 参考是免费的吗？

相关工具

热门搜索

嵌入此工具