array in java in hindi




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

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


जावा 9 में

IntStream.iterate(...) विधियों का उपयोग करना:

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]

ArrayList घोषित करने और आरंभ करने का एक और तरीका:

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

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

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

उदाहरण के लिए आदिम प्रकार 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); उपयोग कर सकते हैं (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[] रूप में माना जाता है। Type... केवल विधि पैरामीटर में उपयोग किया जा सकता है, इसलिए int... i = new int[] {} संकलित नहीं होगा।

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

बहुआयामी Arrays

बहुआयामी सरणी से निपटने के लिए बहुत कठिन हैं। अनिवार्य रूप से, एक 2 डी सरणी सरणी की एक सरणी है। int[][] मतलब int[] s की एक सरणी है। कुंजी यह है कि यदि एक 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]

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

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
    }
}

कक्षा वस्तुओं के सरणी बनाने के लिए आप 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
}

जावा 8 में आप इस तरह उपयोग कर सकते हैं।

String[] strs = IntStream.range(0, 15)  // 15 is the size
    .mapToObj(i -> Integer.toString(i))
    .toArray(String[]::new);

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

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

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


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

 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];

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

Type[] name = new Type[5];

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

आप पहले से मौजूद मानों के साथ सरणी भी बना सकते हैं, जैसे कि

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

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


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

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

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


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

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

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[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]




declare