אתר זה מקיים Java לפי כללי שפת 8. דוגמאות עצמאיות אלו מכילות את שיטת הכניסה שלו, main, בתוך מחלקה. מחלקות עוזר ותשובות המוגבלות לשיטה אינן זקוקות ל-main משלהן. System.out.println(...) מדפיט שורה; System.out.print(...) מדפיט ללא שורה חדשה.
public class Main {
public static void main(String[] args) {
System.out.println("Hello, world!");
System.out.println("I am learning Java.");
}
}
Java מתוקפת: המתקפת בודקת את כל התוכנית, ואז היא מופעלת.
הכרזות, הצבות, קריאות שיטה והצהרות return מסתיימות בפסיק-נקודה ;. בלוק if, for או while משתמש בסוגריים מעוקפים; אל תוסיף פסיק-נקודה רק כי סוגרי הסגירה שלו מופיעים.
דוגמה עצמאית זו לJava 8 מגדירה main בתוך מחלקה
1.2
משתנים וסוגים פרמיטיביים
משתנה חייב להצהיר את סוגו. סוגים פרמיטיביים נפוצים: int (מספר שלם), double (מספר עשרוני), boolean (true/false), char (יחידת קוד UTF-16 אחת; חלק מהאיות דורשים שתי יחידות).
public class Main {
public static void main(String[] args) {
int age = 17;
double price = 9.99;
boolean passed = true;
System.out.println(age + " " + price + " " + passed);
}
}
1.3
הערות סגנון
הערות הן // (שורה אחת) או /* ... */ (בלוק). תרשם את הקוד בתוך הסוגריים { }. שמות מחלקות מתחילים באות גדולה; משתנים ושיטות משתמשות בcamelCase (האות הראשונה קטנה).
public class Main {
public static void main(String[] args) {
// greet the user
String firstName = "Mei";
System.out.println("Hi, " + firstName);
}
}
שגיאות נפוצות
הצהרות, הטלות, קריאות שיטה והצהרות return מסתיימות ב-;; בלוקי זרימת בקרה אינם זקוקים לנקודה-פסיקה נוספת.
השתמש בנקודת הכניסה הסטנדרטית של Java 8 public static void main(String[] args); שם הפרמטר עשוי להיות שונה, ו-String... args גם כן תקף.
חשבונאות Java משתמשת ב+ - * / וב% (שארית). עם שניints, / היא חילוק שלם — היא מזרקת את החלק העשרוני. +=, -=, ו++ הם מקיצים.
public class Main {
public static void main(String[] args) {
int a = 7, b = 2;
System.out.println(a / b); // 3 (integer division)
System.out.println(a % b); // 1
double x = 7.0 / 2; // 3.5 (one side is double)
System.out.println(x);
}
}
int/int גוזר; יש להשתמש ב-double כדי לקבל מנה אמיתית
2.2
שימוש באובייקטים: String, Math, classes
חלק מערכים הם אובייקטים עם מתודות. ל-String יש את .length(), .substring() ו-.toUpperCase(). ל-Math יש את Math.max, Math.sqrt ו-Math.pow. מחלקות האריזה (Integer, Double) עוטפות ערך ראשוני — לדוגמה, Integer.parseInt("42").
public class Main {
public static void main(String[] args) {
String s = "Hello";
System.out.println(s.length()); // 5
System.out.println(s.toUpperCase()); // HELLO
System.out.println(Math.max(3, 9)); // 9
System.out.println(Integer.parseInt("42") + 1); // 43
}
}
Math.random() מחזירה מספר רנדומלי double בטווח מ-0.0 ועד (אך לא כולל) 1.0. ניתן למצוא מספרים שלמים על ידי סקייל והמרה: זוהי הסגנון המקובל ב-AP:
public class Main {
public static void main(String[] args) {
// a random whole number from 1 to 6 (a dice roll)
int roll = (int) (Math.random() * 6) + 1;
System.out.println(roll >= 1 && roll <= 6); // true
}
}
Integer.MAX_VALUE (2147483647) ו-Integer.MIN_VALUE הם הגבולות של int; מעבר עליהם גורם לעטיפה (overflow).
משתנה אובייקט המפנה לאובייקט כלשהו מחזירה null; ניסיון לקרוא מתודה עליה זורק NullPointerException.
2.3
הקמה (Casting) והמרת סוגים
הקמה משנה את סוג הערך. (int) מזרק את החלק השברי; (double) מונע חילוק שלם כאשר נדרש תוצאה מדויקת.
public class Main {
public static void main(String[] args) {
double pi = 3.99;
System.out.println((int) pi); // 3
int total = 7, n = 2;
System.out.println((double) total / n); // 3.5
}
}
שגיאות נפוצות
חילוק שלם: 5 / 2 הוא 2, לא 2.5. יש להקום תחילה: (double) 5 / 2.
השוו בין Strings (ובין שאר אובייקטים) באמצעות .equals(), ולא ==.
== על שני אובייקטים בודק האם מדובר באותו אובייקט בדיוק, ולא אם הם נראים זהים.
if מבצע בלוק כאשר תנאי הוא נכון; else if ו-else מוסיפים מקרים נוספים. התנאי נכתב ב-( ), והבלוק ב-{ }.
public class Main {
public static void main(String[] args) {
int score = 72;
if (score >= 80) {
System.out.println("A");
} else if (score >= 60) {
System.out.println("B");
} else {
System.out.println("fail");
}
}
}
if בוחר את הענף האמת; else את הענף השגוי
3.2
מפעילים לוגיים והשוואות
השווה עם ==, !=, <, >, <=, >= — ההשוואה מחזירה boolean. שלב עם && (and), || (or), ! (not) — המפעילים הלוגיים. עבור Strings, השתמש ב-.equals(...), לא ב-==.
public class Main {
public static void main(String[] args) {
int age = 16;
boolean member = true;
System.out.println(age >= 18 && member); // false
String a = "hi";
System.out.println(a.equals("hi")); // true
}
}
3.3
מתג
switch בוחר בין מספר ערכים קבועים. השתמש ב-break כדי לעצור מקרה; ללאו, הביצוע עשוי להמשיך למקרה הבא. default הוא החלופה.
public class Main {
public static void main(String[] args) {
int day = 3;
switch (day) {
case 1: System.out.println("Mon"); break;
case 3: System.out.println("Wed"); break;
default: System.out.println("other");
}
}
}
שגיאות נפוצות
התנאי חייב להיות boolean; if (x = 5) לא יתקפל (השתמש ב-==).
בתוך switch, break, return או throw יכולים לעצור דליפת קוד. הגעה למקרה הבא ללא אחד מהם ממשיכה את הביצוע שם.
&& ו-|| מבצעים קיצור (short-circuit). & ו-| פועלים ביטית על מספרים שלמים; עם בוליאנים הם מעבירים שני ארגומנטים.
לולאת while חוזרת על עצמה כל עוד התנאי מתקיים. יש לשנות משהו בתוך הלולאה, אחרת היא תתרחש לנצח.
public class Main {
public static void main(String[] args) {
int n = 1;
while (n <= 3) {
System.out.println(n);
n++;
}
}
}
while בודק את התנאי לפני כל עבר של הגוף
4.2
לולאות for
לולאת for מארגנת את ההתחלה, התנאי והשלב בשורה אחת. מתאים ביותר כשהכמות ידועה.
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.print(i + " ");
}
System.out.println(); // 0 1 2 3 4
}
}
4.3
הצטברות
תבנית המצטבר: להתחיל משתנה לפני הלולאה, ואז לעדכן אותו בכל סיבוב.
public class Main {
public static void main(String[] args) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i;
}
System.out.println(total); // 15
}
}
4.4
לולאות מצטבות
לולאה בתוך לולאה היא לולאה מקוננת. הלולאה הפנימית מתבצעת במלואה בכל סיבוב של החיצונית.
public class Main {
public static void main(String[] args) {
for (int r = 0; r < 3; r++) {
for (int c = 0; c < 3; c++) {
System.out.print("*");
}
System.out.println();
}
}
}
שגיאות נפוצות
for (int i = 0; i < n; i++) פועל n פעמים (מ-0 עד n - 1); שימוש ב-<= מוסיף סיבוב נוסף.
אל תשים נקודה-פס ישר לאחר for (...) או while (...) — זה יוצר לולאה ריקה.
הכרז את הספור (counter) ב-header של for כך שהטווח שלו יסתיים עם הלולאה.
מסדרת String היא טקסט. שיטות מועילות: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...). מסדרות הן בלתי ניתנות לשינוי: תוכנן אינו ניתן לשינוי. שיטות עשויות להחזיר מספרים, בוליאנים או מסדרות; מסדרה שהוחזרה עשויה להשתמש באובייקט קיים.
public class Main {
public static void main(String[] args) {
String s = "Python";
System.out.println(s.length()); // 6
System.out.println(s.charAt(0)); // P
System.out.println(s.substring(0, 3)); // Pyt
System.out.println(s.toUpperCase()); // PYTHON
}
}
השיטות שתשתמש בהן כל יום:
שיטה
משמעות
דוגמה → תוצאה
.length()
כמה תווים
"Hi".length() → 2
.charAt(i)
one character
"Hi".charAt(0) → H
.substring(a, b)
חלק, עוצר לפני b
"Python".substring(0, 3) → Pyt
.substring(a)
מ-a ועד הסוף
"Python".substring(3) → hon
.indexOf(x)
מיקום ראשון, -1 אם לא קיים
"banana".indexOf("na") → 2
.equals(s)
אותו טקסט?
"hi".equals("hi") → true
.compareTo(s)
סדר: שלילי / 0 / חיובי
"apple".compareTo("banana") → שלילי
compareTo משווה יחידות קוד UTF-16 באופן לקסיקוגרפי, עם התחשבות בגדולות אות (לדוגמה, "Z" מגיע לפני "a") — המבחן האפ״י משתמש בזה לסיוום שאלות:
public class Main {
public static void main(String[] args) {
String a = "apple", b = "banana";
System.out.println(a.compareTo(b) < 0); // true (apple comes first)
System.out.println(a.compareTo("apple")); // 0 (equal)
}
}
שיטות מפתח למחרוזות: length, charAt, substring, equals
5.2
בניית וניווט במחרוזות
אחדו מחרוזות באמצעות + (הדבקה). צפו בכל תווית באמצעות לולאה ו.charAt(i).
public class Main {
public static void main(String[] args) {
String word = "banana";
int count = 0;
for (int i = 0; i < word.length(); i++) {
if (word.charAt(i) == 'a') count++;
}
System.out.println(count); // 3
}
}
כשאתם בונים מחרוזת ארוכה בתוך לולאה, StringBuilder מהיר משמעותית: הוסיפו את החלקים באמצעות append, ולאחר מכן קראו ל-.toString() פעם אחת.
public class Main {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
sb.append(i).append(" ");
}
System.out.println(sb.toString().trim()); // 1 2 3 4 5
}
}
שגיאות נפוצות
מסדרות הן בלתי ניתנות לשינוי: s.toUpperCase() מחזירה תוצאה באותיות גדולות ללא שינוי s, ולכן יש לאחסן את התוצאה.
קראו תווית באמצעות s.charAt(i); האורך הוא s.length() (זו שיטה, עם ()).
בניית מחרוזת באמצעות += בתוך לולאה גדולה היא איטית; השתמשו ב-StringBuilder.
מערך מחזיק מספר קבוע של ערכים מאותו סוג. מדדו מתוך 0, והגיעו לגודל באמצעות .length.
public class Main {
public static void main(String[] args) {
int[] scores = {88, 71, 95};
System.out.println(scores[0]); // 88
System.out.println(scores.length); // 3
scores[1] = 100;
System.out.println(scores[1]); // 100
}
}
*ערך ראשוני שומר את הערך שלו; משתנה מערך שומר על הפניה לאובייקט המערך
6.2
אלגוריתמים למערכים
סרו את המערך באמצעות לולאה כדי למצוא מקסימום, סכום, מונה או לבצע חיפוש. לולאת for-each (for (int x : a)) קוראת כל ערך בסדר.
public class Main {
public static void main(String[] args) {
int[] a = {3, 9, 2, 7};
int max = a[0], total = 0;
for (int x : a) {
if (x > max) max = x;
total += x;
}
System.out.println(max + " " + total); // 9 21
}
}
6.3
מערךים בעלי ממד 2
מערך דו-ממדי 2 הוא רשת של שורות ועמודות: grid[row][col].
public class Main {
public static void main(String[] args) {
int[][] grid = {{1, 2, 3}, {4, 5, 6}};
System.out.println(grid[1][2]); // 6
for (int[] row : grid) {
for (int v : row) System.out.print(v + " ");
}
System.out.println(); // 1 2 3 4 5 6
}
}
שגיאות נפוצות
גודל המערכת הוא a.length (ללא סוגריים, ללא ()), והוא קבוע ברגע היצירה.
אינדקסים תקפים הם מ-0 עד a.length - 1; a[a.length] גורם לפגיעה ב-ArreyIndexOutOfBoundsException.
ArrayList היא רשימה שאפשר לשנות גודלה — היא גדלה ומצטמצמת כשמוסיפים או מורידים פריטים. היא מאחסנת אובייקטים, לכן יש להשתמש בסוג עטיפה כמוInteger (לאint). החלק<Integer> הוא סוג גנרי. שיטות מרכזיות: .add(x), .get(i), .set(i, x), .size(), .remove(i).
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(10);
nums.add(20);
nums.add(30);
System.out.println(nums.size()); // 3
System.out.println(nums.get(1)); // 20
nums.set(0, 99);
System.out.println(nums); // [99, 20, 30]
}
}
ArrayList: add, get, size ברשימה בעלת גודל משתנה
7.2
אלגוריתמי ArrayList ובג של remove
.remove(i) מזיז כל אלמנט לאחריו מקום אחד שמאלה. אם תסיר אלמנטים בזמן ספירה iלמעלה, תדלג על האלמנט הבא. פתרון: לולאה לחוצה או אל תגביר i אחרי הסרה.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<Integer>();
for (int n : new int[]{4, 7, 4, 9, 4}) nums.add(n);
// Remove every 4 — loop backwards so removals don't skip items.
for (int i = nums.size() - 1; i >= 0; i--) {
if (nums.get(i) == 4) nums.remove(i);
}
System.out.println(nums); // [7, 9]
}
}
שגיאות נפוצות
ArrayList משתמש ב.size(), .get(i) ו.add(...) — ולא ב[] שאתה משתמש בו בערכות (arrays).
הסרת פריטים בזמן עובר קדימה באמצעות אינדקס מדלג על הפריט הבא (שגיאת ההסרה). לולאה לחוצה, או השתמש באיטרטור.
אחסן אובייקטים, לא ערכים ראשוניים: השתמש בArrayList<Integer>, וה-Java תעשה אוטומטית עטיפה (auto-boxing) של ערכי int.
כיתה היא תבנית לאובייקטים. השדות שלה מאחסנים נתונים, הבונה מייצר אובייקט חדש, והמתודות הן הפעולות. this.name פירושו "ה-name של אובייקט זה". צור אובייקט עם new.
public class Main {
public static void main(String[] args) {
Dog d = new Dog("Rex", 3);
System.out.println(d.describe()); // Rex is 3 years old
d.haveBirthday();
System.out.println(d.describe()); // Rex is 4 years old
}
}
class Dog {
private String name;
private int age;
public Dog(String name, int age) { // constructor
this.name = name;
this.age = age;
}
public String describe() {
return name + " is " + age + " years old";
}
public void haveBirthday() {
age++;
}
}
חבר static שייך לכיתה עצמה, ולא לכל אובייקט בנפרד. קרא לשיטה סטטית על שם הכיתה — כמו Math.max — ושדה סטטי משותף לכל האובייקטים:
public class Main {
public static void main(String[] args) {
System.out.println(Counter.made()); // 0
new Counter();
new Counter();
System.out.println(Counter.made()); // 2
}
}
class Counter {
private static int count = 0; // shared by ALL Counter objects
public Counter() { count++; }
public static int made() { // called on the class: Counter.made()
return count;
}
}
שדות מאחסנים מצב; בונה בונה; שיטות פועלות
8.2
עטיפה
אקספלציה (Encapsulation) שולטת בגישה למצב האובייקט. סימן שדות כprivate כדי לחסום גישה ישירה ממחלקות שאינן קשורות; אקססור (getter) קורא מצב ומיוטור (mutator) משנה אותו. סטר (setter) הוא סוג אחד של מיוטור. private אינו מאמת ערכים: בוני-אובייקט ושיטות מיוטור צריכים בדיקות עצמאיות או תנאי מקדימים נקובים. דוגמה זו מניחה start לא-שלילי והוספות הנכנסות בint; שיטת ההפקדה שלה דוחה סכומים לא-חיוביים.
public class Main {
public static void main(String[] args) {
Account a = new Account(100);
a.deposit(50);
a.deposit(-999); // rejected by the guard
System.out.println(a.getBalance()); // 150
}
}
class Account {
private int balance; // hidden from outside
public Account(int start) {
balance = start;
}
public void deposit(int amount) {
if (amount > 0) balance += amount; // this guard checks the deposit amount
}
public int getBalance() { // accessor (getter)
return balance;
}
}
שגיאות נפוצות
לבונה יש שם הכיתה ואין לו סוג החזרה (לא גם void).
השתמש בthis.field כדי להבדיל בין שדה לבין פרמטר בעל אותו שם.
הגדר שדות כprivate והגיע אליהם דרך מתודות getter/setter (הסתגרות).
ירושה מאפשרת לתת-כיתה להשתמש בהורים. כתוב class Cat extends Animal ו-Cat יורש שדות ומתודות זמינות מ-Animal. חברים פרטיים אינם נורשים; בניינים אינם נורשים גם כן. קרא לבניין ההורה עם super(...).
public class Main {
public static void main(String[] args) {
Cat c = new Cat("Milo");
c.eat(); // Milo is eating (inherited from Animal)
c.speak(); // Meow (Cat's own method)
}
}
class Animal {
protected String name;
public Animal(String name) { this.name = name; }
public void eat() { System.out.println(name + " is eating"); }
}
class Cat extends Animal {
public Cat(String name) { super(name); } // call Animal's constructor
public void speak() { System.out.println("Meow"); }
}
*חתול וכלב מורשים מAnimal: הם מורשים את חבריה ומוסיפים את משלהם
9.2
פולימורפיזם ו-toString
כיתה בת יכולה להחליף מתודה ולהחליף את גרסת ההורה. פולימורפיזם פירושה שמשתנה Shape יכול להכיל כל סוג בת, וה-Java בוחרת את הtoString הנכון בזמן הרצה. System.out.println(obj) קורא אוטומטית לobj.toString().
public class Main {
public static void main(String[] args) {
Shape[] shapes = { new Circle(2), new Square(3) };
for (Shape s : shapes) {
System.out.println(s); // each calls its own toString
}
}
}
class Shape {
public String toString() { return "a shape"; }
}
class Circle extends Shape {
private int r;
public Circle(int r) { this.r = r; }
public String toString() { return "Circle r=" + r; } // override
}
class Square extends Shape {
private int side;
public Square(int side) { this.side = side; }
public String toString() { return "Square side=" + side; } // override
}
שגיאות נפוצות
מתודה מחליפה חייבת להתאים בדיוק לחתימה; הוסף @Override כך שהקומפיילר יזהה טעויות.
super(...) חייב להיות השורה הראשונה בבונה של סוג נגזר.
אובייקט של מחלקה נגזרת IS-A אובייקט של מחלקת אם, אך לא להפך.
רקורסיה היא שיטה הקוראת לעצמה. לכל רקורסיה נדרש מקרה בסיס (כאן לעצור) וקריאה רקורסיבית המנחה את הביצועים אליו. ללא מקרה בסיס, התוכנית מעולם אינה נעצרת וגורמת לקריסה עם שפיכת סטאק (stack overflow).
מערך קריאות עבור factorial(3): כל קריאה מחכה, ולאחר מכן מחזירה ערך בסדר הפוך
public class Main {
public static void main(String[] args) {
System.out.println(factorial(5)); // 120
}
public static int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call: n * (n-1)!
}
}
מעקב: factorial(5) מחכה ל-factorial(4), שזה מחכה ל-factorial(3)… ועד שהערך factorial(1) מחזיר את 1. לאחר מכן התוצאות כופלות זו את זו בחזרה למעלה: 1 → 2 → 6 → 24 → 120.
רקורסיה פועלת גם על Strings — הורידו אותף אחד בכל קריאה:
public class Main {
public static void main(String[] args) {
System.out.println(reverse("PYTHON")); // NOHTYP
}
static String reverse(String s) {
if (s.length() <= 1) return s; // base case
return reverse(s.substring(1)) + s.charAt(0);
}
}
Merge sort הוא המיון הרקורסיבי הנבחן במבחן AP: חלקו את המערך לשתי חצאים, מיינו כל חצי רקורסיבית, ואחרי מכן מיזגו את שני החצאים הממוינים. ריצת האלגוריתם היא O(n log n) — מהירות משמעותית יותר מאשר מיונים ברמת O(n²) על מערכים גדולים.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7, 3};
mergeSort(a, 0, a.length - 1);
System.out.println(Arrays.toString(a)); // [1, 2, 3, 5, 7, 9]
}
static void mergeSort(int[] a, int lo, int hi) {
if (lo >= hi) return; // base case: one element
int mid = (lo + hi) / 2;
mergeSort(a, lo, mid); // sort the left half
mergeSort(a, mid + 1, hi); // sort the right half
merge(a, lo, mid, hi); // merge the two halves
}
static void merge(int[] a, int lo, int mid, int hi) {
int[] tmp = new int[hi - lo + 1];
int i = lo, j = mid + 1, k = 0;
while (i <= mid && j <= hi) {
if (a[i] <= a[j]) tmp[k++] = a[i++];
else tmp[k++] = a[j++];
}
while (i <= mid) tmp[k++] = a[i++];
while (j <= hi) tmp[k++] = a[j++];
for (k = 0; k < tmp.length; k++) a[lo + k] = tmp[k];
}
}
שגיאות נפוצות
ריקורסיה דורשת מקרה בסיסי, או שתופיע שגיאת StackOverflowError.
כל קריאה רקורסיבית חייבת לקרב CLOSER למקרה הבסיס.
בצעו מעקב ידני לדוגמה קטנה כדי לוודא שהרקורסיה מחזירה את הערך הנכון.
בשלב המיזוג ב-Merge sort מתבצע העבודה העיקרית; הרקורסיה משמשת רק לחלוקת המערכת.
חיפוש ליניארי בודק כל אלמנט — עובד על כל מערך. חיפוש בינארי מהיר משמעותית יותר אך דורש מערך מומיין: הוא בוחן את האלמנט באמצע, ולאחר מכן פולט חצי מהטווח בכל צעד. שניהם מחזירים את המקדם, או -1 אם לא נמצא.
public class Main {
public static void main(String[] args) {
int[] a = {2, 5, 8, 12, 16, 23}; // sorted, so binary search works
System.out.println(linear(a, 12)); // 3
System.out.println(binary(a, 12)); // 3
System.out.println(binary(a, 9)); // -1 (not found)
}
static int linear(int[] a, int target) {
for (int i = 0; i < a.length; i++)
if (a[i] == target) return i;
return -1;
}
static int binary(int[] a, int target) {
int lo = 0, hi = a.length - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
}
חיפוש בינארי מחצית את הטווח בכל צעד, ולכן מערך ממויין נבדק בזמן O(log n)
11.2
מיון בחירה ומיון הכנסה
במיון בחירה נמצא באופן חוזר הערך הקטן ביותר שנותר והוא מתחליפו עם האלמנט הראשון. במיון הכנסה לוקחים כל ערך ומחליקים אותו אחורה למקומו בין הערכים שכבר ממוינים.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7};
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++)
if (a[j] < a[min]) min = j;
int t = a[min]; a[min] = a[i]; a[i] = t; // swap into place
}
System.out.println(Arrays.toString(a)); // [1, 2, 5, 7, 9]
}
}
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7};
for (int i = 1; i < a.length; i++) {
int key = a[i], j = i - 1;
while (j >= 0 && a[j] > key) { // shift bigger values right
a[j + 1] = a[j];
j--;
}
a[j + 1] = key; // drop key into the gap
}
System.out.println(Arrays.toString(a)); // [1, 2, 5, 7, 9]
}
}
השוואת מהירויות:
אלגוריתם
זמן
חיפוש ליניארי
O(n)
חיפוש בינארי
O(log n), רק מערכים ממוינים
מיון בחירה / מיון הכנסה
O(n²)
מיון מיזוג (נושא 10)
O(n log n)
שגיאות נפוצות
חיפוש בינארי פועל רק על מערך מוארך.
חיפוש ליניארי הוא O(n); חיפוש בינארי הוא O(log n) אך דורש קודם כן מיון.
מיון בחירה ומיון השחלה הם O(n²) — קלים ללמידה, איטיים על נתונים גדולים.
אובייקט Scanner קורא טקסט שורה בשורה. עבור קובץ אמיתי כותבים new Scanner(new File("scores.txt")); כאן אנו עוטפים String כדי שהדוגמה תעבוד בכל מקום. משתמשים ב-.split(" ") לפצל שורה לחלקים וב-Integer.parseInt(...) לפרש מספר מתוך טקסט.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Real file: Scanner in = new Scanner(new File("scores.txt"));
String data = "Alice 80\nBob 95\nCara 72";
Scanner in = new Scanner(data);
int total = 0, count = 0;
while (in.hasNextLine()) {
String line = in.nextLine();
String[] parts = line.split(" "); // break the line on the space
total += Integer.parseInt(parts[1]);
count++;
}
System.out.println("average = " + (total / count)); // average = 82
}
}
Scanner קורא שורות כל עוד hasNextLine הוא true
12.2
סוגי השאלות FRQ של AP
מבחן AP CS A מכיל ארבע שאלות פתוחות, כל אחת בעלת מבנה קבוע:
Q1 — מתודות ושליטה: כתיבת מתודות לפי ספקיפיקציה נתונה; לולאות, if, String/Math.
Q2 — עיצוב מחלקה: כתיבת מחלקה מלאה (שדות, בונה, מתודות) מתוך תיאור.
שאלה3 — מערך /ArrayList: עבד על מערך בעל ממד 1 או על ArrayList (חיפוש, ספירה, בניית רשימה חדשה).
שאלה4 — מערך בעל ממד 2: עבור על גריד לפי שורה ועמודה.
המיומנות תמיד זהה: קריאת הספק, כתיבת המתודה בדיוק כפי שתוארה, החזרת סוג נכון.
public class Main {
public static void main(String[] args) {
// Q1 style: implement a method to a spec, then it is tested.
System.out.println(countEven(new int[]{4, 7, 10, 3, 6})); // 3
}
/** Returns how many values in arr are even. */
public static int countEven(int[] arr) {
int count = 0;
for (int x : arr)
if (x % 2 == 0) count++;
return count;
}
}
שגיאות נפוצות
nextInt() משאיר את סימן הרווח החדש מאחוריו, כך שמצווה nextLine() הבאה תקרא שורה ריקה — קרא אותה קודם.
לבדוק hasNext() לפני הקריאה, כדי להימנע מהליכה מחוץ לגבולות הקובץ.
במבחן FRQ, קרא את חתימת המתודה בקפידה: התאים את סוג ההחזרה והפרמטרים בדיוק.