Java-வில் arrays எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

ஒரு **array** என்பது நினைவகத்தில் தொடர்ச்சியாக சேமிக்கப்பட்ட, **அதே type**-இன் elements-இன் நிலையான-அளவுள்ள, வரிசைப்படுத்தப்பட்ட தொகுப்பு ஆகும். Arrays அடிப்படையானவை, ஆனால் அவற்றின் நிலையான அளவு என்பது dynamic collections-க்கு நீங்கள் அடிக்கடி `ArrayList`-ஐ விரும்புகிறீர்கள் என்பதைக் குறிக்கிறது. ## Arrays-ஐ அறிவித்தல் மற்றும் உருவாக்குதல் ```java int[] nums = new int[5]; // size 5, default-initialized to 0 int[] nums2 = {1, 2, 3, 4, 5}; // declare + initialize with values String[] names = new String[3]; // objects default to null nums[0] = 10; // set by index (0-based) int x = nums[0]; // get by index nums.length; // 5 — the size (a field, NOT a method!) ``` Arrays உருவாக்கத்தின் போது அமைக்கப்பட்ட ஒரு **நிலையான அளவை** கொண்டுள்ளன — நீங்கள் அவற்றை வளர்க்கவோ சுருக்கவோ முடியாது. Elements type-க்கு ஏற்ற zeros-க்கு (`0`, `0.0`, `false`, `null`) default ஆகின்றன. ## ஒரு பொதுவான கவனிக்க வேண்டிய விஷயம்: length ஒரு field ```java nums.length; // ✅ array — a field (no parentheses) str.length(); // ✅ String — a method (parentheses) list.size(); // ✅ collection — a method ``` Array `length` ஒரு field; String `length()` மற்றும் collection `size()` methods ஆகும் — அடிக்கடி குழப்பத்தை ஏற்படுத்தும் ஒரு புள்ளி. ## Bounds checking ```java int[] arr = {1, 2, 3}; arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime ``` எல்லைக்கு வெளியே அணுகலுக்கு Java ஒரு exception-ஐ எறிகிறது (undefined behavior கொண்ட C போல் அல்ல) — பாதுகாப்பானது, ஆனால் நீங்கள் `0` முதல் `length-1` வரை இருக்க வேண்டும். ## Iterating ```java // enhanced for-each (when you don't need the index) for (int n : nums) { System.out.println(n); } // traditional for (when you need the index) for (int i = 0; i < nums.length; i++) { nums[i] *= 2; } ``` ## Multidimensional arrays ```java int[][] matrix = {{1, 2}, {3, 4}}; // array of arrays matrix[0][1]; // 2 ``` ## Arrays vs ArrayList — எப்போது எதைப் பயன்படுத்துவது ```text Array → fixed size, slightly faster, can hold primitives directly (int[]) ArrayList → DYNAMIC size (grow/shrink), rich methods (add/remove/contains), but holds objects only (Integer, not int) ``` ```java List list = new ArrayList<>(); list.add(1); // grows dynamically — no fixed size list.remove(0); ``` நிலையான-அளவு, செயல்திறன்-உணர்திறன், அல்லது primitive data-க்கு ஒரு எளிய array-ஐ பயன்படுத்தவும்; அளவு மாறும்போது அல்லது உங்களுக்கு வசதியான operations தேவைப்படும்போது `ArrayList`-ஐ பயன்படுத்தவும். ## இது ஏன் முக்கியம் Arrays Java-வில் ஒரு அடிப்படை data structure ஆகும் — வேகமான, memory-திறமையான, தொடர்ச்சியான சேமிப்பு நேரடியாகவும் பல collections-க்கான backing ஆகவும் பயன்படுத்தப்படுகிறது (ArrayList ஒரு array-ஐ சுற்றிக் கட்டுகிறது). அவற்றின் நிலையான-அளவு இயல்பு, 0-அடிப்படை indexing, runtime bounds checking, `length` field (vs method) கவனிக்க வேண்டிய விஷயம், மற்றும் குறிப்பாக **எப்போது ஒரு array vs ArrayList-ஐ பயன்படுத்த வேண்டும்** (fixed/primitive/fast vs dynamic/convenient) என்பதைப் புரிந்துகொள்வது அவசியம். Arrays algorithms மற்றும் செயல்திறன்-முக்கியமான code-இல் தொடர்ந்து தோன்றுகின்றன, அதே சமயம் அவற்றின் வரம்புகளை (resizing இல்லை) அறிவது dynamic collections ஏன் உள்ளன மற்றும் பொதுவான பயன்பாட்டிற்கு பொதுவாக ஏன் விரும்பப்படுகின்றன என்பதை விளக்குகிறது.