दिलचस्प पोस्ट
मैं PHP में एक अतुल्यकालिक GET अनुरोध कैसे कर सकता हूं? कैसे कैश रिक्त करें और सभी लक्ष्यों को साफ करें Xcode 4 और बाद में मायसाम बनाम इनोएडीबी 'If' स्टेटमेंट के अंत में अर्धविराम पायथन में टिल्ड ऑपरेटर खोज के लिए शांत यूआरएल डिजाइन लगातार डुप्लिकेट शब्द के लिए नियमित अभिव्यक्ति ऐप स्टोर पर ऐप के साथ कैसे जुड़ें एचटीएमएल से पीडीएफ जेनरेट करने के लिए wkhtmltopdf कॉलिंग 1 और 100 के बीच अद्वितीय यादृच्छिक संख्या उत्पन्न करें एनजी-दोहराना फ़िल्टरिंग डेटा दिनांक सीमा के अनुसार Z- INDEX का न्यूनतम और अधिकतम मान आप साइगविन पर विंडोज में क्रॉन्टाब कैसे चलाते हैं? क्रोम में सेलेनियम वेबड्रायवर परीक्षण के मामलों को चलाने के लिए कैसे? आप Xib फ़ाइलों से कस्टम UITableViewCells कैसे लोड करते हैं?

मैं जावा में एक सरणी को कैसे घोषित और आरम्भ करूं?

मैं जावा में एक सरणी को कैसे घोषित और आरम्भ करूं?

वेब के समाधान से एकत्रित समाधान "मैं जावा में एक सरणी को कैसे घोषित और आरम्भ करूं?"

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

आदिम प्रकारों के लिए:

int[] myIntArray = new int[3]; int[] myIntArray = {1,2,3}; int[] myIntArray = new int[]{1,2,3}; 

कक्षाओं के लिए, उदाहरण के लिए String , यह वही है:

 String[] myStringArray = new String[3]; String[] myStringArray = {"a","b","c"}; String[] myStringArray = new String[]{"a","b","c"}; 

आरंभ करने का तीसरा तरीका उपयोगी है जब आप पहले सरणी को घोषित करते हैं और फिर इसे आरंभ करते हैं। कास्ट यहाँ आवश्यक है

 String[] myStringArray; myStringArray = new String[]{"a","b","c"}; 

दो प्रकार के सरणी हैं।

एक आयामी सरणी

डिफ़ॉल्ट मानों के लिए सिंटैक्स:

 int[] num = new int[5]; 

या (कम पसंदीदा)

 int num[] = new int[5]; 

दिए गए मानों के साथ सिंटैक्स (वैरिएबल / फील्ड इनिशियलाइज़ेशन):

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

या (कम पसंदीदा)

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

नोट: सुविधा int [] के लिए num बेहतर है क्योंकि यह स्पष्ट रूप से बताता है कि आप सरणी के बारे में यहां बात कर रहे हैं। अन्यथा कोई अंतर नहीं हर्गिज नहीं।

बहुआयामी सरणी

घोषणा

 int[][] num = new int[5][2]; 

या

 int num[][] = new int[5][2]; 

या

 int[] num[] = new int[5][2]; 

प्रारंभ

  num[0][0]=1; num[0][1]=2; num[1][0]=1; num[1][1]=2; num[2][0]=1; num[2][1]=2; num[3][0]=1; num[3][1]=2; num[4][0]=1; num[4][1]=2; 

या

  int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} }; 

रग्गी सरणी (या गैर-आयताकार अर्रे)

  int[][] num = new int[5][]; num[0] = new int[1]; num[1] = new int[5]; num[2] = new int[2]; num[3] = new int[3]; 

तो यहां हम कॉलम स्पष्ट रूप से परिभाषित कर रहे हैं।
दूसरा रास्ता:

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

तक पहुंचने के लिए:

 for (int i=0; i<(num.length); i++ ) { for (int j=0;j<num[i].length;j++) System.out.println(num[i][j]); } 

वैकल्पिक रूप से:

 for (int[] a : num) { for (int i : a) { System.out.println(i); } } 

खड़ी सरणियां बहुआयामी arrays हैं।
विवरण के लिए आधिकारिक जावा ट्यूटोरियल पर बहुआयामी सरणी विवरण देखें

 Type[] variableName = new Type[capacity]; Type[] variableName = {comma-delimited values}; Type variableName[] = new Type[capacity]; Type variableName[] = {comma-delimited values}; 

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

ऐसे कई तरीके हैं जिनमें आप जावा में एक सरणी को घोषित कर सकते हैं:

 float floatArray[]; //initialize later int[] integerArray = new int[10]; String[] array = new String[] {"a", "b"}; 

आप सूर्य ट्यूटोरियल साइट और जावाडाक पर अधिक जानकारी पा सकते हैं।

मुझे लगता है कि यदि आप प्रत्येक भाग को समझते हैं तो यह सहायक है:

 Type[] name = new Type[5]; 

Type[] नामक चर का नाम है ("नाम" को पहचानकर्ता कहा जाता है) शाब्दिक "प्रकार" आधार प्रकार है, और कोष्ठक का अर्थ है कि यह आधार का सरणी प्रकार है। सरणी प्रकार अपने स्वयं के मोड़ प्रकार में होते हैं, जो आपको बहुआयामी arrays जैसे Type[][] (सरणी प्रकार प्रकार []) करने की अनुमति देता है। new कीवर्ड नए सरणी के लिए मेमोरी आवंटित करने के लिए कहता है। ब्रैकेट के बीच की संख्या कहती है कि नई सरणी कितनी बड़ी होगी और कितनी मेमोरी आवंटित होगी। उदाहरण के लिए, अगर जावा जानता है कि आधार प्रकार Type 32 बाइट्स लेता है, और आप आकार 5 की एक सरणी चाहते हैं, तो इसे आंतरिक रूप से 32 * 5 = 160 बाइट आवंटित करना होगा।

आप पहले से ही मूल्यों के साथ arrays भी बना सकते हैं, जैसे कि

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

जो न केवल खाली जगह बनाता है बल्कि उन मानों के साथ भरता है। जावा यह बता सकता है कि primitives integers हैं और उनमें से 5 हैं, इसलिए सरणी का आकार निहित रूप से निर्धारित किया जा सकता है।

निम्नलिखित एक सरणी की घोषणा को दर्शाता है, लेकिन सरणी को प्रारंभ नहीं किया गया है:

  int[] myIntArray = new int[3]; 

निम्नलिखित घोषणा को दिखाता है साथ ही साथ सरणी का आरंभीकरण भी दिखाता है:

 int[] myIntArray = {1,2,3}; 

अब, निम्नलिखित में भी घोषणा और साथ ही सरणी के प्रारंभिक रूप से पता चलता है:

 int[] myIntArray = new int[]{1,2,3}; 

लेकिन यह तीसरा व्यक्ति अज्ञात सरणी-ऑब्जेक्ट निर्माण की संपत्ति को दर्शाता है जो एक संदर्भ चर "myIntArray" द्वारा इंगित किया जाता है, इसलिए यदि हम सिर्फ "नए int [] {1,2,3};" लिखते हैं तो यह कैसे अज्ञात सरणी-ऑब्जेक्ट बनाया जा सकता है।

अगर हम सिर्फ लिखते हैं:

 int[] myIntArray; 

यह सरणी की घोषणा नहीं है, लेकिन निम्नलिखित बयान उपरोक्त घोषणा पूर्ण करता है:

 myIntArray=new int[3]; 

इसके अलावा, यदि आप कुछ और गतिशील चाहते हैं तो सूची इंटरफ़ेस है। यह अच्छी तरह से प्रदर्शन नहीं करेगा, लेकिन अधिक लचीला है:

 List<String> listOfString = new ArrayList<String>(); listOfString.add("foo"); listOfString.add("bar"); String value = listOfString.get(0); assertEquals( value, "foo" ); 

वैकल्पिक रूप से,

 // Either method works String arrayName[] = new String[10]; String[] arrayName = new String[10]; 

वह एक सरणी की घोषणा करता है जिसे आकार 10 नामक सरणी नाम arrayName है (आपके पास तत्वों का उपयोग करने के लिए 9 से 9 है)।

एक सरणी बनाने के दो मुख्य तरीके हैं:

यह एक खाली सरणी के लिए:

 int[] array = new int[n]; // "n" being the number of spaces to allocate in the array 

और यह एक, एक प्रारंभिक सरणी के लिए:

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

आप बहुआयामी arrays भी बना सकते हैं, जैसे:

 int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...}; 

उदाहरण के लिए आदिम प्रकार का int लें घोषित करने और int सरणी के कई तरीके हैं:

 int[] i = new int[capacity]; int[] i = new int[] {value1, value2, value3, etc}; int[] i = {value1, value2, value3, etc}; 

जहां इन सब में, आप int i[] बजाय int[] i उपयोग कर सकते हैं int[] i

प्रतिबिंब के साथ, आप (Type[]) Array.newInstance(Type.class, capacity); उपयोग कर सकते हैं (Type[]) Array.newInstance(Type.class, capacity);

ध्यान दें कि विधि पैरामीटर में, ... variable arguments इंगित करता variable arguments । अनिवार्य रूप से, पैरामीटर की कोई भी संख्या ठीक है। कोड के साथ समझा जाना आसान है:

 public static void varargs(int fixed1, String fixed2, int... varargs) {...} ... varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100} varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200}; 

विधि के अंदर, varargs को एक सामान्य int[] रूप में माना जाता है int[] Type... उपयोग केवल विधि पैरामीटर में किया जा सकता है, इसलिए int... i = new int[] {} संकलन नहीं करेगा।

ध्यान दें कि जब कोई विधि int[] या किसी अन्य Type[] को पारित करते हैं, तो आप तीसरे मार्ग का उपयोग नहीं कर सकते। बयान int[] i = *{a, b, c, d, etc}* , संकलक यह मानता है कि {...} मतलब है एक int[] लेकिन इसका कारण यह है कि आप एक वैरिएबल घोषित कर रहे हैं। जब कोई विधि में सरणी गुजरती है, तो घोषणा या तो new Type[capacity] होनी चाहिए new Type[capacity] या new Type[] {...}

बहुआयामी सरणी

बहुआयामी arrays के साथ निपटने के लिए बहुत कठिन हैं। अनिवार्य रूप से, 2 डी सरणी सरणी का सरणी है int[][] अर्थ है int[] कुंजी यह है कि यदि कोई int[][] को int[x][y] घोषित किया जाता है, तो अधिकतम अनुक्रमणिका i[x-1][y-1] है i[x-1][y-1] मूलतः, एक आयताकार int[3][5] है:

 [0, 0] [1, 0] [2, 0] [0, 1] [1, 1] [2, 1] [0, 2] [1, 2] [2, 2] [0, 3] [1, 3] [2, 3] [0, 4] [1, 4] [2, 4] 

यदि आप प्रतिबिंबों का उपयोग कर सरणी बनाना चाहते हैं तो आप ऐसा कर सकते हैं:

  int size = 3; int[] intArray = (int[]) Array.newInstance(int.class, size ); 

ऑब्जेक्ट संदर्भों की एक सरणी घोषित करना:

 class Animal {} class Horse extends Animal { public static void main(String[] args) { /* * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed) */ Animal[] a1 = new Animal[10]; a1[0] = new Animal(); a1[1] = new Horse(); /* * Array of Animal can hold Animal and Horse and all subtype of Horse */ Animal[] a2 = new Horse[10]; a2[0] = new Animal(); a2[1] = new Horse(); /* * Array of Horse can hold only Horse and its subtype (if any) and not allowed supertype of Horse nor other subtype of Animal. */ Horse[] h1 = new Horse[10]; h1[0] = new Animal(); // Not allowed h1[1] = new Horse(); /* * This can not be declared. */ Horse[] h2 = new Animal[10]; // Not allowed } } 

सरणी वस्तुओं की एक अनुक्रमिक सूची है

 int item = value; int [] one_dimensional_array = { value, value, value, .., value }; int [][] two_dimensional_array = { { value, value, value, .. value }, { value, value, value, .. value }, .. .. .. .. { value, value, value, .. value } }; 

यदि यह एक वस्तु है, तो यह एक ही अवधारणा है

 Object item = new Object(); Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() }; Object [][] two_dimensional_array = { { new Object(), new Object(), .. new Object() }, { new Object(), new Object(), .. new Object() }, .. .. .. { new Object(), new Object(), .. new Object() } }; 

ऑब्जेक्ट्स के मामले में, आपको इसे new Type(..) का इस्तेमाल करने के लिए इसे आरंभ करने के लिए या तो उसे null करने की आवश्यकता है, String और Integer जैसी कक्षाएं विशेष मामले हैं जिन्हें निम्नलिखित के रूप में नियंत्रित किया जाएगा

 String [] a = { "hello", "world" }; // is equivalent to String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) }; Integer [] b = { 1234, 5678 }; // is equivalent to Integer [] b = { new Integer(1234), new Integer(5678) }; 

सामान्य तौर पर आप एरेज़ बना सकते हैं जो कि M आयामी है

 int [][]..[] array = // ^ M times [] brackets {{..{ // ^ M times { bracket // this is array[0][0]..[0] // ^ M times [0] }}..} // ^ M times } bracket ; 

यह ध्यान देने योग्य है कि स्पेस के मामले में एक M आयामी सरणी बनाना महंगा है। जब आप सभी आयामों पर N साथ एक M आयामी सरणी बनाते हैं, तो सरणी का कुल आकार N^M से बड़ा होता है, चूंकि प्रत्येक सरणी का कोई संदर्भ होता है, और एम-आयाम पर एक (एम -1) है – संदर्भ के आयामी सरणी कुल आकार निम्नानुसार है

 Space = N^M + N^(M-1) + N^(M-2) + .. + N^0 // ^ ^ array reference // ^ actual data 

वर्ग ऑब्जेक्ट के एरेज़ बनाने के लिए आप java.util.ArrayList उपयोग कर सकते हैं एक सरणी परिभाषित करने के लिए:

 public ArrayList<ClassName> arrayName; arrayName = new ArrayList<ClassName>(); 

सरणी को मान असाइन करें:

 arrayName.add(new ClassName(class parameters go here); 

सरणी से पढ़ें:

 ClassName variableName = arrayName.get(index); 

ध्यान दें:

variableName सरणी का एक संदर्भ है जिसका अर्थ है कि variableName को जोड़कर arrayName को हेरफेर arrayName होगा

छोरों के लिए:

 //repeats for every value in the array for (ClassName variableName : arrayName){ } //Note that using this for loop prevents you from editing arrayName 

लूप के लिए जो आपको arrayName को संपादित करने की अनुमति देता है (लूप के लिए पारंपरिक):

 for (int i = 0; i < arrayName.size(); i++){ //manipulate array here } 

ArrayList को घोषित और प्रारंभ करने का दूसरा तरीका:

 private List<String> list = new ArrayList<String>(){{ add("e1"); add("e2"); }}; 

जावा 8 और बाद के संस्करण के लिए घोषणा और आरंभ करें सरल पूर्णांक सरणी बनाएं:

 int [] a1 = IntStream.range(1, 20).toArray(); System.out.println(Arrays.toString(a1)); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 

[-50, 50 के बीच पूर्णांक के लिए यादृच्छिक सरणी बनाएं] और डबल (0, 1 ई 17) के लिए:

 int [] a2 = new Random().ints(15, -50, 50).toArray(); double [] a3 = new Random().doubles(5, 0, 1e17).toArray(); 

दो अनुक्रमों की शक्ति:

 double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray(); System.out.println(Arrays.toString(a4)); // output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0] 

स्ट्रिंग के लिए [] आपको एक कन्स्ट्रक्टर निर्दिष्ट करना होगा

 String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new); System.out.println(Arrays.toString(a5)); 

बहुआयामी सरणी:

 String [][] a6 = List.of(new String[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"}) .toArray(new String[0][]); System.out.println(Arrays.deepToString(a6)); // output: [[a, b, c], [d, e, f, g]] 
 int[] SingleDimensionalArray = new int[2] int[][] MultiDimensionalArray = new int[3][4]