نحوه دسترسی به عناصر آرایه (Array) در جاوا

دسترسی به عناصر آرایه در جاوا چگونه است؟

در جاوا، برای دسترسی به هر عنصر از آرایه، از نام آرایه به همراه اندیس (index) عنصر مورد نظر در داخل کروشه استفاده می‌کنید.
اندیس مشخص می‌کند که کدام خانه از آرایه را می‌خواهید. مهم‌ترین نکته این است که اندیس آرایه در جاوا از صفر شروع می‌شود، بنابراین اولین عنصر در اندیس ۰، دومین عنصر در اندیس ۱ و به همین ترتیب قرار دارد.

فرم کلی:

arrayName[index]

مثال ساده:

int[] numbers = {10, 20, 30, 40, 50};
int firstElement = numbers[0];  // دسترسی به عنصر اول - مقدار 10
int thirdElement = numbers[2];   // دسترسی به عنصر سوم - مقدار 30
int lastElement = numbers[4];    // دسترسی به عنصر آخر - مقدار 50

به همین سادگی! با استفاده از نام آرایه و اندیس داخل کروشه، به هر عنصری که می‌خواهید دسترسی پیدا می‌کنید.

اندیس (Index) در آرایه جاوا چیست؟

 اندیس در آرایه جاوا یک عدد صحیح است که موقعیت هر عنصر را در آرایه مشخص می‌کند.
مهم‌ترین ویژگی‌های اندیس در آرایه جاوا عبارتند از:

۱. شروع از صفر

برخلاف بسیاری از زبان‌های برنامه‌نویسی دیگر که شماره خانه‌ها از ۱ شروع می‌شود، در جاوا شماره خانه‌ها از ۰ شروع می‌شود.

int[] scores = {95, 87, 92, 78, 88};
// اندیس 0 = 95
// اندیس 1 = 87
// اندیس 2 = 92
// اندیس 3 = 78
// اندیس 4 = 88

۲. محدوده مجاز اندیس

اندیس‌های مجاز برای یک آرایه از ۰ تا طول آرایه منهای یک (length-1) هستند.

int[] arr = new int[10];
// اندیس‌های مجاز: 0 تا 9
// اندیس 10 غیرمجاز است

۳. دسترسی با اندیس متغیر

اندیس می‌تواند یک عدد ثابت یا یک متغیر یا حتی یک عبارت حسابی باشد.

int[] numbers = {100, 200, 300, 400, 500};
int i = 2;
System.out.println(numbers[i]);     // دسترسی با متغیر - خروجی: 300
System.out.println(numbers[i+1]);   // دسترسی با عبارت - خروجی: 400
System.out.println(numbers[4-2]);   // دسترسی با عبارت - خروجی: 300

۴. طول آرایه

برای اینکه بدانید آخرین اندیس مجاز چیست، از خاصیت length استفاده می‌کنید.

int[] arr = {5, 10, 15, 20};
int lastIndex = arr.length - 1;  // 3
System.out.println(arr[lastIndex]);  // دسترسی به آخرین عنصر - خروجی: 20

نکته مهم: اگر به اندیسی خارج از محدوده مجاز دسترسی پیدا کنید، جاوا در زمان اجرا خطای ArrayIndexOutOfBoundsException می‌دهد و برنامه متوقف می‌شود.

int[] arr = {1, 2, 3};
System.out.println(arr[5]);  // خطا! اندیس 5 خارج از محدوده است

🚀 از صفر تا قهرمان جاوا، فقط با یک دوره!
به دنبال یه فرصت طلایی برای شروع برنامه‌نویسی می‌گردی؟
دوره آموزشی جاوا ما، همون چیزیه که نیاز داری!

✨ چرا این دوره رو انتخاب می‌کنی؟
🎯 از مبتدی تا حرفه‌ای
بدون پیش‌زمینه شروع می‌کنی و به یه برنامه‌نویس جاوا تبدیل می‌شی که بازار کار منتظرته!

🛠 پروژه‌محور و عملی
با انجام پروژه‌های واقعی، کدنویسی رو یاد می‌گیری، نه فقط تئوری!

👨‍🏫 پشتیبانی همیشگی
هرجا گیر کنی، تیم پشتیبانی کنارته تا مشکلت حل بشه.

🔓 دسترسی مادام‌العمر
هر وقت خواستی به محتوا دسترسی داری، برای همیشه!

 

🔥 همین حالا ثبت‌نام کن 

خواندن عناصر آرایه در جاوا

خواندن عناصر آرایه یعنی گرفتن مقدار ذخیره شده در یک خانه خاص و استفاده از آن در برنامه.
روش‌های مختلفی برای خواندن عناصر آرایه وجود دارد:

۱. خواندن یک عنصر خاص

ساده‌ترین حالت، دسترسی مستقیم با اندیس مشخص است:

public class ReadSpecificElement {
    public static void main(String[] args) {
        String[] colors = {"قرمز", "آبی", "سبز", "زرد", "مشکی"};
        
        // خواندن عنصر دوم (اندیس 1)
        String secondColor = colors[1];
        System.out.println("رنگ دوم: " + secondColor);  // خروجی: آبی
        
        // خواندن عنصر آخر
        String lastColor = colors[colors.length - 1];
        System.out.println("آخرین رنگ: " + lastColor);  // خروجی: مشکی
    }
}

۲. خواندن تمام عناصر با حلقه for

برای خواندن و نمایش تمام عناصر یک آرایه، از حلقه استفاده می‌کنیم:

public class ReadAllElements {
    public static void main(String[] args) {
        int[] scores = {18, 19, 20, 17, 16};
        
        System.out.println("نمرات دانش‌آموزان:");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("دانش‌آموز " + (i+1) + ": " + scores[i]);
        }
    }
}

خروجی:

نمرات دانش‌آموزان:
دانش‌آموز 1: 18
دانش‌آموز 2: 19
دانش‌آموز 3: 20
دانش‌آموز 4: 17
دانش‌آموز 5: 16

۳. خواندن با حلقه for-each (حلقه پیشرفته)

برای خواندن عناصر زمانی که نیاز به اندیس ندارید، حلقه for-each خواناتر است:

public class ReadWithForEach {
    public static void main(String[] args) {
        String[] names = {"علی", "رضا", "سارا", "مریم"};
        
        System.out.println("اسامی:");
        for (String name : names) {
            System.out.println(name);
        }
    }
}

۴. خواندن و محاسبه روی عناصر

اغلب عناصر را می‌خوانید تا روی آنها محاسباتی انجام دهید:

public class CalculateWithArray {
    public static void main(String[] args) {
        int[] numbers = {5, 10, 15, 20, 25};
        int sum = 0;
        
        for (int i = 0; i < numbers.length; i++) {
            sum = sum + numbers[i];  // خواندن هر عنصر و جمع زدن
        }
        
        double average = (double) sum / numbers.length;
        System.out.println("مجموع: " + sum);      // خروجی: 75
        System.out.println("میانگین: " + average); // خروجی: 15.0
    }
}

۵. خواندن و جستجو در آرایه

public class SearchElement {
    public static void main(String[] args) {
        int[] numbers = {12, 34, 56, 78, 90};
        int target = 56;
        boolean found = false;
        
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == target) {  // خواندن و مقایسه
                System.out.println("مقدار " + target + " در اندیس " + i + " پیدا شد");
                found = true;
                break;
            }
        }
        
        if (!found) {
            System.out.println("مقدار پیدا نشد");
        }
    }
}

تغییر مقدار عناصر آرایه در جاوا

تغییر مقدار یک عنصر آرایه بسیار شبیه به خواندن آن است، با این تفاوت که در سمت راست تساوی، مقدار جدید را قرار می‌دهیم.

۱. تغییر یک عنصر خاص

public class ChangeSpecificElement {
    public static void main(String[] args) {
        int[] temperatures = {25, 27, 26, 28, 24};
        
        System.out.println("دمای اولیه روز سوم: " + temperatures[2]);  // 26
        
        // تغییر دمای روز سوم (اندیس 2) به 30
        temperatures[2] = 30;
        
        System.out.println("دمای جدید روز سوم: " + temperatures[2]);  // 30
        
        // نمایش همه دماها بعد از تغییر
        for (int temp : temperatures) {
            System.out.print(temp + " ");
        }
        // خروجی: 25 27 30 28 24
    }
}

۲. تغییر چند عنصر با حلقه

public class ChangeMultipleElements {
    public static void main(String[] args) {
        int[] scores = {10, 15, 12, 18, 14};
        
        // اضافه کردن 5 نمره به همه دانش‌آموزان
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scores[i] + 5;
        }
        
        // نمایش نمرات جدید
        System.out.print("نمرات پس از اضافه شدن 5 واحد: ");
        for (int score : scores) {
            System.out.print(score + " ");
        }
        // خروجی: 15 20 17 23 19
    }
}

۳. تغییر بر اساس شرط

public class ChangeWithCondition {
    public static void main(String[] args) {
        int[] grades = {12, 8, 15, 6, 18, 5};
        
        // نمرات زیر 10 را به 10 تبدیل کن
        for (int i = 0; i < grades.length; i++) {
            if (grades[i] < 10) {
                grades[i] = 10;
            }
        }
        
        System.out.print("نمرات پس از اصلاح: ");
        for (int grade : grades) {
            System.out.print(grade + " ");
        }
        // خروجی: 12 10 15 10 18 10
    }
}

۴. تغییر عناصر در حلقه for-each (محدودیت)

نکته مهم: در حلقه for-each نمی‌توانید مقدار عناصر را تغییر دهید، زیرا متغیر حلقه فقط یک کپی از عناصر است.

public class ForEachChangeError {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        // این روش کار نمی‌کند!
        for (int num : numbers) {
            num = num * 2;  // فقط متغیر num تغییر می‌کند، آرایه تغییری نمی‌کند
        }
        
        // نتیجه: آرایه همچنان {1, 2, 3, 4, 5} است
        
        // برای تغییر باید از حلقه for معمولی استفاده کنید
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = numbers[i] * 2;  // درست
        }
        // نتیجه: {2, 4, 6, 8, 10}
    }
}

مثال‌های ترکیبی خواندن و تغییر

مثال ۱: معکوس کردن آرایه

public class ReverseArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        System.out.print("آرایه اصلی: ");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        
        // معکوس کردن آرایه
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        
        System.out.print("\nآرایه معکوس: ");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

مثال ۲: جابجایی عناصر در آرایه

public class SwapElements {
    public static void main(String[] args) {
        String[] fruits = {"سیب", "پرتقال", "موز", "انگور"};
        
        System.out.println("قبل از جابجایی:");
        for (String fruit : fruits) {
            System.out.print(fruit + " ");
        }
        
        // جابجایی عنصر اول (اندیس 0) با عنصر سوم (اندیس 2)
        String temp = fruits[0];
        fruits[0] = fruits[2];
        fruits[2] = temp;
        
        System.out.println("\nبعد از جابجایی:");
        for (String fruit : fruits) {
            System.out.print(fruit + " ");
        }
        // خروجی: موز پرتقال سیب انگور
    }
}

مثال ۳: انتقال عناصر به آرایه جدید

public class CopyArray {
    public static void main(String[] args) {
        int[] source = {1, 2, 3, 4, 5};
        int[] destination = new int[source.length];
        
        // خواندن از آرایه منبع و نوشتن در آرایه مقصد
        for (int i = 0; i < source.length; i++) {
            destination[i] = source[i];
        }
        
        System.out.print("آرایه کپی شده: ");
        for (int num : destination) {
            System.out.print(num + " ");
        }
    }
}

اشتباهات رایج در دسترسی به عناصر آرایه

اشتباه ۱: اشتباه در شمارش اندیس

int[] arr = {10, 20, 30};
// اشتباه: فکر کردن اینکه اندیس از 1 شروع می‌شود
System.out.println(arr[1]);  // این می‌شود 20، نه 10!
// درست: اولین عنصر در اندیس 0 است
System.out.println(arr[0]);  // درست - خروجی: 10

اشتباه ۲: رفتن خارج از محدوده

int[] arr = new int[5];
// اشتباه: دسترسی به اندیس 5
arr[5] = 100;  // خطا! آخرین اندیس مجاز 4 است
// درست: محدوده مجاز 0 تا 4
arr[4] = 100;  // درست

اشتباه ۳: استفاده از length به جای length-1

int[] arr = {1, 2, 3, 4};
// اشتباه: arr.length برابر 4 است اما آخرین اندیس 3 است
System.out.println(arr[arr.length]);  // خطا!
// درست:
System.out.println(arr[arr.length - 1]);  // خروجی: 4

اشتباه ۴: تغییر عناصر در حلقه for-each

int[] numbers = {1, 2, 3};
for (int num : numbers) {
    num = 10;  // این کار آرایه را تغییر نمی‌دهد!
}

کاربردهای عملی دسترسی به عناصر آرایه

۱. ذخیره و نمایش اطلاعات دانش‌آموزان

public class StudentScores {
    public static void main(String[] args) {
        String[] students = {"علی", "رضا", "سارا"};
        int[] scores = {18, 20, 17};
        
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i] + ": " + scores[i]);
        }
    }
}

۲. یافتن کمترین و بیشترین مقدار

public class MinMax {
    public static void main(String[] args) {
        int[] data = {45, 23, 78, 12, 89, 34};
        int min = data[0];
        int max = data[0];
        
        for (int i = 1; i < data.length; i++) {
            if (data[i] < min) min = data[i];
            if (data[i] > max) max = data[i];
        }
        
        System.out.println("کمترین: " + min);
        System.out.println("بیشترین: " + max);
    }
}

جمع‌بندی

مهم‌ترین نکات نحوه دسترسی به عناصر آرایه در جاوا  عبارتند از:

۱. برای دسترسی به عناصر آرایه از arrayName[index] استفاده می‌شود.

۲. اندیس آرایه از ۰ شروع می‌شود و تا length-1 ادامه می‌یابد.

۳. می‌توانید با استفاده از اندیس، مقادیر را بخوانید (مانند int x = arr[2]) یا تغییر دهید (مانند arr[2] = 50).

۴. برای خواندن و تغییر همه عناصر، از حلقه‌های for و for-each استفاده می‌شود. اما توجه داشته باشید که حلقه for-each فقط برای خواندن مناسب است، نه برای تغییر.

۵. دسترسی به اندیس خارج از محدوده باعث خطای ArrayIndexOutOfBoundsException می‌شود.

۶. خاصیت length تعداد کل عناصر آرایه را نشان می‌دهد و آخرین اندیس مجاز برابر length-1 است.

تسلط بر دسترسی به عناصر آرایه، پایه‌ای برای یادگیری مباحث پیشرفته‌تر مانند جستجو، مرتب‌سازی و پردازش داده‌ها در جاوا است.