Conas a bhíonn feidhm ag eagair i Java?

Question

Accepted Answer

Is éard atá i **eagar** ná bailiúchán de dhiminsean socraithe, ordúil, de ghnéithe den **chineál céanna**, stóráilte go leanúnach i cuimhne. Is bunúsach iad eagair, ach ciallaíonn an méid socraithe go bhféadfaidh tú `ArrayList` a bheith i bhfabhar agat i dtaobh bailiúcháin dhinimiúla. ## Eagair a dhearbhú agus a chruthú ```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!) ``` Tá **méid socraithe** ag eagair a bhíonn leagtha amach agus iad á gcruthú — ní féidir leo fás ná laghdú. Glacann eilimintí le zéarótaí cuí don chineál de réir réamhshocraithe (`0`, `0.0`, `false`, `null`). ## Gréine choitíanta: is réimse an fad ```java nums.length; // ✅ array — a field (no parentheses) str.length(); // ✅ String — a method (parentheses) list.size(); // ✅ collection — a method ``` Is réimse an `length` d'eagar; is modhanna iad `length()` an String agus `size()` an bhailiúcháin — pointe mearbhaill a bhíonn ann go minic. ## Seiceáil theorainn ```java int[] arr = {1, 2, 3}; arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime ``` Caitheann Java eisceacht ar ghlacadh as a bharr teorainn (murab ionann agus C, a bhíonn i gceist aici iompar neamhshainithe) — níos sábháilte, ach ní mór duit fanacht i `0` go `length-1`. ## Athrá ```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; } ``` ## Eagair ilghéimí ```java int[][] matrix = {{1, 2}, {3, 4}}; // array of arrays matrix[0][1]; // 2 ``` ## Eagair i gcomparáid le ArrayList — cathain a úsáid gach ceann ```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); ``` Baineann eagair gheal d'úsáid a bhaint as do mhéid socraithe, feidhmíochta gríobhach, nó sonraí primitive; úsáideann tú `ArrayList` nuair a bhíonn an méid ag athrú nó nuair is gá go mbíonn oibríochtaí áisiúil agat. ## Cén fáth go bhfuil an tábhachtach Is struchtúr bunúsach sonraí a bhíonn in eagair i Java — stóráil thapa, éifeachtach cuimhne, leanúnach, a úsáidtear go díreach agus mar bhunús d'go leor bailiúcháin (cuimsigeann ArrayList eagair). A thuiscint ar a nádúr de mhéid socraithe, innéacsú 0-bhunaithe, seiceáil teorainn fadréir ama, an gréine an réimse `length` (i gcomparáid le modh), agus go háirithe **cathain a úsáid eagair i gcomparáid le ArrayList** (socraithe/primitive/tapa i gcomparáid le dinimiciúil/áisiúil) a bhíonn fíor-riachtanach. Bíonn eagair ann i gcónaí in algorithmí agus cód críochaithe feidhmíochta, agus cúlra an chéilí i bhfad níos fearr a bhíonn ann (gan athmhéadú) is fáth ar bith gur ann do bailiúcháin dhinimiúla agus is fearr de ghnáth iad le haghaidh úsáid ghinearálta.