జావాలో arrays ఎలా పని చేస్తాయి?

Question

Accepted Answer

ఒక **array** అనేది ఒకే **రకమైన** elements యొక్క fixed-size, ordered collection, memory లో contiguously నిల్వ చేయబడుతుంది. Arrays ఆధారమైనవి, కానీ వాటి fixed size అంటే మీరు dynamic collections కోసం తరచుగా `ArrayList` కు ప్రాధాన్యత ఇస్తారు. ## Arrays declare చేయడం మరియు సృష్టించడం ```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 సృష్టిన సమయంలో **fixed size** సెట్ చేయబడతాయి — మీరు వాటిని grow or shrink చేయలేరు. Elements type-appropriate zeros (`0`, `0.0`, `false`, `null`) కు default అవుతాయి. ## ఒక సాధారణ gotcha: 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 out-of-bounds access కోసం exception throw చేస్తుంది (C నుండి భిన్నంగా, ఇది undefined behavior కలిగి ఉంటుంది) — సురక్షితమైనది, కానీ మీరు `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); ``` Fixed-size, performance-sensitive, లేదా primitive data కోసం plain array ఉపయోగించండి; size మారినప్పుడు లేదా మీకు convenient operations అవసరమైనప్పుడు `ArrayList` ఉపయోగించండి. ## ఇది ఎందుకు ముఖ్యమైనది Arrays జావాలో ఒక ఫండామెంటల్ డేటా స్ట్రక్చర్ — fast, memory-efficient, contiguous storage directly ఉపయోగించబడుతుంది మరియు చాలా collections (ArrayList an array wrap చేస్తుంది) కు backing. వాటి fixed-size nature, 0-based indexing, runtime bounds checking, `length` field (vs method) gotcha, మరియు ముఖ్యంగా **ఎప్పుడు array vs ArrayList ఉపయోగించాలి** (fixed/primitive/fast vs dynamic/convenient) అర్థం చేసుకోవడం అవసరం. Arrays algorithms మరియు performance-critical code లో నిరంతరం కనిపిస్తాయి, అయితే వాటి limitations (no resizing) తెలుసుకోవడం dynamic collections ఎందుకు ఉన్నాయో మరియు సాధారణ ఉపయోగం కోసం సాధారణంగా ఇష్టపడినవి ఎందుకో వివరిస్తుంది.