मैं जावा में किसी ऐरे को कैसे घोषित और आरंभ कर सकता हूं?
जवाबों:
आप या तो सरणी घोषणापत्र या सरणी शाब्दिक का उपयोग कर सकते हैं (लेकिन केवल जब आप घोषित करते हैं और चर को तुरंत प्रभावित करते हैं, सरणी सरणी को किसी सरणी को पुन: असाइन करने के लिए उपयोग नहीं किया जा सकता है)।
आदिम प्रकारों के लिए:
int[] myIntArray = new int[3];
int[] myIntArray = {1, 2, 3};
int[] myIntArray = new int[]{1, 2, 3};
// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html
int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort कक्षाओं के लिए 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"};return {1,2,3}एक त्रुटि देता है, जबकि return new int[]{1,2,3}ठीक काम करता है (यह मानते हुए कि आपका फ़ंक्शन पूर्णांक सरणी देता है)।
दो प्रकार के सरणी हैं।
डिफ़ॉल्ट मानों के लिए सिंटैक्स:
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 [] संख्या बेहतर है क्योंकि यह स्पष्ट रूप से बताता है कि आप यहाँ सरणी के बारे में बात कर रहे हैं। नहीं तो कोई फर्क नहीं। हर्गिज नहीं।
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);
}
}रग्ड सरणियाँ बहुआयामी सरणियाँ हैं।
स्पष्टीकरण के लिए आधिकारिक जावा ट्यूटोरियल में बहुआयामी सरणी विवरण देखें
Type[] variableName = new Type[capacity];
Type[] variableName = {comma-delimited values};
Type variableName[] = new Type[capacity];
Type variableName[] = {comma-delimited values};यह भी मान्य है, लेकिन मैं प्रकार के बाद कोष्ठक पसंद करता हूं, क्योंकि यह देखना आसान है कि चर का प्रकार वास्तव में एक सरणी है।
int[] a, b;नहीं होगा int a[], b;।
ऐसे कई तरीके हैं जिनसे आप जावा में एक सरणी घोषित कर सकते हैं:
float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};आप सूर्य ट्यूटोरियल साइट और जावाडॉक में अधिक जानकारी पा सकते हैं ।
मुझे लगता है कि यह उपयोगी है यदि आप प्रत्येक भाग को समझते हैं:
Type[] name = new Type[5];Type[]चर के प्रकार को नाम कहा जाता है ("नाम" को पहचानकर्ता कहा जाता है )। शाब्दिक "प्रकार" आधार प्रकार है, और कोष्ठक का मतलब है कि यह आधार का सरणी प्रकार है। सरणी प्रकार अपने स्वयं के बदले प्रकार हैं, जो आपको बहुआयामी सरणियों को बनाने की अनुमति देता है जैसे (प्रकार का प्रकार [])। कीवर्ड नई सरणी के लिए मेमोरी आवंटित करने के लिए कहता है। ब्रैकेट के बीच की संख्या कहती है कि नई सरणी कितनी बड़ी होगी और कितनी मेमोरी आवंटित करनी है। उदाहरण के लिए, यदि जावा को पता है कि आधार प्रकार 32 बाइट्स लेता है, और आप आकार 5 चाहते हैं, तो उसे आंतरिक रूप से 32 * 5 = 160 बाइट्स आवंटित करने की आवश्यकता है।Type[][]newType
आप वहां पहले से मौजूद मानों के साथ सरणियाँ भी बना सकते हैं, जैसे कि
int[] name = {1, 2, 3, 4, 5};जो न केवल खाली जगह बनाता है बल्कि उन मूल्यों से भरता है। जावा बता सकता है कि आदिम पूर्णांक हैं और उनमें से 5 हैं, इसलिए सरणी का आकार अनुमानित रूप से निर्धारित किया जा सकता है।
int[] name = new int[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];वैकल्पिक रूप से,
// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];यह एक सरणी की घोषणा करता है जिसे arrayNameआकार 10 कहा जाता है (आपके पास उपयोग करने के लिए 9 से तत्व 0 हैं)।
इसके अलावा, यदि आप कुछ अधिक गतिशील चाहते हैं तो सूची इंटरफ़ेस है। यह उतना अच्छा प्रदर्शन नहीं करेगा, लेकिन अधिक लचीला है:
List<String> listOfString = new ArrayList<String>();
listOfString.add("foo");
listOfString.add("bar");
String value = listOfString.get(0);
assertEquals( value, "foo" );Listएक सामान्य वर्ग है, इसमें एक पैरामीटर के रूप में एक प्रकार है, जो संलग्न है <>। यह मदद करता है क्योंकि आपको केवल एक बार एक सामान्य प्रकार को परिभाषित करने की आवश्यकता है और आप इसे कई अलग-अलग प्रकारों के साथ उपयोग कर सकते हैं। अधिक विस्तृत विवरण के लिए docs.oracle.com/javase/tutorial/java/generics/types.html
एक सरणी बनाने के दो मुख्य तरीके हैं:
यह एक खाली सरणी के लिए:
int[] array = new int[n]; // "n" being the number of spaces to allocate in the arrayऔर यह एक, एक आरंभिक सरणी के लिए:
int[] array = {1,2,3,4 ...};आप इस तरह बहुआयामी सरणियाँ भी बना सकते हैं:
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।
प्रतिबिंब के साथ, आप उपयोग कर सकते हैं (Type[]) Array.newInstance(Type.class, capacity);
ध्यान दें कि विधि मापदंडों में, ...इंगित करता है 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[]। Type...केवल विधि मापदंडों में उपयोग किया जा सकता है, इसलिए int... i = new int[] {}संकलन नहीं होगा।
ध्यान दें कि int[]किसी विधि (या किसी अन्य Type[]) को पास करते समय, आप तीसरे तरीके का उपयोग नहीं कर सकते हैं। बयान में int[] i = *{a, b, c, d, etc}*, संकलक मानता है कि {...}साधन ए int[]। लेकिन ऐसा इसलिए है क्योंकि आप एक चर घोषित कर रहे हैं। किसी सरणी को किसी विधि से पास करते समय, घोषणा या तो होनी चाहिए new Type[capacity]याnew Type[] {...} ।
बहुआयामी सरणियों से निपटने के लिए बहुत कठिन हैं। अनिवार्य रूप से, एक 2D सरणी सरणियों का एक सरणी है। int[][]का मतलब सरणी है int[]। कुंजी यह है कि अगर एक के int[][]रूप में घोषित किया जाता है int[x][y], तो अधिकतम सूचकांक है 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]विभिन्न IntStream.iterateऔर IntStream.takeWhileविधियों का उपयोग करना :
int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();
Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();
Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]स्थानीय परिवर्तनीय प्रकार का प्रयोग :
var letters = new String[]{"A", "B", "C"};यदि आप प्रतिबिंबों का उपयोग करके ऐरे बनाना चाहते हैं तो आप ऐसा कर सकते हैं:
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() }
};वस्तुओं के मामले में, आपको nullउन्हें उपयोग करने के लिए आरंभ करने के लिए इसे निर्दिष्ट करने की आवश्यकता है new Type(..), जैसे कक्षाएं 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अंतरिक्ष के संदर्भ में एक आयामी सरणी बनाना महंगा है। जब से आप सभी Mआयामों के साथ एक आयामी सरणी बनाते हैं, सरणी Nका कुल आकार से बड़ा होता है N^M, क्योंकि प्रत्येक सरणी में एक संदर्भ होता है, और एम-आयाम पर संदर्भों का एक (एम -1)-आयामी आयाम होता है। कुल आकार निम्नानुसार है
Space = N^M + N^(M-1) + N^(M-2) + .. + N^0
// ^ ^ array reference
// ^ actual dataJava 8 में आप इस तरह का उपयोग कर सकते हैं।
String[] strs = IntStream.range(0, 15) // 15 is the size
.mapToObj(i -> Integer.toString(i))
.toArray(String[]::new);क्लास ऑब्जेक्ट की सरणियाँ बनाने के लिए आप इसका उपयोग कर सकते हैं 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
छोरों के लिए:
//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
}जावा 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, 1E17] के बीच पूर्णांकों के लिए एक यादृच्छिक सरणी बनाएँ:
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]]ArrayList को घोषित करने और आरंभ करने का दूसरा तरीका:
private List<String> list = new ArrayList<String>(){{
add("e1");
add("e2");
}};यहाँ बहुत सारे उत्तर हैं। मैं सरणियाँ बनाने के लिए कुछ ट्रिकी तरीके जोड़ रहा हूँ ( परीक्षा के दृष्टिकोण से यह जानना अच्छा है)
एक सरणी को घोषित और परिभाषित करें
int intArray[] = new int[3];यह लंबाई की एक सरणी बनाएगा 3. जैसा कि यह एक आदिम प्रकार धारण करता है, int, सभी मान डिफ़ॉल्ट रूप से 0 पर सेट होते हैं। उदाहरण के लिए,
intArray[2]; // Will return 0चर नाम से पहले बॉक्स कोष्ठक [] का उपयोग करना
int[] intArray = new int[3];
intArray[0] = 1; // Array content is now {1, 0, 0}आरंभ और सरणी को डेटा प्रदान करते हैं
int[] intArray = new int[]{1, 2, 3};इस बार बॉक्स ब्रैकेट में आकार का उल्लेख करने की कोई आवश्यकता नहीं है। यहां तक कि इसका एक सरल रूप है:
int[] intArray = {1, 2, 3, 4};लंबाई की एक सरणी ०
int[] intArray = new int[0];
int length = intArray.length; // Will return length 0बहुआयामी सरणियों के लिए भी ऐसा ही है
int intArray[][] = new int[2][3];
// This will create an array of length 2 and
//each element contains another array of length 3.
// { {0,0,0},{0,0,0} }
int lenght1 = intArray.length; // Will return 2
int length2 = intArray[0].length; // Will return 3चर से पहले बॉक्स कोष्ठक का उपयोग करना:
int[][] intArray = new int[2][3];यह बिल्कुल ठीक है यदि आप अंत में एक बॉक्स ब्रैकेट रखते हैं:
int[] intArray [] = new int[2][4];
int[] intArray[][] = new int[2][3][4]कुछ उदाहरण
int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}}
// All the 3 arrays assignments are valid
// Array looks like {{1,2,3},{4,5,6}}यह अनिवार्य नहीं है कि प्रत्येक आंतरिक तत्व एक ही आकार का हो।
int [][] intArray = new int[2][];
intArray[0] = {1,2,3};
intArray[1] = {4,5};
//array looks like {{1,2,3},{4,5}}
int[][] intArray = new int[][2] ; // This won't compile. Keep this in mind.यदि आप उपरोक्त सिंटैक्स का उपयोग कर रहे हैं, तो आपको यह सुनिश्चित करना होगा कि आगे की दिशा आपको बॉक्स कोष्ठक में मान निर्दिष्ट करनी है। और यह संकलन नहीं होगा। कुछ उदाहरण:
int [][][] intArray = new int[1][][];
int [][][] intArray = new int[1][2][];
int [][][] intArray = new int[1][2][3];एक अन्य महत्वपूर्ण विशेषता सहसंयोजक है
Number[] numArray = {1,2,3,4}; // java.lang.Number
numArray[0] = new Float(1.5f); // java.lang.Float
numArray[1] = new Integer(1); // java.lang.Integer
// You can store a subclass object in an array that is declared
// to be of the type of its superclass.
// Here 'Number' is the superclass for both Float and Integer.
Number num[] = new Float[5]; // This is also validमहत्वपूर्ण: संदर्भित प्रकारों के लिए, सरणी में संग्रहीत डिफ़ॉल्ट मान शून्य है।
आप इसके साथ भी कर सकते हैं java.util.Arrays:
List<String> number = Arrays.asList("1", "2", "3");
Out: ["1", "2", "3"]यह एक बहुत सरल और सीधा है।
स्थानीय चर प्रकार के अनुमानों के साथ आपको केवल एक बार प्रकार बताना होगा:
var values = new int[] { 1, 2, 3 };या
int[] values = { 1, 2, 3 }var।
var openjdk.java.net/jeps/286
ऐरे के दो बुनियादी प्रकार हैं।
स्टेटिक ऐरे: फिक्स्ड साइज ऐरे (इसका आकार शुरुआत में घोषित किया जाना चाहिए और बाद में इसे बदला नहीं जा सकता)
डायनामिक एरे: इसके लिए कोई आकार सीमा नहीं मानी जाती है। (जावा में शुद्ध गतिशील सरणियाँ मौजूद नहीं हैं। इसके बजाय, सूची को सबसे अधिक प्रोत्साहित किया गया है)
पूर्णांक, स्ट्रिंग, फ्लोट, आदि का एक स्थिर सरणी घोषित करने के लिए ... बलो घोषणा और आरंभीकरण बयानों का उपयोग करें।
int[] intArray = new int[10];
String[] intArray = new int[10];
float[] intArray = new int[10];
// here you have 10 index starting from 0 to 9गतिशील सुविधाओं का उपयोग करने के लिए, आपको सूची का उपयोग करना होगा ... सूची शुद्ध गतिशील सरणी है और शुरुआत में आकार घोषित करने की आवश्यकता नहीं है। बोला JAVA> में सूची घोषित करने का उचित तरीका है
ArrayList<String> myArray = new ArrayList<String>();
myArray.add("Value 1: something");
myArray.add("Value 2: something more");घोषणा को छोड़ें: int[] arr;
प्रारंभिक ऐरे: int[] arr = new int[10];10 सरणी में अनुमत तत्वों की संख्या का प्रतिनिधित्व करता है
घोषणा बहु आयामी: int[][] arr;
प्रारंभिक बहुआयामी सरणी: int[][] arr = new int[10][17];10 पंक्तियों और 17 स्तंभों और 170 तत्वों क्योंकि 10 गुणा 17 170 है।
किसी सरणी को आरम्भ करने का अर्थ है उसके आकार को निर्दिष्ट करना।
किसी ऐरे को घोषित करना और आरंभ करना बहुत आसान है। उदाहरण के लिए, आप पाँच पूर्णांक तत्वों को सहेजना चाहते हैं जो एक सरणी में 1, 2, 3, 4 और 5 हैं। आप इसे निम्नलिखित तरीके से कर सकते हैं:
ए)
int[] a = new int[5];या
ख)
int[] a = {1, 2, 3, 4, 5};इसलिए मूल पैटर्न विधि के आधार पर आरंभीकरण और घोषणा के लिए है:
datatype[] arrayname = new datatype[requiredarraysize];datatype निचले मामले में होना चाहिए।
इसलिए मूल पैटर्न विधि द्वारा आरंभीकरण और घोषणा के लिए है:
यदि यह एक स्ट्रिंग सरणी है:
String[] a = {"as", "asd", "ssd"};यदि यह एक चरित्र सरणी है:
char[] a = {'a', 's', 'w'};फ्लोट डबल के लिए, सरणी का प्रारूप पूर्णांक के समान होगा।
उदाहरण के लिए:
double[] a = {1.2, 1.3, 12.3};लेकिन जब आप ऐरे को "विधि" से घोषित करते हैं और शुरू करते हैं, तो आपको मैन्युअल रूप से या लूप या कुछ और से मान दर्ज करना होगा।
लेकिन जब आप इसे "विधि b" द्वारा करते हैं, तो आपको मैन्युअल रूप से मान दर्ज नहीं करना होगा।
सरणी में प्राइमरी डेटा प्रकार के साथ-साथ श्रेणी की वस्तुओं के अनुसार सरणी की परिभाषा हो सकती है। आदिम डेटा प्रकारों के मामले में, वास्तविक मान सन्निहित स्मृति स्थानों में संग्रहीत किए जाते हैं। एक वर्ग की वस्तुओं के मामले में, वास्तविक वस्तुओं को ढेर खंड में संग्रहीत किया जाता है।
वन-डायमेंशनल एरे:
एक-आयामी सरणी घोषणा का सामान्य रूप है
type var-name[];
OR
type[] var-name;जावा में एक ऐरे को इंस्टेंट करना
var-name = new type [size];उदाहरण के लिए
int intArray[]; //declaring array
intArray = new int[20]; // allocating memory to array
// the below line is equals to line1 + line2
int[] intArray = new int[20]; // combining both statements in one
int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };
// accessing the elements of the specified array
for (int i = 0; i < intArray.length; i++)
System.out.println("Element at index " + i + " : "+ intArray[i]);फिल्मों के वर्ग के साथ एक और पूर्ण उदाहरण movies
public class A {
public static void main(String[] args) {
class Movie{
String movieName;
String genre;
String movieType;
String year;
String ageRating;
String rating;
public Movie(String [] str)
{
this.movieName = str[0];
this.genre = str[1];
this.movieType = str[2];
this.year = str[3];
this.ageRating = str[4];
this.rating = str[5];
}
}
String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};
Movie mv = new Movie(movieDetailArr);
System.out.println("Movie Name: "+ mv.movieName);
System.out.println("Movie genre: "+ mv.genre);
System.out.println("Movie type: "+ mv.movieType);
System.out.println("Movie year: "+ mv.year);
System.out.println("Movie age : "+ mv.ageRating);
System.out.println("Movie rating: "+ mv.rating);
}
} int[] SingleDimensionalArray = new int[2]
int[][] MultiDimensionalArray = new int[3][4]