જાવામાં arrays કેવી રીતે કામ કરે છે?

Question

Accepted Answer

**array** એ નિશ્ચિત કદ, ક્રમમાં એલિમેન્ટ્સનું સંગ્રહ છે જે **એક જ પ્રકાર**ના હોય છે અને મેમોરીમાં સતત રીતે સંગ્રહિત થાય છે। Arrays મૌલિક હોય છે, પરંતુ તેમાં નિશ્ચિત કદ હોવાનું કારણે તમે ગતિશીલ સંગ્રહ માટે ઘણી વાર `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 ડિફોલ્ટ રીતે પ્રકાર-યોગ્ય શૂન્ય (`0`, `0.0`, `false`, `null`) લે છે. ## એક સામાન્ય ત્રુટિ: length એક ક્ષેત્ર છે ```java nums.length; // ✅ array — a field (no parentheses) str.length(); // ✅ String — a method (parentheses) list.size(); // ✅ collection — a method ``` Array `length` એ ક્ષેત્ર છે; String `length()` અને collection `size()` પદ્ધતિઓ છે — આ વારંવાર માટે એક મૂંઝવણજનક બાબત છે. ## Bounds checking ```java int[] arr = {1, 2, 3}; arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime ``` Java બાહ્ય-મર્યાદા reach માટે અપવાદ દોરી કાઢે છે (C ની જેમ નહીં, જેમાં અસંજ્ઞાયિત વર્તન હોય છે) — વધુ સુરક્ષિત, પરંતુ તમે `0` થી `length-1` ની અંદર રહેવું જોઇએ. ## પુનરાવૃત્તિ કરવું ```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; } ``` ## બહુ-પરિમાણીય arrays ```java int[][] matrix = {{1, 2}, {3, 4}}; // array of arrays matrix[0][1]; // 2 ``` ## Arrays વિ 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); ``` નિશ્ચિત-કદ, performance-sensitive, અથવા primitive data માટે સાદા array વાપરો; જ્યારે કદ બદલાય અથવા તમને સુવિધાજનક ઓપરેશન્સ જોઇએ ત્યારે `ArrayList` વાપરો. ## કેમ તે મહત્વપૂર્ણ છે Arrays જાવામાં એક મૌલિક ડેટા સ્ટ્રક્ચર છે — ઝડપી, મેમોરી-કુશળ, સતત સંગ્રહ જે સીધો વાપરવામાં આવે છે અને ઘણાં સંગ્રહો (ArrayList એક array ને આવરે છે) માટે તેનો આધાર છે. તેમના નિશ્ચિત-કદ પ્રકૃતિ, 0-આધારિત ઇન્ડેક્સિંગ, runtime bounds checking, `length` ક્ષેત્ર (વર્સ પદ્ધતિ) ત્રુટિ, અને ખાસ કરીને **array વર્સ ArrayList ક્યારે વાપરવો** (નિશ્ચિત/primitive/ઝડપી વર્સ ગતિશીલ/સુવિધાજનક) સમજવું આવશ્યક છે. Arrays અલ્ગોરિધમ અને performance-critical કોડમાં સતત દેખાય છે, જ્યારે તેમની મર્યાદાઓ (resizing નથી) જાણવી તે સમજાવે છે કે શા માટે ગતિશીલ સંગ્રહો અસ્તિત્વમાં છે અને સામાન્ય વપરાશ માટે સામાન્ય રીતે તેને પ્રાધાન્ય આપવામાં આવે છે.