דף צ'יטים Java
מדריך Java הניתן לחיפוש ולהדפסה: טיפוסים, מחרוזות, אוספים, זרמים, רשומות, התאמת תבניות, מקביליות וקלט/פלט קבצים. חינם.
Basics & types
10var 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
12s.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
12List<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
12list.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
9record 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
8if (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
11interface 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
10Optional.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
9try { ... } 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
12Thread.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)
12Path 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
12javac 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 מודרנית לדף אחד הניתן לחיפוש: יסודות וטיפוסים, מחרוזות וגושי טקסט, אוספים, זרמים (streams) ולמבדות, רשומות ומחלקות אטומות (sealed), התאמת תבניות ו-switch, יסודות תכנות מונחה עצמים, Optional, חריגות ו-try-with-resources, מקביליות, קלט/פלט קבצים עם java.nio, ופקודות בנייה ושורת הפקודה.
הוא מכסה גם את היסודות שאתה כותב כל יום (List, HashMap, לולאת for-each, בלוק try-with-resources) וגם את תכונות השפה החדשות ששינו את הצורה שבה קוראים Java, כולל רשומות, טיפוסים אטומים, ביטויי switch עם התאמת תבניות וגושי טקסט.
הדף חינמי ופועל בצד הלקוח: סנן שורות בזמן אמת עם תיבת החיפוש, עבור בין סעיפים עם תוכן העניינים הדביק, העתק כל קטע קוד בלחיצה אחת והדפס את הדף לעיון לצד המקלדת שלך.
כיצד להשתמש ב-דף צ'יטים Java
- עבור בקצרה על הסעיפים, מיסודות וטיפוסים ואוספים ועד מקביליות ובנייה ושורת פקודה.
- חפש מילת מפתח כמו stream, record או Optional כדי לסנן כל שורה בזמן אמת.
- עבור להתאמת תבניות ו-switch או לזרמים ולמבדות כאשר אתה זקוק לתחביר המודרני.
- לחץ על קטע קוד או על סמל ההעתקה שלו כדי להעתיק את קוד ה-Java ללוח שלך.
- הדפס את הדף לעיון לא מקוון ב-Java.
שאלות נפוצות
שנים עשר סעיפים: יסודות וטיפוסים, מחרוזות וגושי טקסט, אוספים, זרמים ולמבדות, רשומות ומחלקות אטומות, התאמת תבניות ו-switch, יסודות תכנות מונחה עצמים, Optional, חריגות ו-try-with-resources, מקביליות, קלט/פלט קבצים עם java.nio, ופקודות בנייה ושורת הפקודה.
כן. רשומות, מחלקות אטומות, גושי טקסט, var, ביטויי switch משופרים והתאמת תבניות מקבלים כל אחד שורות משלו לצד התחביר הקלאסי.
הוא בנוי סביב מה שבאמת כותבים: יצירה ואיטרציה של List, Set, Map ו-Deque, ולאחר מכן map, filter, collect, groupingBy, reduce והאוספים (collectors) הנפוצים.
כן. לחץ על כל קטע קוד או על סמל ההעתקה שמופיע בריחוף, והוא נוחת בלוח שלך עם אישור קצר.
כן, לגמרי חינם: ניתן לחיפוש, להדפסה ומוצג בדפדפן שלך ללא הרשמה.
חיפושים פופולריים
דף צ'יטים java
מדריך תחביר java
דף צ'יטים collections ב-java
דוגמאות streams ב-java
records ו-sealed classes ב-java
switch pattern matching ב-java
יסודות מקביליות ב-java
צריך עזרה?
נתקלת בבעיה בכלי הזה? ספר לצוות שלנו.