Java Language => Arrays

परिचय

एरेस एक मनमाना मात्रा के भंडारण और पुनर्प्राप्ति के लिए अनुमति देता है। वे गणित में वैक्टर के अनुरूप हैं। सरणियों के सारणी मैट्रिक्स के अनुरूप होते हैं, और बहुआयामी सरणियों के रूप में कार्य करते हैं। एरे किसी भी प्रकार के किसी भी डेटा को स्टोर कर सकते हैं: आदिम जैसे कि int या संदर्भ प्रकार जैसे Object ।

वाक्य - विन्यास

ArrayType[] myArray; // घोषणाओं का ऐलान
ArrayType myArray[]; // एक और वैध वाक्यविन्यास (कम आमतौर पर इस्तेमाल और हतोत्साहित)
ArrayType[][][] myArray; // बहु-आयामी दांतेदार सरणियों की घोषणा (दोहराएं [] एस)
ArrayType myVar = myArray[index]; // अनुक्रमण पर (पढ़ना) तत्व
myArray[index] = value; // सरणी के स्थिति index के लिए मान असाइन करें
ArrayType[] myArray = new ArrayType[arrayLength]; // ऐरे इनिशियलाइज़ेशन सिंटैक्स
int[] ints = {1, 2, 3}; // प्रदान किए गए मानों के साथ एरियर आरंभीकरण सिंटैक्स, लंबाई प्रदान किए गए मानों की संख्या से अनुमानित है: {[value1 [, value2] *]}
new int[]{4, -5, 6} // Can be used as argument, without a local variable
int[] ints = new int[3]; // same as {0, 0, 0}
int[][] ints = {{1, 2}, {3}, null}; // बहु-आयामी सरणी आरंभीकरण। int [] वस्तु का विस्तार करता है (और ऐसा कोई भी करता है []) इतना शून्य एक वैध मूल्य है।

पैरामीटर

पैरामीटर	विवरण
`ArrayType`	सरणी का प्रकार। यह आदिम ( `int` , `long` , `byte` ) या ऑब्जेक्ट ( `String` , `MyObject` , आदि) हो सकता है।
सूची	सूचकांक एक सरणी में एक निश्चित वस्तु की स्थिति को संदर्भित करता है।
लंबाई	हर सरणी, जब बनाया जा रहा है, एक निर्दिष्ट लंबाई की जरूरत है। यह या तो तब किया जाता है जब रिक्त सरणी ( `new int[3]` ) बनाते हैं या निहित करते हैं जब मान निर्दिष्ट करते हैं ( `{1, 2, 3}` )।

एरे बनाना और आरंभ करना

बुनियादी मामलों

int[]   numbers1 = new int[3];                 // Array for 3 int values, default value is 0
int[]   numbers2 = { 1, 2, 3 };                // Array literal of 3 int values
int[]   numbers3 = new int[] { 1, 2, 3 };      // Array of 3 int values initialized
int[][] numbers4 = { { 1, 2 }, { 3, 4, 5 } };  // Jagged array literal
int[][] numbers5 = new int[5][];               // Jagged array, one dimension 5 long
int[][] numbers6 = new int[5][4];              // Multidimensional array: 5x4

किसी भी आदिम या संदर्भ प्रकार का उपयोग करके सारणियां बनाई जा सकती हैं।

float[]  boats = new float[5];          // Array of five 32-bit floating point numbers.
double[] header = new double[] { 4.56, 332.267, 7.0, 0.3367, 10.0 };
                                       // Array of five 64-bit floating point numbers.
String[] theory = new String[] { "a", "b", "c" };
                                       // Array of three strings (reference type).
Object[] dArt = new Object[] { new Object(), "We love Stack Overflow.", new Integer(3) };
                                       // Array of three Objects (reference type).

अंतिम उदाहरण के लिए, ध्यान दें कि घोषित सरणी प्रकार के उपप्रकार को सरणी में अनुमति दी गई है।

उपयोगकर्ता परिभाषित प्रकारों के लिए सरणी को भी आदिम प्रकारों के समान बनाया जा सकता है

UserDefinedClass[] udType = new UserDefinedClass[5];

एरे, कलेक्शन और स्ट्रीम्स

जावा एसई 1.2

// Parameters require objects, not primitives

// Auto-boxing happening for int 127 here
Integer[]       initial        = { 127, Integer.valueOf( 42 ) };
List<Integer>   toList         = Arrays.asList( initial );  // Fixed size! 

// Note: Works with all collections
Integer[]       fromCollection = toList.toArray( new Integer[toList.size()] );

//Java doesn't allow you to create an array of a parameterized type
List<String>[]  list = new ArrayList<String>[2];  // Compilation error!

जावा एसई 8

// Streams - JDK 8+
Stream<Integer> toStream       = Arrays.stream( initial );
Integer[]       fromStream     = toStream.toArray( Integer[]::new );

पहचान

एक सरणी एक डेटा संरचना है जो एक निश्चित संख्या में आदिम मूल्यों या ऑब्जेक्ट इंस्टेंस के संदर्भ रखती है।

किसी सरणी में प्रत्येक आइटम को एक तत्व कहा जाता है, और प्रत्येक तत्व को इसके संख्यात्मक सूचकांक द्वारा एक्सेस किया जाता है। सरणी बनाए जाने पर सरणी की लंबाई स्थापित की जाती है:

int size = 42;
int[] array = new int[size];

किसी सरणी का आकार प्रारंभ होने पर रनटाइम पर तय किया जाता है। इसे आरंभीकरण के बाद बदला नहीं जा सकता। यदि आकार को रनटाइम के दौरान परिवर्तनशील होना चाहिए, तो Collection श्रेणी जैसे ArrayList का उपयोग किया जाना चाहिए। ArrayList एक सरणी में तत्वों को संग्रहीत करता है और नए सरणी को आवंटित करके और पुराने सरणी से तत्वों की प्रतिलिपि बनाकर आकार बदलने का समर्थन करता है।

यदि सरणी एक आदिम प्रकार का है, अर्थात

int[] array1 = { 1,2,3 };
int[] array2 = new int[10];

मान सरणी में ही संग्रहीत होते हैं। इनिशियलाइज़र की अनुपस्थिति में (ऊपर array2 ), प्रत्येक तत्व को निर्दिष्ट डिफ़ॉल्ट मान 0 (शून्य) है।

यदि सरणी प्रकार ऑब्जेक्ट संदर्भ है, जैसे कि

SomeClassOrInterface[] array = new SomeClassOrInterface[10];

फिर सरणी में SomeClassOrInterface प्रकार की वस्तुओं के संदर्भ शामिल हैं। उन संदर्भों का एक उदाहरण का उल्लेख कर सकते SomeClassOrInterface की या (वर्गों के लिए) किसी भी उपवर्ग या लागू करने वर्ग (इंटरफेस के लिए) SomeClassOrInterface । यदि सरणी घोषणा में कोई इनिशियलाइज़र नहीं है, तो प्रत्येक तत्व को null का डिफ़ॉल्ट मान असाइन किया गया है।

क्योंकि सभी सरणियों हैं int -indexed, एक सरणी के आकार एक से निर्दिष्ट किया जाना चाहिए int । सरणी का आकार long निर्दिष्ट नहीं किया जा सकता है:

long size = 23L;
int[] array = new int[size]; // Compile-time error:
                             // incompatible types: possible lossy conversion from
                             // long to int

ऐरे एक शून्य-आधारित इंडेक्स सिस्टम का उपयोग करते हैं, जिसका अर्थ है कि इंडेक्सिंग 0 से शुरू होता है और length - 1 पर समाप्त होता है।

उदाहरण के लिए, निम्न छवि आकार 10 साथ एक सरणी का प्रतिनिधित्व करती है। यहां, पहला तत्व इंडेक्स 0 और आखिरी तत्व इंडेक्स 9 , पहला तत्व इंडेक्स 1 और आखिरी तत्व इंडेक्स 10 (नीचे आंकड़ा देखें)।

एरे के तत्वों तक पहुंच निरंतर समय में की जाती है । अर्थात सरणी के पहले तत्व तक पहुँचने के लिए दूसरे तत्व, तीसरे तत्व और इतने पर पहुँचने की समान लागत (समय में) होती है।

जावा शाब्दिक और कंस्ट्रक्टर नोटेशन सहित सरणियों को परिभाषित करने और आरंभ करने के कई तरीके प्रदान करता है। new Type[length] कंस्ट्रक्टर का उपयोग करते समय सरणियों की घोषणा करते समय, प्रत्येक तत्व को निम्नलिखित डिफ़ॉल्ट मानों के साथ आरंभ किया जाएगा:

0 आदिम संख्यात्मक प्रकारों के लिए : byte , short , int , long , float और double ।
char प्रकार के लिए '\u0000' (शून्य वर्ण)।
boolean प्रकार के लिए false ।
संदर्भ प्रकारों के लिए null ।

आदिम प्रकार सरणियों का निर्माण और आरंभ करना

int[] array1 = new int[] { 1, 2, 3 }; // Create an array with new operator and 
                                      // array initializer.
int[] array2 = { 1, 2, 3 };           // Shortcut syntax with array initializer.
int[] array3 = new int[3];            // Equivalent to { 0, 0, 0 }
int[] array4 = null;                  // The array itself is an object, so it
                                      // can be set as null.

किसी ऐरे की घोषणा करते समय, [] घोषणा के आरंभ में (प्रकार के नाम के बाद) प्रकार के हिस्से के रूप में प्रकट होगा, या किसी विशेष चर के लिए घोषणाकर्ता के हिस्से के रूप में (चर नाम के बाद), या दोनों:

int array5[];       /* equivalent to */  int[] array5;
int a, b[], c[][];  /* equivalent to */  int a; int[] b; int[][] c;
int[] a, b[];       /* equivalent to */  int[] a; int[][] b;
int a, []b, c[][];  /* Compilation Error, because [] is not part of the type at beginning
                       of the declaration, rather it is before 'b'. */    
// The same rules apply when declaring a method that returns an array:
int foo()[] { ... } /* equivalent to */  int[] foo() { ... }

निम्नलिखित उदाहरण में, दोनों घोषणाएं सही हैं और बिना किसी समस्या के संकलन और चला सकते हैं। हालाँकि, जावा कोडिंग कन्वेंशन और Google जावा स्टाइल गाइड दोनों ही चर नाम के बाद कोष्ठक के साथ फ़ॉर्म को हतोत्साहित करते हैं- कोष्ठक सरणी प्रकार की पहचान करते हैं और प्रकार पदनाम के साथ दिखाई देना चाहिए । उसी का उपयोग विधि वापसी हस्ताक्षरों के लिए किया जाना चाहिए।

float array[]; /* and */ int foo()[] { ... } /* are discouraged */
float[] array; /* and */ int[] foo() { ... } /* are encouraged */

हतोत्साहित प्रकार सी उपयोगकर्ताओं को बदलने के लिए होता है , जो सी के लिए वाक्य रचना से परिचित होते हैं जिनके चर नाम के बाद कोष्ठक होते हैं।

जावा में, आकार 0 सरणियों का होना संभव है:

int[] array = new int[0]; // Compiles and runs fine.
int[] array2 = {};        // Equivalent syntax.

हालाँकि, चूंकि यह एक खाली सरणी है, इसलिए इसमें कोई तत्व नहीं पढ़ा जा सकता है या इसे सौंपा जा सकता है:

array[0] = 1;     // Throws java.lang.ArrayIndexOutOfBoundsException.
int i = array2[0]; // Also throws ArrayIndexOutOfBoundsException.

इस तरह के खाली सरणियाँ आम तौर पर रिटर्न वैल्यू के रूप में उपयोगी होती हैं, ताकि कॉलिंग कोड को एक संभावित null मान के बजाय एक सरणी से निपटने के बारे में चिंता करनी पड़े, जिससे NullPointerException हो सकती है।

एक सरणी की लंबाई एक गैर-नकारात्मक पूर्णांक होनी चाहिए:

int[] array = new int[-1]; // Throws java.lang.NegativeArraySizeException

सरणी का आकार सार्वजनिक अंतिम फ़ील्ड का उपयोग करके निर्धारित किया जा सकता है जिसे length कहा जाता है:

System.out.println(array.length); // Prints 0 in this case.

नोट : array.length ArrayList.size() विपरीत सरणी के वास्तविक आकार को लौटाती है और सरणी तत्वों की संख्या नहीं होती है, जो एक मान असाइन किए गए सरणी तत्वों की संख्या लौटाता है।

बहुआयामी सरणियों का निर्माण और आरंभ करना

बहु-आयामी सरणी बनाने का सबसे सरल तरीका इस प्रकार है:

int[][] a = new int[2][3];

यह दो तीन-लंबाई वाली int सरणियाँ बनाएगा- a[0] और a[1] । यह आयताकार बहु-आयामी सरणियों के शास्त्रीय, सी-शैली के आरंभ के समान है।

आप एक ही समय में बना और आरंभ कर सकते हैं:

int[][] a = { {1, 2}, {3, 4}, {5, 6} };

सी के विपरीत , जहां केवल आयताकार बहुआयामी सरणियों का समर्थन किया जाता है, आंतरिक सरणियों को एक ही लंबाई या उससे अधिक की आवश्यकता नहीं होती है:

int[][] a = { {1}, {2, 3}, null };

यहाँ, a[0] एक-लम्बाई का int सरणी है, जबकि a[1] एक दो-लंबाई वाला int सरणी है और a[2] null । इस तरह की सरणियों को दांतेदार सरणियाँ या रैग्ड सरणियाँ कहा जाता है, अर्थात् वे सरणियों के सरणियाँ हैं। जावा में बहुआयामी सरणियों को सरणियों के array[i][j][k] रूप में लागू किया जाता है, अर्थात array[i][j][k] ((array[i])[j])[k] array[i][j][k] के बराबर है। C # के विपरीत , सिंटैक्स array[i,j] जावा में समर्थित नहीं है।

जावा में बहुआयामी सरणी प्रतिनिधित्व

स्रोत - लाइव ऑन आइडोन

संदर्भ प्रकार सरणियों का निर्माण और आरंभ करना

String[] array6 = new String[] { "Laurel", "Hardy" }; // Create an array with new 
                                                      // operator and array initializer.
String[] array7 = { "Laurel", "Hardy" };              // Shortcut syntax with array 
                                                      // initializer.
String[] array8 = new String[3];                      // { null, null, null }
String[] array9 = null;                               // null

Ideone पर रहते हैं

ऊपर दिखाए गए String शाब्दिक और आदिम के अलावा, सरणी आरंभीकरण के लिए शॉर्टकट सिंटैक्स भी कैनोनिकल Object प्रकारों के साथ काम करता है:

Object[] array10 = { new Object(), new Object() };

क्योंकि सरणियाँ सहसंयोजक होती हैं, एक संदर्भ प्रकार के सरणी को एक उप-वर्ग के एक सरणी के रूप में आरंभीकृत किया जा सकता है, हालांकि यदि आप एक String अलावा किसी अन्य तत्व को सेट करने का प्रयास करते हैं, तो एक ArrayStoreException को फेंक दिया जाएगा:

Object[] array11 = new String[] { "foo", "bar", "baz" };
array11[1] = "qux"; // fine
array11[1] = new StringBuilder(); // throws ArrayStoreException

शॉर्टकट सिंटैक्स का उपयोग इसके लिए नहीं किया जा सकता है क्योंकि शॉर्टकट सिंटैक्स में एक निहित प्रकार की Object[] ।

String[] emptyArray = new String[0] का उपयोग शून्य तत्वों के साथ किया जा सकता है। String[] emptyArray = new String[0] । उदाहरण के लिए, शून्य लंबाई के साथ एक सरणी का उपयोग Collection से एक Array बनाने के लिए किया जाता है जब विधि को किसी ऑब्जेक्ट के रनटाइम प्रकार की आवश्यकता होती है।

दोनों आदिम और संदर्भ प्रकारों में, एक खाली सरणी आरंभीकरण (उदाहरण के लिए String[] array8 = new String[3] ) प्रत्येक डेटा प्रकार के लिए डिफ़ॉल्ट मान के साथ सरणी को आरंभीकृत करेगा।

जेनेरिक प्रकार सरणियों का निर्माण और आरंभ करना

सामान्य वर्गों में, सामान्य प्रकार के सरणियों को इस प्रकार से मिटाया नहीं जा सकता है, जैसे कि क्षरण के कारण:

public class MyGenericClass<T> {
    private T[] a;

    public MyGenericClass() {
        a = new T[5]; // Compile time error: generic array creation
    }
}

इसके बजाय, उन्हें निम्न विधियों में से एक का उपयोग करके बनाया जा सकता है: (ध्यान दें कि ये अनियंत्रित चेतावनी उत्पन्न करेंगे)

एक Object ऐरे बनाकर, और इसे जेनेरिक टाइप पर कास्टिंग करें:
```
a = (T[]) new Object[5];
```
यह सबसे सरल विधि है, लेकिन चूंकि अंतर्निहित सरणी अभी भी टाइप Object[] , इसलिए यह विधि टाइप सुरक्षा प्रदान नहीं करती है। इसलिए, सरणी बनाने की यह विधि केवल सामान्य वर्ग के भीतर ही उपयोग की जाती है - सार्वजनिक रूप से उजागर नहीं की जाती है।
एक वर्ग पैरामीटर के साथ Array.newInstance का उपयोग करके:
```
public MyGenericClass(Class<T> clazz) {
    a = (T[]) Array.newInstance(clazz, 5);
}
```
यहां T के वर्ग को स्पष्ट रूप से कंस्ट्रक्टर को पारित करना होगा। Array.newInstance का रिटर्न प्रकार हमेशा Object । हालाँकि, यह विधि अधिक सुरक्षित है क्योंकि नव निर्मित सरणी हमेशा T[] , और इसलिए इसे सुरक्षित रूप से बाह्यीकृत किया जा सकता है।

आरंभीकरण के बाद एक सरणी भरना

जावा एसई 1.2

Arrays.fill() का उपयोग आरंभीकरण के बाद उसी मान के साथ एक सरणी भरने के लिए किया जा सकता है:

Arrays.fill(array8, "abc");        // { "abc", "abc", "abc" }

Ideone पर रहते हैं

fill() भी सरणी के निर्दिष्ट सीमा के प्रत्येक तत्व के लिए एक मूल्य प्रदान कर सकते हैं:

Arrays.fill(array8, 1, 2, "aaa");  // Placing "aaa" from index 1 to 2.

Ideone पर रहते हैं

जावा एसई 8

जावा संस्करण 8 के बाद से, विधि setAll , और इसके Concurrent parallelSetAll setAll , का उपयोग सरणी के प्रत्येक तत्व को उत्पन्न मानों को सेट करने के लिए किया जा सकता है। इन विधियों को एक जनरेटर फ़ंक्शन पारित किया जाता है जो एक सूचकांक को स्वीकार करता है और उस स्थिति के लिए वांछित मूल्य देता है।

निम्न उदाहरण एक पूर्णांक सरणी बनाता है और इसके सभी तत्वों को उनके संबंधित सूचकांक मूल्य पर सेट करता है:

int[] array = new int[5];
Arrays.setAll(array, i -> i); // The array becomes { 0, 1, 2, 3, 4 }.

Ideone पर रहते हैं

अलग-अलग घोषणा और सरणियों का प्रारंभ

एक सरणी तत्व के लिए एक सूचकांक का मान एक पूर्ण संख्या (0, 1, 2, 3, 4, ...) होना चाहिए और सरणी की लंबाई से कम (अनुक्रमित शून्य-आधारित हैं)। अन्यथा, एक ArrayIndexOutOfBoundsException को फेंक दिया जाएगा:

int[] array9;             // Array declaration - uninitialized
array9 = new int[3];      // Initialize array  - { 0, 0, 0 }
array9[0] = 10;           // Set index 0 value - { 10, 0, 0 }
array9[1] = 20;           // Set index 1 value - { 10, 20, 0 }
array9[2] = 30;           // Set index 2 value - { 10, 20, 30 }

सरणी एरीलाइज़र शॉर्टकट सिंटैक्स के साथ Arrays को पुन: प्रारंभ नहीं किया जा सकता है

किसी सरणी इनिशलाइज़र के साथ एक शॉर्टकट सिंटैक्स के माध्यम से एक सरणी को फिर से इनिशियलाइज़ करना संभव नहीं है क्योंकि एक ऐरेना इनिशलाइज़र को केवल एक फील्ड डिक्लेरेशन या लोकल वैरिएबल डिक्लेरेशन में या एक ऐरे क्रिएशन एक्सप्रेशन के एक हिस्से के रूप में निर्दिष्ट किया जा सकता है।

हालांकि, एक नई सरणी बनाना संभव है और पुराने सरणी को संदर्भित करने के लिए उपयोग किए जा रहे चर को असाइन करना संभव है। जबकि यह परिणाम उस चर के द्वारा संदर्भित किया जाता है, जिसे फिर से आरंभ किया जा रहा है, चर सामग्री पूरी तरह से नया सरणी है। ऐसा करने के लिए, new ऑपरेटर को एक सरणी इनिशियलाइज़र के साथ इस्तेमाल किया जा सकता है और सरणी चर को सौंपा जा सकता है:

// First initialization of array
int[] array = new int[] { 1, 2, 3 };

// Prints "1 2 3 ".
for (int i : array) {
    System.out.print(i + " ");
}

// Re-initializes array to a new int[] array.
array = new int[] { 4, 5, 6 };

// Prints "4 5 6 ".
for (int i : array) {
    System.out.print(i + " ");
}

array = { 1, 2, 3, 4 }; // Compile-time error! Can't re-initialize an array via shortcut 
                        // syntax with array initializer.

Ideone पर रहते हैं

एक संग्रह से एक सरणी बनाना

java.util.Collection में दो तरीके एक संग्रह से एक सरणी बनाते हैं:

Object[] toArray() का उपयोग इस प्रकार किया जा सकता है:

जावा एसई 5

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// although set is a Set<String>, toArray() returns an Object[] not a String[]
Object[] objectArray = set.toArray();

<T> T[] toArray(T[] a) निम्नानुसार इस्तेमाल किया जा सकता है:

जावा एसई 5

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// The array does not need to be created up front with the correct size.
// Only the array type matters. (If the size is wrong, a new array will
// be created with the same type.)
String[] stringArray = set.toArray(new String[0]);  

// If you supply an array of the same size as collection or bigger, it
// will be populated with collection values and returned (new array
// won't be allocated)
String[] stringArray2 = set.toArray(new String[set.size()]);

उनके बीच का अंतर केवल अप्रकाशित बनाम टाइप किए गए परिणामों से अधिक है। उनका प्रदर्शन अलग-अलग हो सकता है (विवरण के लिए कृपया इस प्रदर्शन विश्लेषण अनुभाग को पढ़ें):

Object[] toArray() arraycopy का उपयोग करता है, जो T[] toArray(T[] a) में प्रयुक्त टाइप-चेक्ड arraycopy से बहुत तेज है।
T[] toArray(new T[non-zero-size]) को रनटाइम पर एरे को शून्य-आउट करने की आवश्यकता है, जबकि T[] toArray(new T[0]) नहीं है। इस तरह की परहेज पूर्व की तुलना में बाद की कॉल को तेज करता है। यहां विस्तृत विश्लेषण: पूर्वजों की बुद्धि की सरणियाँ ।

जावा एसई 8

जावा एसई 8+ से शुरू होकर, जहां Stream की अवधारणा को पेश किया गया है, Stream द्वारा निर्मित Stream का उपयोग करना Stream.toArray है।

String[] strings = list.stream().toArray(String[]::new);

जावा में स्टैक ओवरफ्लो पर दो जवाब ( 1 , 2 ) से 'ArrayList' को 'स्ट्रिंग []' में परिवर्तित करने के लिए ।

एक स्ट्रिंग के लिए आता है

जावा एसई 5

जावा 1.5 के बाद से आप इसके हर तत्व पर पुनरावृत्ति किए बिना निर्दिष्ट सरणी की सामग्री का एक String प्रतिनिधित्व प्राप्त कर सकते हैं। बस Arrays.toString(Object[]) लिए Arrays.toString(Object[]) या Arrays.deepToString(Object[]) उपयोग करें:

int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));      // [1, 2, 3, 4, 5]

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
System.out.println(Arrays.deepToString(arr));  // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Arrays.toString() विधि में Object.toString() का उपयोग करने के लिए Arrays.toString() विधि का उपयोग किया जाता है, जो Object.toString() टाइप एरे के बगल में हर आइटम के String मानों को उत्पन्न करता है, इसका उपयोग सभी प्रकार के एरे के लिए किया जा सकता है। उदाहरण के लिए:

public class Cat { /* implicitly extends Object */
    @Override
    public String toString() {
      return "CAT!";
    }
}

Cat[] arr = { new Cat(), new Cat() };
System.out.println(Arrays.toString(arr));        // [CAT!, CAT!]

यदि वर्ग के लिए कोई ओवरराइड toString() मौजूद नहीं है, तो Object से इनहेरिट की गई toString() उपयोग किया जाएगा। आमतौर पर आउटपुट तब बहुत उपयोगी नहीं होता है, उदाहरण के लिए:

public class Dog {
    /* implicitly extends Object */
}

Dog[] arr = { new Dog() };
System.out.println(Arrays.toString(arr));        // [Dog@17ed40e0]

एक सरणी से एक सूची बनाना

Arrays.asList() विधि का उपयोग दिए गए सरणी के तत्वों से युक्त निश्चित आकार की List को वापस करने के लिए किया जा सकता है। परिणामी List सरणी के आधार प्रकार के समान पैरामीटर प्रकार की होगी।

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = Arrays.asList(stringArray);

नोट : यह सूची मूल सरणी के ( एक दृश्य ) द्वारा समर्थित है, जिसका अर्थ है कि सूची में कोई भी परिवर्तन सरणी को बदल देगा और इसके विपरीत। हालांकि, उस सूची में परिवर्तन जो इसके आकार को बदल देगा (और इसलिए सरणी की लंबाई) एक अपवाद फेंक देगा।

सूची की एक प्रति बनाने के लिए, java.util.ArrayList के निर्माता का उपयोग करें। एक तर्क के रूप में एक Collection लेने के लिए java.util.ArrayList :

जावा एसई 5

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));

जावा एसई 7

जावा एसई 7 और बाद में, कोण ब्रैकेट्स की एक जोड़ी <> (प्रकार के तर्कों का खाली सेट) का उपयोग किया जा सकता है, जिसे डायमंड कहा जाता है। संकलक संदर्भ से प्रकार के तर्क निर्धारित कर सकता है। इसका मतलब यह है कि ArrayList के निर्माता को कॉल करते समय टाइप जानकारी को छोड़ा जा सकता है और संकलन के दौरान यह स्वचालित रूप से अनुमान लगाया जाएगा। इसे Type Inference कहते हैं जो Java Generics का एक हिस्सा है।

// Using Arrays.asList()

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));

// Using ArrayList.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(stringArray));

// Using Collections.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, stringArray);

डायमंड के बारे में ध्यान देने योग्य बात यह है कि इसका उपयोग बेनामी कक्षाओं के साथ नहीं किया जा सकता है।

जावा एसई 8

// Using Streams

int[] ints = {1, 2, 3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

String[] stringArray = {"foo", "bar", "baz"};
List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());

Arrays.asList () पद्धति का उपयोग करने से संबंधित महत्वपूर्ण नोट्स

इस विधि रिटर्न List है, जिनमें से एक उदाहरण है Arrays$ArrayList (के स्थिर भीतरी वर्ग Arrays ) और नहीं java.util.ArrayList । परिणामी List निश्चित आकार की है। इसका मतलब है, तत्वों को जोड़ना या निकालना समर्थित नहीं है और एक UnsupportedOperationException को फेंक देगा:
```
stringList.add("something"); // throws java.lang.UnsupportedOperationException
```
एक नई List एक सरणी समर्थित पारित करके बनाया जा सकता है List एक नया की निर्माता के लिए List । यह डेटा की एक नई प्रति बनाता है, जिसमें परिवर्तनशील आकार है और जो मूल सरणी द्वारा समर्थित नहीं है:
```
List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
```
एक आदिम सरणी पर <T> List<T> asList(T... a) , जैसे कि एक int[] , एक List<int[]> उत्पादन करेगा List<int[]> जिसका एकमात्र तत्व वास्तविक तत्वों के बजाय स्रोत आदिम सरणी है स्रोत के सरणी।
इस व्यवहार का कारण यह है कि सामान्य प्रकार के मापदंडों के स्थान पर आदिम प्रकारों का उपयोग नहीं किया जा सकता है, इसलिए इस मामले में पूरे आदिम सरणी सामान्य प्रकार के पैरामीटर को बदल देते हैं। आदेश में एक करने के लिए एक आदिम सरणी बदलने के लिए List , सब से पहले, आदिम सरणी इसी आवरण प्रकार की एक सरणी में कनवर्ट (यानी कॉल Arrays.asList एक पर Integer[] के बजाय एक के int[] )।
इसलिए, यह false होगा:
```
int[] arr = {1, 2, 3};      // primitive array of int
System.out.println(Arrays.asList(arr).contains(1));
```
डेमो देखें
दूसरी ओर, यह true :
```
Integer[] arr = {1, 2, 3};  // object array of Integer (wrapper for int)
System.out.println(Arrays.asList(arr).contains(1));
```
डेमो देखें
यह भी true , क्योंकि सरणी को एक Integer[] रूप में व्याख्या किया जाएगा:
```
System.out.println(Arrays.asList(1,2,3).contains(1));
```
डेमो देखें

बहुआयामी और दांतेदार Arrays

एक सरणी को एक से अधिक आयाम के साथ परिभाषित करना संभव है। एकल इंडेक्स प्रदान करके एक्सेस किए जाने के बजाय, प्रत्येक आयाम के लिए इंडेक्स निर्दिष्ट करके एक बहुआयामी सरणी एक्सेस किया जाता है।

बहुआयामी सरणी की घोषणा जोड़कर किया जा सकता है [] एक नियमित सरणी decleration के लिए प्रत्येक आयाम के लिए। उदाहरण के लिए, 2-आयामी int सरणी बनाने के लिए, घोषणा के लिए ब्रैकेट का एक और सेट जोड़ें, जैसे int[][] । यह 3-आयामी सरणियों ( int[][][] और इसके बाद के लिए जारी है।

तीन पंक्तियों और तीन स्तंभों के साथ 2-आयामी सरणी को परिभाषित करने के लिए:

int rows = 3;
int columns = 3;
int[][] table = new int[rows][columns];

सरणी को अनुक्रमित किया जा सकता है और इस निर्माण के साथ उस पर मान निर्दिष्ट कर सकते हैं। ध्यान दें कि असंबद्ध मान किसी सरणी के प्रकार के लिए डिफ़ॉल्ट मान हैं, इस स्थिति में int लिए 0 ।

table[0][0] = 0;
table[0][1] = 1;
table[0][2] = 2;

एक समय में एक आयाम को त्वरित करना भी संभव है, और यहां तक कि गैर-आयताकार सरणियां भी बनाते हैं। इन्हें आमतौर पर दांतेदार सरणियों के रूप में जाना जाता है।

int[][] nonRect = new int[4][];

यह ध्यान रखना महत्वपूर्ण है कि हालांकि दांतेदार सरणी के किसी भी आयाम को परिभाषित करना संभव है, यह पूर्ववर्ती स्तर को परिभाषित किया जाना चाहिए।

// valid
String[][] employeeGraph = new String[30][];

// invalid
int[][] unshapenMatrix = new int[][10];

// also invalid
int[][][] misshapenGrid = new int[100][][10];

कैसे जावा में बहुआयामी एरर्स का प्रतिनिधित्व किया जाता है

^{छवि स्रोत: http://math.hws.edu/eck/cs124/javanotes3/c8/s5.html}

दांतेदार सरणी शाब्दिक गहनता

बहुआयामी सरणियों और दांतेदार सरणियों को भी शाब्दिक अभिव्यक्ति के साथ आरंभ किया जा सकता है। निम्नलिखित घोषित करता है और एक 2x3 int सरणी को पॉप्युलेट करता है:

int[][] table = {
    {1, 2, 3},
    {4, 5, 6}
};

नोट : दांतेदार उप-नब्ज भी null हो सकते हैं। उदाहरण के लिए, निम्न कोड दो आयामी int सरणी को घोषित करता है और पॉप्युलेट करता है, जिसका पहला सबर्रे null , दूसरा सबर्रे शून्य लंबाई का है, तीसरा सबर्रे एक लंबाई का है और अंतिम सबरे एक दो लंबाई वाला सरणी है:

int[][] table = {
    null,
    {},
    {1},
    {1,2}
};

बहुआयामी सरणी के लिए अपने सूचकांकों द्वारा निम्न-स्तरीय आयाम की सरणियों को निकालना संभव है:

int[][][] arr = new int[3][3][3];
int[][] arr1 = arr[0]; // get first 3x3-dimensional array from arr
int[] arr2 = arr1[0]; // get first 3-dimensional array from arr1
int[] arr3 = arr[0]; // error: cannot convert from int[][] to int[]

सीमा अपवाद के बाहर सरणी सूचकांक

ArrayIndexOutOfBoundsException को तब फेंका जाता है जब किसी सरणी का गैर-मौजूदा इंडेक्स एक्सेस किया जा रहा हो।

सरणी शून्य-आधारित अनुक्रमित हैं, इसलिए पहले तत्व का सूचकांक 0 और अंतिम तत्व का सूचकांक सरणी क्षमता शून्य 1 (यानी array.length - 1 ) है।

इसलिए, सूचकांक द्वारा एक सरणी तत्व के लिए किसी भी अनुरोध i शर्त को पूरा करने के है 0 <= i < array.length , अन्यथा ArrayIndexOutOfBoundsException फेंक दिया जाएगा।

निम्न कोड एक सरल उदाहरण है जहां एक ArrayIndexOutOfBoundsException को फेंक दिया जाता है।

String[] people = new String[] { "Carol", "Andy" };

// An array will be created:
// people[0]: "Carol"
// people[1]: "Andy"

// Notice: no item on index 2. Trying to access it triggers the exception:
System.out.println(people[2]);  // throws an ArrayIndexOutOfBoundsException.

आउटपुट:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at your.package.path.method(YourClass.java:15)

ध्यान दें कि जिस अवैध सूचकांक तक पहुँचा जा रहा है, वह भी अपवाद में शामिल है (उदाहरण में 2 ); यह जानकारी अपवाद का कारण खोजने के लिए उपयोगी हो सकती है।

इससे बचने के लिए, बस जाँच करें कि सूचकांक सरणी की सीमा के भीतर है:

int index = 2;
if (index >= 0 && index < people.length) {
    System.out.println(people[index]);
}

एक ऐरे की लंबाई प्राप्त करना

Arrays ऐसी वस्तुएँ हैं जो निर्दिष्ट प्रकार के तत्वों के अपने आकार को संग्रहीत करने के लिए स्थान प्रदान करती हैं। सरणी बनाए जाने के बाद किसी सरणी का आकार संशोधित नहीं किया जा सकता है।

int[] arr1 = new int[0];
int[] arr2 = new int[2];
int[] arr3 = new int[]{1, 2, 3, 4};
int[] arr4 = {1, 2, 3, 4, 5, 6, 7};

int len1 = arr1.length; // 0
int len2 = arr2.length; // 2
int len3 = arr3.length; // 4
int len4 = arr4.length; // 7

किसी सरणी में length फ़ील्ड किसी सरणी का आकार संग्रहीत करता है। यह एक final क्षेत्र है और इसे संशोधित नहीं किया जा सकता है।

यह कोड एक सरणी की length और वस्तुओं की मात्रा के बीच का अंतर दिखाता है।

public static void main(String[] args) {
    Integer arr[] = new Integer[] {1,2,3,null,5,null,7,null,null,null,11,null,13};

    int arrayLength = arr.length;
    int nonEmptyElementsCount = 0;

    for (int i=0; i<arrayLength; i++) {
        Integer arrElt = arr[i];
        if (arrElt != null) {
            nonEmptyElementsCount++;
        }
    }

    System.out.println("Array 'arr' has a length of "+arrayLength+"\n"
                            + "and it contains "+nonEmptyElementsCount+" non-empty values");
}

परिणाम:

Array 'arr' has a length of 13
and it contains 7 non-empty values

समानता के लिए सरणियों की तुलना करना

सरणी प्रकार java.lang.Object से उनके equals() और ( hashCode() ) कार्यान्वयन विरासत में hashCode() हैं , इसलिए समान सरणी ऑब्जेक्ट के खिलाफ तुलना करने पर केवल equals() ही वापस आएंगे। अपने मूल्यों के आधार पर समानता के लिए सरणियों की तुलना करने के लिए, java.util.Arrays.equals उपयोग करें, जो सभी सरणी प्रकारों के लिए अतिभारित है।

int[] a = new int[]{1, 2, 3};
int[] b = new int[]{1, 2, 3};
System.out.println(a.equals(b)); //prints "false" because a and b refer to different objects
System.out.println(Arrays.equals(a, b)); //prints "true" because the elements of a and b have the same values

जब तत्व प्रकार एक संदर्भ प्रकार, है Arrays.equals() कॉल equals() समानता का निर्धारण करने के सरणी तत्वों पर। विशेष रूप से, यदि तत्व प्रकार स्वयं एक सरणी प्रकार है, तो पहचान तुलना का उपयोग किया जाएगा। समानता के लिए बहुआयामी सरणियों की तुलना करने के लिए, Arrays.deepEquals() को नीचे के बजाय प्रयोग करें:

int a[] = { 1, 2, 3 };
int b[] = { 1, 2, 3 };

Object[] aObject = { a }; // aObject contains one element
Object[] bObject = { b }; // bObject contains one element

System.out.println(Arrays.equals(aObject, bObject)); // false
System.out.println(Arrays.deepEquals(aObject, bObject));// true

क्योंकि सेट और मैप्स equals() और hashCode() उपयोग करते हैं, एरे आमतौर पर सेट एलिमेंट्स या मैप कीज के रूप में उपयोगी नहीं होते हैं। या तो उन्हें एक सहायक वर्ग में लपेटो जो सरणी तत्वों के संदर्भ में equals() और hashCode() को लागू करता है, या उन्हें List उदाहरणों में परिवर्तित करता है और सूचियों को संग्रहीत करता है।

स्ट्रीम करने के लिए पहुंचता है

जावा एसई 8

Stream करने के लिए ऑब्जेक्ट की एक सरणी परिवर्तित करना:

String[] arr = new String[] {"str1", "str2", "str3"};
Stream<String> stream = Arrays.stream(arr);

Arrays.stream() का उपयोग करके Stream करने के लिए प्राथमिकताओं की एक सरणी परिवर्तित करना Arrays.stream() स्ट्रीम की एक आदिम विशेषज्ञता के लिए सरणी को बदल देगा:

int[] intArr = {1, 2, 3};
IntStream intStream = Arrays.stream(intArr);

आप ऐरे में Stream को कई तत्वों तक सीमित कर सकते हैं। प्रारंभ सूचकांक समावेशी है और अंतिम सूचकांक विशिष्ट है:

int[] values = {1, 2, 3, 4};
IntStream intStream = Arrays.stream(values, 2, 4);

Arrays.stream() समान एक विधि Arrays.stream() Stream क्लास में दिखाई देती है: Stream.of() । अंतर यह है कि Stream.of() एक varargs पैरामीटर का उपयोग करता है, इसलिए आप कुछ इस तरह लिख सकते हैं:

Stream<Integer> intStream = Stream.of(1, 2, 3);
Stream<String> stringStream = Stream.of("1", "2", "3");
Stream<Double> doubleStream = Stream.of(new Double[]{1.0, 2.0});

सरणियों में परिवर्तन

आप लूप (उर्फ फॉरच) के लिए एन्हांस का उपयोग करके या सरणी सूचकांकों का उपयोग करके सरणियों पर पुनरावृति कर सकते हैं:

int[] array = new int[10];

// using indices: read and write
for (int i = 0; i < array.length; i++) {
    array[i] = i;
}

जावा एसई 5

// extended for: read only
for (int e : array) {
    System.out.println(e);
}

यहां यह ध्यान देने योग्य है कि एक ऐरे पर Iterator का उपयोग करने का कोई सीधा तरीका नहीं है, लेकिन Arrays लाइब्रेरी के माध्यम से इसे Iterable ऑब्जेक्ट प्राप्त करने के लिए आसानी से एक सूची में परिवर्तित किया जा सकता है।

बॉक्सिंग सरणियों के लिए Arrays.asList का उपयोग करें :

Integer[] boxed = {1, 2, 3};
Iterable<Integer> boxedIt = Arrays.asList(boxed); // list-backed iterable
Iterator<Integer> fromBoxed1 = boxedIt.iterator();

आदिम सरणियों (जावा 8 का उपयोग करके) धाराओं का उपयोग करें (विशेष रूप से इस उदाहरण में - Arrays.stream -> IntStream ):

int[] primitives = {1, 2, 3};
IntStream primitiveStream = Arrays.stream(primitives); // list-backed iterable
PrimitiveIterator.OfInt fromPrimitive1 = primitiveStream.iterator();

यदि आप स्ट्रीम (कोई जावा 8) का उपयोग नहीं कर सकते हैं, तो आप Google की अमरूद लाइब्रेरी का उपयोग करना चुन सकते हैं:

Iterable<Integer> fromPrimitive2 = Ints.asList(primitives);

दो-आयामी सरणियों या अधिक में, दोनों तकनीकों का उपयोग थोड़ा अधिक जटिल फैशन में किया जा सकता है।

उदाहरण:

int[][] array = new int[10][10];

for (int indexOuter = 0; indexOuter < array.length; indexOuter++) {
    for (int indexInner = 0; indexInner < array[indexOuter].length; indexInner++) {
        array[indexOuter][indexInner] = indexOuter + indexInner;
    }
}

जावा एसई 5

for (int[] numbers : array) {
    for (int value : numbers) {
        System.out.println(value);
    }
}

सूचकांक आधारित लूप का उपयोग किए बिना किसी भी गैर-समान मूल्य पर एक ऐरे को सेट करना असंभव है।

बेशक, आप सूचकांकों का उपयोग while या लूप do-while while भी उपयोग कर सकते हैं।

सावधानी का एक नोट: सरणी सूचकांकों का उपयोग करते समय, सुनिश्चित करें कि सूचकांक 0 और array.length - 1 (दोनों समावेशी) के बीच है। सरणी लंबाई पर हार्ड कोडित धारणा न करें अन्यथा यदि आप सरणी लंबाई में परिवर्तन करते हैं तो आपके कोड को तोड़ सकते हैं लेकिन आपके हार्ड कोडित मान नहीं हैं।

उदाहरण:

int[] numbers = {1, 2, 3, 4};

public void incrementNumbers() {
    // DO THIS :
    for (int i = 0; i < numbers.length; i++) {
        numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;      
    }
 
    // DON'T DO THIS :
    for (int i = 0; i < 4; i++) {
        numbers[i] += 1;
    }
}

यदि आप सूचकांक प्राप्त करने के लिए फैंसी गणनाओं का उपयोग नहीं करते हैं, तो यह सबसे अच्छा है, लेकिन सूचकांक को पुन: उपयोग करने के लिए और यदि आपको विभिन्न मानों की गणना करने की आवश्यकता है।

उदाहरण:

public void fillArrayWithDoubleIndex(int[] array) {
    // DO THIS :
    for (int i = 0; i < array.length; i++) {
        array[i] = i * 2;
    }
 
    // DON'T DO THIS :
    int doubleLength = array.length * 2;
    for (int i = 0; i < doubleLength; i += 2) {
        array[i / 2] = i;
    }
}

उल्टे क्रम में पहुंचता है

int[] array = {0, 1, 1, 2, 3, 5, 8, 13};
for (int i = array.length - 1; i >= 0; i--) {
   System.out.println(array[i]);
}

कोड पुनरावृत्ति को कम करने के लिए अस्थायी एरर्स का उपयोग करना

कोड दोहराने के बजाय एक अस्थायी सरणी पर इरेट करना आपके कोड को क्लीनर बना सकता है। इसका उपयोग किया जा सकता है जहां एक ही ऑपरेशन कई चर पर किया जाता है।

// we want to print out all of these
String name = "Margaret";
int eyeCount = 16;
double height = 50.2;
int legs = 9;
int arms = 5;


// copy-paste approach:
System.out.println(name);
System.out.println(eyeCount);
System.out.println(height);
System.out.println(legs);
System.out.println(arms);


// temporary array approach:
for(Object attribute : new Object[]{name, eyeCount, height, legs, arms})
    System.out.println(attribute);

// using only numbers
for(double number : new double[]{eyeCount, legs, arms, height})
    System.out.println(Math.sqrt(number));

ध्यान रखें कि इस कोड का उपयोग प्रदर्शन-महत्वपूर्ण खंडों में नहीं किया जाना चाहिए, क्योंकि लूप में प्रवेश करने पर हर बार एक सरणी बनाई जाती है, और यह कि आदिम चर को सरणी में कॉपी किया जाएगा और इस प्रकार संशोधित नहीं किया जा सकता है।

प्रतिलिपि बनाना

किसी सरणी को कॉपी करने के लिए जावा कई तरीके प्रदान करता है।

पाश के लिए

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length]; 
for (int i = 0; i < a.length; i++) {
    b[i] = a[i];
}

ध्यान दें कि आदिम सरणी के बजाय ऑब्जेक्ट सरणी के साथ इस विकल्प का उपयोग करने से कॉपी मूल सामग्री के संदर्भ में भर जाएगी।

Object.clone ()

चूंकि सरणियाँ जावा में Object s हैं, आप Object.clone() उपयोग कर सकते हैं।

int[] a = { 4, 1, 3, 2 };
int[] b = a.clone(); // [4, 1, 3, 2]

ध्यान दें कि किसी सरणी के लिए Object.clone विधि उथली प्रतिलिपि का प्रदर्शन करती है, अर्थात यह एक नए सरणी के लिए एक संदर्भ देता है जो स्रोत सरणी के समान तत्वों का संदर्भ देता है।

Arrays.copyOf ()

java.util.Arrays एक सरणी की प्रतिलिपि दूसरे को निष्पादित करने का एक आसान तरीका प्रदान करता है। यहाँ मूल उपयोग है:

int[] a = {4, 1, 3, 2};
int[] b = Arrays.copyOf(a, a.length); // [4, 1, 3, 2]

ध्यान दें कि Arrays.copyOf भी एक अधिभार प्रदान करता है जो आपको सरणी के प्रकार को बदलने की अनुमति देता है:

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

System.arraycopy ()

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) निर्दिष्ट सरणी से एक सरणी की प्रतिलिपि public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) निर्दिष्ट स्थान पर शुरुआत, गंतव्य सरणी की निर्दिष्ट स्थिति तक।

उपयोग के एक उदाहरण के नीचे

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, a.length); // [4, 1, 3, 2]

Arrays.copyOfRange ()

मुख्य रूप से एक ऐरे के एक हिस्से को कॉपी करने के लिए उपयोग किया जाता है, आप इसे नीचे दिए गए अनुसार पूरे सरणी को कॉपी करने के लिए भी उपयोग कर सकते हैं:

int[] a = { 4, 1, 3, 2 };
int[] b = Arrays.copyOfRange(a, 0, a.length); // [4, 1, 3, 2]

कास्टिंग कास्टिंग

सरणी वस्तुएं हैं, लेकिन उनका प्रकार निहित वस्तुओं के प्रकार से परिभाषित होता है। इसलिए, कोई केवल A[] को T[] में शामिल नहीं कर सकता है, लेकिन विशिष्ट A[] प्रत्येक A सदस्य को T ऑब्जेक्ट में डाला जाना चाहिए। सामान्य उदाहरण:

public static <T, A> T[] castArray(T[] target, A[] array) {
    for (int i = 0; i < array.length; i++) {
        target[i] = (T) array[i];
    }
    return target;
}

इस प्रकार, एक A[] सरणी दिया:

T[] target = new T[array.Length];
target = castArray(target, array);

जावा एसई इस उद्देश्य के लिए Arrays.copyOf(original, newLength, newType) विधि प्रदान करता है:

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

किसी सरणी से एक तत्व निकालें

जावा किसी तत्व को किसी सरणी से निकालने के लिए java.util.Arrays में एक सीधी विधि प्रदान नहीं करता है। इसे निष्पादित करने के लिए, आप मूल सरणी को हटाने के लिए तत्व के बिना किसी नए को कॉपी कर सकते हैं या अपने सरणी को हटाकर किसी अन्य संरचना में परिवर्तित कर सकते हैं।

ArrayList का उपयोग करना

आप एरे को java.util.List बदल सकते हैं। लिस्ट करें, एलीमेंट को हटा दें और सूची को वापस ऐरे में बदलें।

String[] array = new String[]{"foo", "bar", "baz"};

List<String> list = new ArrayList<>(Arrays.asList(array));
list.remove("foo");

// Creates a new array with the same size as the list and copies the list
// elements to it.
array = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(array)); //[bar, baz]

System.arraycopy का उपयोग करना

System.arraycopy() का उपयोग मूल सरणी की प्रतिलिपि बनाने और आपके इच्छित तत्व को निकालने के लिए किया जा सकता है। एक उदाहरण के नीचे:

int[] array = new int[] { 1, 2, 3, 4 }; // Original array.
int[] result = new int[array.length - 1]; // Array which will contain the result.
int index = 1; // Remove the value "2".

// Copy the elements at the left of the index.
System.arraycopy(array, 0, result, 0, index);
// Copy the elements at the right of the index.
System.arraycopy(array, index + 1, result, index, array.length - index - 1);

System.out.println(Arrays.toString(result)); //[1, 3, 4]

Apache Commons Lang का उपयोग करना

किसी तत्व को आसानी से हटाने के लिए, आप अपाचे कॉमन्स लैंग लाइब्रेरी और विशेष रूप से क्लास ArrayUtils के स्टैटिक मेथड removeElement() का उपयोग कर सकते हैं। एक उदाहरण के नीचे:

int[] array = new int[]{1,2,3,4};
array = ArrayUtils.removeElement(array, 2); //remove first occurrence of 2
System.out.println(Arrays.toString(array)); //[1, 3, 4]

ऐरे कोवरियनस

ऑब्जेक्ट सरणियां सहसंयोजक होती हैं, जिसका अर्थ है कि जैसे Integer Number का एक उपवर्ग है, वैसे ही Integer[] Number[] का एक उपवर्ग है Number[] । यह सहज लग सकता है, लेकिन आश्चर्यजनक व्यवहार के परिणामस्वरूप हो सकता है:

Integer[] integerArray = {1, 2, 3};
Number[] numberArray = integerArray;  // valid
Number firstElement = numberArray[0]; // valid
numberArray[0] = 4L;                  // throws ArrayStoreException at runtime

हालाँकि Integer[] Number[] का एक उपवर्ग है Number[] , यह केवल Integer s को ही धारण कर सकता है, और एक Long element को असाइन करने की कोशिश में एक रनटाइम अपवाद फेंकता है।

ध्यान दें कि यह व्यवहार सरणियों के लिए अद्वितीय है, और इसके बजाय एक सामान्य List का उपयोग करके बचा जा सकता है:

List<Integer> integerList = Arrays.asList(1, 2, 3);
//List<Number> numberList = integerList;  // compile error
List<? extends Number> numberList = integerList;
Number firstElement = numberList.get(0);
//numberList.set(0, 4L);                  // compile error

यह सभी प्रकार के तत्व तत्वों को एक ही प्रकार साझा करने के लिए आवश्यक नहीं है, जब तक कि वे सरणी के प्रकार के उपवर्ग हैं:

interface I {}

class A implements I {}
class B implements I {}
class C implements I {}

I[] array10 = new I[] { new A(), new B(), new C() }; // Create an array with new
                                                     // operator and array initializer.

I[] array11 = { new A(), new B(), new C() };         // Shortcut syntax with array
                                                     // initializer.

I[] array12 = new I[3];                              // { null, null, null }

I[] array13 = new A[] { new A(), new A() };          // Works because A implements I.

Object[] array14 = new Object[] { "Hello, World!", 3.14159, 42 }; // Create an array with
                                                     // new operator and array initializer.

Object[] array15 = { new A(), 64, "My String" };     // Shortcut syntax 
                                                     // with array initializer.

आप किसी सरणी का आकार कैसे बदलेंगे?

इसका सरल उत्तर यह है कि आप ऐसा नहीं कर सकते। एक बार एक सरणी बना लेने के बाद, इसका आकार नहीं बदला जा सकता है। इसके बजाय, एक सरणी को उचित आकार के साथ एक नया सरणी बनाकर और मौजूदा सरणी से नए को तत्वों को कॉपी करके केवल "आकार परिवर्तन" किया जा सकता है।

String[] listOfCities = new String[3];   // array created with size 3.
listOfCities[0] = "New York";
listOfCities[1] = "London";
listOfCities[2] = "Berlin";

(उदाहरण के लिए) मान लीजिए कि एक नए तत्व के लिए जोड़ा जा करने की जरूरत है listOfCities सरणी से ऊपर के रूप में परिभाषित। ऐसा करने के लिए, आपको निम्न की आवश्यकता होगी:

आकार 4 के साथ एक नई सरणी बनाएं,
पुराने सरणी के मौजूदा 3 तत्वों को 0, 1 और 2 पर नए सरणी में कॉपी करें, और
ऑफसेट 3 पर नए सरणी में नया तत्व जोड़ें।

उपरोक्त करने के विभिन्न तरीके हैं। जावा 6 से पहले, सबसे संक्षिप्त तरीका था:

String[] newArray = new String[listOfCities.length + 1];
System.arraycopy(listOfCities, 0, newArray, 0, listOfCities.length);
newArray[listOfCities.length] = "Sydney";

जावा 6 के बाद से, Arrays.copyOf और Arrays.copyOfRange तरीके इसे और अधिक सरलता से कर सकते हैं:

String[] newArray = Arrays.copyOf(listOfCities, listOfCities.length + 1);
newArray[listOfCities.length] = "Sydney";

किसी सरणी को कॉपी करने के अन्य तरीकों के लिए, निम्न उदाहरण देखें। ध्यान रखें कि आकार बदलने पर आपको एक अलग लंबाई के साथ एक सरणी प्रति की आवश्यकता होती है।

प्रतिलिपि बनाना

एक बेहतर विकल्प सरणी आकार देने के लिए

ऊपर वर्णित एक सरणी का आकार बदलने के साथ दो बड़ी कमियां हैं:

यह अक्षम है। एक सरणी को बड़ा (या छोटा) बनाने में कई या सभी मौजूदा तत्व तत्वों की प्रतिलिपि बनाना और एक नई सरणी ऑब्जेक्ट आवंटित करना शामिल है। यह सरणी जितनी बड़ी होगी, उतनी ही महंगी होगी।
आपको किसी भी "लाइव" चर को अपडेट करने में सक्षम होने की आवश्यकता है जिसमें पुराने सरणी के संदर्भ हैं।

एक विकल्प के साथ शुरू करने के लिए एक बड़े पर्याप्त आकार के साथ सरणी बनाने के लिए है। यह केवल व्यवहार्य है यदि आप सरणी को आवंटित करने से पहले उस आकार को सटीक रूप से निर्धारित कर सकते हैं। यदि आप ऐसा नहीं कर सकते हैं, तो फिर से आकार बदलने की समस्या उत्पन्न होती है।

अन्य विकल्प जावा एसई वर्ग पुस्तकालय या एक तृतीय-पक्ष पुस्तकालय द्वारा प्रदान की गई डेटा संरचना वर्ग का उपयोग करना है। उदाहरण के लिए, जावा एसई "संग्रह" फ्रेमवर्क विभिन्न रनटाइम गुणों के साथ List , Set और Map एपीआई के कार्यान्वयन की एक संख्या प्रदान करता है। ArrayList वर्ग एक सादे सरणी (जैसे O (N) लुकअप, O (1) मिलता है और सेट, O (N) यादृच्छिक सम्मिलन और विलोपन) की प्रदर्शन विशेषताओं के सबसे निकट है) संदर्भ अद्यतन समस्या के बिना अधिक कुशल आकार प्रदान करते हुए।

( ArrayList लिए आकार परिवर्तन की क्षमता प्रत्येक आकार पर बैकिंग एरे के आकार को दोगुना करने की अपनी रणनीति से आती है। एक विशिष्ट उपयोग-मामले के लिए, इसका मतलब है कि आप केवल कभी-कभी आकार बदलते हैं। जब आप सूची के जीवनकाल में परिशोधन करते हैं, तो रिसाइज़ लागत। प्रति प्रविष्टि O(1) । एक सादा सरणी का आकार बदलने पर एक ही रणनीति का उपयोग करना संभव हो सकता है।)

एक सरणी में एक तत्व ढूँढना

किसी सरणी में मान का स्थान खोजने के कई तरीके हैं। निम्नलिखित उदाहरण स्निपेट मानते हैं कि सरणी निम्नलिखित में से एक है:

  String[] strings = new String[] { "A", "B", "C" };
  int[] ints = new int[] { 1, 2, 3, 4 };

इसके अलावा, हर एक index या index index2 को या तो आवश्यक तत्व के इंडेक्स में सेट करता है, या -1 मौजूद नहीं होने पर।

`Arrays.binarySearch` का उपयोग करना (केवल हल किए गए सरणियों के लिए)

  int index = Arrays.binarySearch(strings, "A");
  int index2 = Arrays.binarySearch(ints, 1);

`Arrays.asList` का उपयोग करना (केवल गैर-आदिम सरणियों के लिए)

  int index = Arrays.asList(strings).indexOf("A");
  int index2 = Arrays.asList(ints).indexOf(1);  // compilation error

`Stream` का उपयोग करना

जावा एसई 8

  int index = IntStream.range(0, strings.length)
                       .filter(i -> "A".equals(strings[i]))
                       .findFirst()
                       .orElse(-1); // If not present, gives us -1.
  // Similar for an array of primitives

लूप का उपयोग करके रैखिक खोज

  int index = -1;
  for (int i = 0; i < array.length; i++) {
      if ("A".equals(array[i])) {
          index = i;
          break;
      }            
  }
  // Similar for an array of primitives

रैखिक खोज जैसे org.apache.commons के रूप में तीसरे पक्ष के पुस्तकालयों का उपयोग कर

  int index = org.apache.commons.lang3.ArrayUtils.contains(strings, "A");
  int index2 = org.apache.commons.lang3.ArrayUtils.contains(ints, 1);

नोट: प्रत्यक्ष रेखीय खोज का उपयोग करना सूची में लपेटने से अधिक कुशल है।

यदि किसी एलीमेंट में कोई तत्व है तो परीक्षण करना

ऊपर दिए गए उदाहरणों का परीक्षण करने के लिए अनुकूलित किया जा सकता है यदि सरणी में केवल परीक्षण करके एक तत्व होता है यह देखने के लिए कि क्या सूचकांक गणना अधिक या शून्य के बराबर है।

वैकल्पिक रूप से, कुछ और संक्षिप्त रूप भी हैं:

boolean isPresent = Arrays.asList(strings).contains("A");

जावा एसई 8

boolean isPresent = Stream<String>.of(strings).anyMatch(x -> "A".equals(x));

boolean isPresent = false;
for (String s : strings) {
    if ("A".equals(s)) {
        isPresent = true;
        break;
    }
}

boolean isPresent = org.apache.commons.lang3.ArrayUtils.contains(ints, 4);

क्रमबद्ध सरणियाँ

Arrays एपीआई के साथ छँटाई सरणियों को आसानी से किया जा सकता है।

import java.util.Arrays;

// creating an array with integers
int[] array = {7, 4, 2, 1, 19};
// this is the sorting part just one function ready to be used
Arrays.sort(array);
// prints [1, 2, 4, 7, 19]
System.out.println(Arrays.toString(array));

स्ट्रिंग सरणियों को क्रमबद्ध करना:

String एक संख्यात्मक डेटा नहीं है, यह परिभाषित करता है कि यह खुद का आदेश है जिसे लेक्सिकोग्राफ़िक ऑर्डर कहा जाता है, जिसे अल्फाबेटिक ऑर्डर भी कहा जाता है। जब आप क्रमबद्ध sort() विधि का उपयोग करते हुए स्ट्रिंग की एक सरणी को sort() करते हैं, तो यह सरणी को तुलनात्मक इंटरफ़ेस द्वारा परिभाषित प्राकृतिक क्रम में क्रमबद्ध करता है, जैसा कि नीचे दिखाया गया है:

बढ़ता हुआ क्रम

String[] names = {"John", "Steve", "Shane", "Adam", "Ben"};
System.out.println("String array before sorting : " + Arrays.toString(names));
Arrays.sort(names); 
System.out.println("String array after sorting in ascending order : " + Arrays.toString(names));

आउटपुट:

String array before sorting : [John, Steve, Shane, Adam, Ben]    
String array after sorting in ascending order : [Adam, Ben, John, Shane, Steve]

घटता क्रम

Arrays.sort(names, 0, names.length, Collections.reverseOrder());
System.out.println("String array after sorting in descending order : " + Arrays.toString(names));

आउटपुट:

String array after sorting in descending order : [Steve, Shane, John, Ben, Adam]

ऑब्जेक्ट सरणी को सॉर्ट करना

ऑब्जेक्ट एरे को क्रमबद्ध करने के लिए, सभी तत्वों को सॉर्टिंग के क्रम को परिभाषित करने के लिए Comparable या Comparator इंटरफेस को लागू करना चाहिए।

हम किसी वस्तु सरणी को उसके प्राकृतिक क्रम पर क्रमबद्ध करने के लिए sort(Object[]) विधि का उपयोग कर सकते हैं, लेकिन आपको यह सुनिश्चित करना होगा कि सरणी के सभी तत्व Comparable लागू हों।

इसके अलावा, वे, और साथ ही परस्पर तुलनीय होना चाहिए के लिए उदाहरण e1.compareTo(e2) एक फेंक नहीं होना चाहिए ClassCastException सरणी में किसी भी तत्व के लिए E1 और E2। वैकल्पिक रूप से आप निम्न उदाहरण में दिखाए गए अनुसार sort(T[], Comparator) विधि का उपयोग करके कस्टम ऑर्डर पर ऑब्जेक्ट सरणी सॉर्ट कर सकते हैं।

// How to Sort Object Array in Java using Comparator and Comparable
Course[] courses = new Course[4];
courses[0] = new Course(101, "Java", 200);
courses[1] = new Course(201, "Ruby", 300);
courses[2] = new Course(301, "Python", 400);
courses[3] = new Course(401, "Scala", 500);
       
System.out.println("Object array before sorting : " + Arrays.toString(courses));
       
Arrays.sort(courses);
System.out.println("Object array after sorting in natural order : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.PriceComparator());
System.out.println("Object array after sorting by price : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.NameComparator());
System.out.println("Object array after sorting by name : " + Arrays.toString(courses));

आउटपुट:

Object array before sorting : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting in natural order : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by price : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by name : [#101 Java@200 , #301 Python@400 , #201 Ruby@300 , #401 Scala@500 ]

आदिम और बॉक्सिंग प्रकारों के बीच सरणियों को परिवर्तित करना

कभी-कभी आदिम प्रकार के बॉक्सिंग प्रकारों में रूपांतरण आवश्यक है।

सरणी बदलने के लिए, धाराओं का उपयोग करना संभव है (जावा 8 और इसके बाद के संस्करण में):

जावा एसई 8

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = 
    Arrays.stream(primitiveArray).boxed().toArray(Integer[]::new);

निचले संस्करणों के साथ यह आदिम सरणी को पुनरावृत्त करके और इसे स्पष्ट रूप से बॉक्सिंग सरणी में कॉपी करके हो सकता है:

जावा एसई 8

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = new Integer[primitiveArray.length];
for (int i = 0; i < primitiveArray.length; ++i) {
    boxedArray[i] = primitiveArray[i]; // Each element is autoboxed here
}

इसी तरह, एक बॉक्सिंग ऐरे को उसके आदिम समकक्ष के एक ऐरे में बदला जा सकता है:

जावा एसई 8

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = 
    Arrays.stream(boxedArray).mapToInt(Integer::intValue).toArray();

जावा एसई 8

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = new int[boxedArray.length];
for (int i = 0; i < boxedArray.length; ++i) {
    primitiveArray[i] = boxedArray[i]; // Each element is outboxed here
}

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

परिचय

वाक्य - विन्यास

पैरामीटर

एरे बनाना और आरंभ करना

बुनियादी मामलों

एरे, कलेक्शन और स्ट्रीम्स

पहचान

आदिम प्रकार सरणियों का निर्माण और आरंभ करना

बहुआयामी सरणियों का निर्माण और आरंभ करना

जावा में बहुआयामी सरणी प्रतिनिधित्व

संदर्भ प्रकार सरणियों का निर्माण और आरंभ करना

जेनेरिक प्रकार सरणियों का निर्माण और आरंभ करना

आरंभीकरण के बाद एक सरणी भरना

अलग-अलग घोषणा और सरणियों का प्रारंभ

सरणी एरीलाइज़र शॉर्टकट सिंटैक्स के साथ Arrays को पुन: प्रारंभ नहीं किया जा सकता है

एक संग्रह से एक सरणी बनाना

एक स्ट्रिंग के लिए आता है

एक सरणी से एक सूची बनाना

Arrays.asList () पद्धति का उपयोग करने से संबंधित महत्वपूर्ण नोट्स

बहुआयामी और दांतेदार Arrays

कैसे जावा में बहुआयामी एरर्स का प्रतिनिधित्व किया जाता है

सीमा अपवाद के बाहर सरणी सूचकांक

एक ऐरे की लंबाई प्राप्त करना

समानता के लिए सरणियों की तुलना करना

स्ट्रीम करने के लिए पहुंचता है

सरणियों में परिवर्तन

प्रतिलिपि बनाना

पाश के लिए

Object.clone ()

Arrays.copyOf ()

System.arraycopy ()

Arrays.copyOfRange ()

कास्टिंग कास्टिंग

किसी सरणी से एक तत्व निकालें

ArrayList का उपयोग करना

System.arraycopy का उपयोग करना

Apache Commons Lang का उपयोग करना

ऐरे कोवरियनस

आप किसी सरणी का आकार कैसे बदलेंगे?

एक बेहतर विकल्प सरणी आकार देने के लिए

एक सरणी में एक तत्व ढूँढना

Arrays.binarySearch का उपयोग करना (केवल हल किए गए सरणियों के लिए)

Arrays.asList का उपयोग करना (केवल गैर-आदिम सरणियों के लिए)

Stream का उपयोग करना

लूप का उपयोग करके रैखिक खोज

रैखिक खोज जैसे org.apache.commons के रूप में तीसरे पक्ष के पुस्तकालयों का उपयोग कर

यदि किसी एलीमेंट में कोई तत्व है तो परीक्षण करना

क्रमबद्ध सरणियाँ

आदिम और बॉक्सिंग प्रकारों के बीच सरणियों को परिवर्तित करना

`Arrays.binarySearch` का उपयोग करना (केवल हल किए गए सरणियों के लिए)

`Arrays.asList` का उपयोग करना (केवल गैर-आदिम सरणियों के लिए)

`Stream` का उपयोग करना