Java Cheat Sheet: דף עזר מהיר
עודכן לאחרונה
Hello World ומבנה התוכנית
כל תוכנית Java רצה ממתודת main שנמצאת בתוך מחלקה.
| רכיב | קוד |
|---|---|
| הצהרת מחלקה | public class Main { ... } |
| נקודת כניסה | public static void main(String[] args) { ... } |
| הדפסת שורה | System.out.println("Hello, World!"); |
| הדפסה בלי ירידת שורה | System.out.print("text"); |
| קריאת קלט | Scanner sc = new Scanner(System.in); |
| ייבוא מחלקה | import java.util.ArrayList; |
| הערות | // line ו-/* block */ |
טיפוסי נתונים
טיפוסים פרימיטיביים נכתבים באותיות קטנות; מחלקות העטיפה שלהם מתחילות באות גדולה.
| טיפוס | תיאור |
|---|---|
int | מספר שלם 32 ביט עם סימן |
long | מספר שלם 64 ביט עם סימן |
double / float | מספרים בנקודה צפה |
boolean | true או false |
char | תו Unicode יחיד של 16 ביט |
byte / short | מספרים שלמים של 8 / 16 ביט |
String | טקסט בלתי ניתן לשינוי (מחלקה, לא טיפוס פרימיטיבי) |
Integer, Double, Boolean | מחלקות עטיפה לטיפוסים פרימיטיביים |
var | טיפוס מקומי שמוסק אוטומטית (Java 10+) |
משתנים
| פעולה | תחביר |
|---|---|
| הצהרה ואתחול | int x = 5; |
| הסקת טיפוס (מקומי) | var name = "Ada"; |
| קבוע | final double PI = 3.14159; |
| שרשור מחרוזות | String s = "Hi " + name; |
| המרת מחרוזת ל-int | int n = Integer.parseInt("42"); |
| המרת int למחרוזת | String s = String.valueOf(42); |
| מחרוזת מעוצבת | String.format("%d items", n) |
אופרטורים
אופרטורים אריתמטיים, של השוואה, לוגיים ושל השמה.
| אופרטור | משמעות |
|---|---|
+ - * / % | חיבור, חיסור, כפל, חילוק, שארית |
++ -- | הגדלה / הקטנה ב-1 |
== != | שווה / לא שווה (השוואת הפניות עבור אובייקטים) |
> < >= <= | השוואות גדול / קטן |
&& || ! | AND, OR, NOT לוגיים (עם קיצור מעגל) |
& | ^ ~ | AND, OR, XOR, NOT ברמת הביט |
<< >> >>> | הזזה שמאלה, ימינה עם סימן, ימינה בלי סימן |
+= -= *= /= | השמה מורכבת |
? : | טרינרי: x > 0 ? "pos" : "neg" |
instanceof | בדיקת טיפוס: if (o instanceof String s) |
בקרת זרימה
| משפט | תחביר |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| משפט switch | switch (n) { case 1: ...; break; default: ...; } |
| ביטוי switch | var s = switch (n) { case 1 -> "one"; default -> "other"; }; |
| לולאת while | while (i < n) { ... } |
| לולאת do-while | do { ... } while (i < n); |
| לולאת for | for (int i = 0; i < n; i++) { ... } |
| for משופר (for-each) | for (String item : list) { ... } |
| Break / continue | break; יוצא מהלולאה, continue; מדלג לאיטרציה הבאה |
מתודות של String
String בלתי ניתן לשינוי: כל מתודה מחזירה מחרוזת חדשה. השתמשו ב-StringBuilder כשמשרשרים בתוך לולאה.
| מתודה | מה היא עושה |
|---|---|
s.length() | מספר התווים |
s.charAt(i) | התו באינדקס i |
s.substring(a, b) | חיתוך מ-a (כולל) עד b (לא כולל) |
s.indexOf("x") | האינדקס הראשון של תת-מחרוזת, או -1 |
s.contains("x") | true אם תת-המחרוזת קיימת |
s.replace("a", "b") | החלפת כל המופעים |
s.split(",") | פיצול למערך String[] |
s.trim() / s.strip() | הסרת רווחים בהתחלה ובסוף |
s.toUpperCase() / toLowerCase() | שינוי אותיות גדולות/קטנות |
s.equals(t) / equalsIgnoreCase(t) | השוואת ערכים (לא ==) |
s.startsWith("x") / endsWith("x") | בדיקת תחילית / סיומת |
String.join(",", list) | חיבור איברים עם מפריד |
Math וכלי עזר נפוצים
מתודות עזר סטטיות מתוך java.lang.Math ומחלקות העטיפה של המספרים.
| קריאה | תוצאה |
|---|---|
Math.max(a, b) / Math.min(a, b) | הגדול / הקטן מבין שני ערכים |
Math.abs(x) | ערך מוחלט |
Math.pow(x, y) | x בחזקת y (מחזיר double) |
Math.sqrt(x) | שורש ריבועי |
Math.round(x) / floor / ceil | עיגול לקרוב / למטה / למעלה |
Math.random() | double אקראי בטווח [0.0, 1.0) |
Integer.parseInt("42") | המרת מחרוזת ל-int |
Integer.MAX_VALUE / MIN_VALUE | ה-int הגדול / הקטן ביותר |
Arrays.sort(arr) | מיון מערך במקום |
Arrays.toString(arr) | תוכן המערך בצורה קריאה |
מתודות
| פעולה | תחביר |
|---|---|
| הגדרת מתודה | int add(int a, int b) { return a + b; } |
| ללא ערך החזרה | void greet() { ... } |
| מתודה סטטית | static int square(int x) { return x * x; } |
| מתודה ציבורית | public String getName() { return name; } |
| Varargs | int sum(int... nums) { ... } |
| קריאה למתודה | int r = add(2, 3); |
| קריאה למתודה סטטית | Math.max(a, b); |
| העמסת מתודות (Overloading) | int max(int a, int b) ו-double max(double a, double b) |
מחלקות ו-OOP
| פעולה | תחביר |
|---|---|
| הגדרת מחלקה | public class Dog { ... } |
| שדה | private String name; |
| בנאי | public Dog(String name) { this.name = name; } |
| יצירת אובייקט | Dog d = new Dog("Rex"); |
| Getter / setter | public String getName() { return name; } |
| ירושה | class Puppy extends Dog { ... } |
| ממשק (Interface) | interface Runnable { void run(); } |
| מימוש ממשק | class Task implements Runnable { ... } |
| דריסת מתודה | @Override public void speak() { ... } |
Records, enums ו-Java מודרנית
תחביר מודרני ותמציתי (Java 14+) לנשאי נתונים ולקבוצות ערכים קבועות.
| יכולת | תחביר |
|---|---|
| Record (נתונים בלתי ניתנים לשינוי) | record Point(int x, int y) {} |
| שימוש ב-record | var p = new Point(1, 2); p.x(); |
| Enum | enum Day { MON, TUE, WED } |
| Enum עם ערכים | enum Coin { PENNY(1), DIME(10); ... } |
| Text block | String s = """\n multi\n line\n """; |
Pattern matching עם instanceof | if (o instanceof String s) { s.length(); } |
| Switch עם patterns (Java 21) | case Integer i -> ...; case String s -> ...; |
| Sealed class | sealed interface Shape permits Circle, Square {} |
Collections
Collections גנריים מתוך java.util.
| טיפוס | שימוש ודוגמה |
|---|---|
ArrayList<T> | מערך דינמי: list.add(1); list.get(0); list.size(); |
HashMap<K, V> | מפתח-ערך: map.put("a", 1); map.get("a"); |
HashSet<T> | ערכים ייחודיים: set.add(5); set.contains(5); |
LinkedList<T> | רשימה מקושרת דו-כיוונית, טובה כתור/deque |
ArrayDeque<T> | מחסנית/תור: dq.push(x); dq.pop(); |
| מערך | int[] nums = {1, 2, 3}; |
| מעבר על רשימה | for (T x : list) { ... } |
| מעבר על map | for (var e : map.entrySet()) { e.getKey(); e.getValue(); } |
Streams ו-lambdas
צינורות עיבוד בסגנון פונקציונלי על collections (Java 8+).
| פעולה | תחביר |
|---|---|
| ביטוי Lambda | x -> x * 2 |
| יצירת stream | list.stream() |
| סינון | .filter(n -> n > 0) |
| מיפוי / שינוי | .map(n -> n * 2) |
| מיון | .sorted() או .sorted(Comparator.reverseOrder()) |
| צמצום / סכום | .reduce(0, Integer::sum) |
| ספירה / התאמה | .count(), .anyMatch(n -> n > 5) |
| איסוף לרשימה | .collect(Collectors.toList()) |
| לכל איבר | .forEach(System.out::println) |
דפוסים נפוצים (try/catch, generics)
| דפוס | תחביר |
|---|---|
| Try / catch | try { ... } catch (Exception e) { ... } |
| תפיסת exception מסוים | catch (IOException e) { ... } |
| Finally | finally { ... } תמיד רץ |
| Try-with-resources | try (Scanner sc = new Scanner(...)) { ... } |
| זריקת exception | throw new IllegalArgumentException("bad"); |
| מחלקה גנרית | class Box<T> { T value; } |
| מתודה גנרית | <T> T first(List<T> list) { ... } |
| טיפוס חסום | <T extends Number> |
התחביר, ה-collections ופעולות ה-streams של Java שהכי שימושיים, בעמוד אחד. ה-Java cheat sheet הזה הוא דף עזר מהיר לכתיבת Java: טיפוסי הנתונים, בקרת זרימה, מחלקות, ה-collections ArrayList/HashMap, ה-Streams API, ודפוסי ה-exceptions וה-generics שמשתמשים בהם כל יום.
כל מה שכאן הוא Java סטנדרטי (Java 8 ואילך) ומתקמפל עם javac. העתיקו את מה שצריך, או נסו כל קטע קוד בזמן אמת בעורך האונליין של Java, בלי להתקין JDK. חדשים בשפה? קורס Java האינטראקטיבי והחינמי של Coddy בונה את אותם מושגים צעד אחר צעד.
שאלות נפוצות על ה-Java cheat sheet
האם ה-Java cheat sheet הזה בחינם?
כן. ה-Java cheat sheet הזה חינמי לגמרי, בלי צורך בהרשמה. שמרו אותו במועדפים וחזרו אליו בכל פעם שצריך לבדוק תחביר, collection או פעולת stream.
מה ההבדל בין == ל-.equals() ב-Java?
עבור אובייקטים,
== משווה הפניות, כלומר האם שני משתנים מצביעים בדיוק על אותו אובייקט, ואילו .equals() משווה את התוכן. שני אובייקטי String שונים עם אותו טקסט הם .equals() אבל לא בהכרח ==. השתמשו תמיד ב-.equals() כדי להשוות ערכים של מחרוזות ואובייקטים אחרים; השתמשו ב-== רק לטיפוסים פרימיטיביים (int, boolean וכו') או כדי לבדוק null.למה משמשים streams ב-Java?
ה-Streams API (Java 8+) מאפשר לעבד collections בצינור קריא של פעולות,
filter, map, sorted, reduce, collect, במקום לולאות ידניות. מתחילים עם list.stream(), משרשרים פעולות ביניים ומסיימים בפעולה סופית כמו collect(Collectors.toList()) או forEach. כך קוד שמשנה נתונים נשאר תמציתי וברור.אפשר לתרגל Java אונליין?
כן. פתחו את עורך האונליין של Java כדי לקמפל ולהריץ כל קטע קוד מדף העזר הזה בדפדפן, בלי להתקין JDK. כשתרצו מסגרת מסודרת, קורס Java האינטראקטיבי והחינמי של Coddy לוקח אתכם צעד אחר צעד ממשתנים ולולאות ועד מחלקות, collections ו-streams.
האם דף העזר הזה מתאים למתחילים?
כן. הוא מסודר מאבני הבניין הנפוצות ביותר (טיפוסים, בקרת זרימה, מתודות) ועד המתקדמות (streams, generics, exceptions), כך שאפשר להשתמש בחלקים העליונים כבר מהיום הראשון ולהתקדם לשאר בהמשך.
איך ממירים String ל-int ב-Java?
השתמשו ב-
Integer.parseInt("42") כדי לקבל int פרימיטיבי, או ב-Integer.valueOf("42") כדי לקבל אובייקט Integer. שתיהן זורקות NumberFormatException אם המחרוזת אינה מספר תקין, ולכן עטפו אותן ב-try / catch כשהקלט אינו אמין. לכיוון ההפוך, השתמשו ב-String.valueOf(n) או ב-Integer.toString(n).מה ההבדל בין ArrayList למערך ב-Java?
למערך (
int[] a = new int[5]) יש אורך קבוע שנקבע ביצירה, והוא יכול להחזיק טיפוסים פרימיטיביים ישירות. ArrayList<T> גדל וקטן באופן דינמי עם add() ו-remove(), אבל שומר רק אובייקטים, ולכן טיפוסים פרימיטיביים עוברים auto-boxing (ArrayList<Integer>). השתמשו במערך כשהגודל ידוע וקבוע, וב-ArrayList כשגודל האוסף משתנה.משאבים קשורים
עוד דפי עזר
