वन-डाइमेंशनल एरे (One Dimensional Array)

जावा में वन-डाइमेंशनल एरे को new आॅपरेटर की सहायता से निम्न प्रकार बनाया जा सकता है-

एरे में वैल्यू निम्नानुसार स्टोर/प्रयोग की जा सकती है-

a[0] = 45;
a[1] = 488;
a[2] = 17;

या

int a[] = {45, 488, 17};

या

int a[] = new int{45, 488, 17};

नीचे दिए गए उदाहरण में एक एरे में पांच संख्याएं स्टोर कर उन्हें प्रिंट करवाया गया है।

class demo
{
  public static void main(String arrr[])
  {
    int a[]=new int[5];
    a[0] = 45;
    a[1] = 488;
    a[2] = -248;
    a[3] = 14;
    a[4] = 158;

    System.out.println("You entered: " + a[0]);
    System.out.println("You entered: " + a[1]);
    System.out.println("You entered: " + a[2]);
    System.out.println("You entered: " + a[3]);
    System.out.println("You entered: " + a[4]);
  }
}

Output:

You entered: 45
You entered: 488
You entered: -248
You entered: 14
You entered: 158

नीचे दिए गए उदाहरण में पाँच संख्याओं का एक एरे बनाया गया है तथा उनकी डिफ़ॉल्ट वैल्यूज को प्रिंट कराया गया है. गया है।

import java.util.*;
class demo
{
  public static void main(String[] args)
  {
	int a[];	//declaration of array
	a = new int[5];  //memory allocation

	for(int i=0; i<5; i++)
		System.out.print(a[i] + " ");	//default values
  }
}

Output:

0 0 0 0 0

नीचे दिए गए उदाहरण में पाँच संख्याओं का एक एरे बनाया गया है तथा उसमें यूज़र से वैल्यूज़ लेकर उन्हे प्रिन्ट किया गया है।

import java.util.*;
class demo
{
  public static void main(String arrr[])
  {
    int a[] = new int[5];
    int c;
      Scanner ob = new Scanner(System.in);
      for(c=0; c<=4; c++)
      {
        System.out.print("Enter a no.: ");
        a[c] = ob.nextInt();
      }
      System.out.println("You entered -");
      for(c=0; c<=4; c++)
      {
        System.out.print(a[c] + " ");
      }
  }
}

Output:

Enter a no.: 3
Enter a no.: 2
Enter a no.: 5
Enter a no.: 1
Enter a no.: 7
You entered -
3 2 5 1 7

length प्राॅपर्टी

एरे की length प्राॅपर्टी का प्रयोग एरे में उपस्थित एलीमेंट्स की संख्या ज्ञात करने के लिए किया जाता है। यह प्राॅपर्टी फिक्स होती है अर्थात् इसकी वैल्यू को परिवर्तित नहीं किया जा सकता है। निम्नलिखित उदाहरण में एरे के एलीमेंट्स को प्रिंट कराने के लिए लूप में length प्राॅपर्टी का प्रयोग किया गया हैः

class Demo
{
	public static void main(String[] args)
	{
		int a[] = new int[]{10, 20, 30};
		for(int i=0; i < a.length; i++)
		{
			System.out.print(a[i] + "\t");
		}
	}
}

Output:

10      20      30

उपरोक्त उदाहरण में एरे को डिक्लेयर करते समय ही उसे इनीशियलाइज़ कर दिया गया है। ध्यान दें कि इनीशियलाइज़ेशन के समय एरे का साइज़ नहीं दिया जाता है।

उदाहरणः निम्नलिखित उदाहरण में स्ट्रिंग के ऐरे को बना कर उसे प्रिंट कराया गया है.

class Demo {
  public static void main(String[] args)
  {
    String a[] = {"Anil", "Sunil", "Ajay", "Vijay"};

    for(int i=0; i < a.length; i++)
	System.out.print(a[i] + " ");
  }
}

Output:

Anil Sunil Ajay Vijay 

ध्यान दें, जावा में स्ट्रिंग करैक्टर ऐरे नहीं होते हैं और ना ही वो null द्वारा टर्मिनेट होते हैं.

उदाहरणः निम्नलिखित उदाहरण में ऐरे का साइज़ यूजर से पूछ कर सेट किया गया है.

import java.util.Scanner;
class Main
{
	public static void main(String[] args)
	{
		int size;
		Scanner ob = new Scanner(System.in);
		System.out.print("Enter size for array: ");
		size = ob.nextInt();
		int a[] = new int[size];

		for(int i=0; i < a.length; i++)
			System.out.print(a[i] + " ");
	}
}

Output:

Enter size for array: 3
0 0 0

उदाहरणः निम्नलिखित उदाहरण में ऐरे का साइज़ रन टाइम पर परिवर्तित किया गया है.

class Main
{
	public static void main(String[] args)
	{
		int a[];
		a = new int[3];
		for(int i=0; i < a.length; i++)
			System.out.print(a[i] + " ");

		System.out.println();

		a = new int[5];
		for(int i=0; i < a.length; i++)
			System.out.print(a[i] + " ");
	}
}

Output:

0 0 0 
0 0 0 0 0

For-Each लूप

जावा 5 से एक नया for-each लूप उपलब्ध है जिसके प्रयोग से एरे तथा कलेक्शन के एलीमेंट्स को बिना उनके इंडेक्स पोज़ीशन का प्रयोग कर के एक्सेस किया जा सकता है। लूप में प्रयोग होने वाला वेरिएबल ही सभी एलीेमेंट्स को बारी-बारी से प्रदर्शित करता है। कलेक्शन में इसका प्रयोग यहां नहीं समझाया जा रहा है। इसका प्रारुप निम्नानुसार हैः

for (dataType loopVariable : ArrayName) 
{
  code using loopVariable;
  ... ... ... ... ... ...;
}

नीचे दिए गए उदाहरण में एरे के एलीमेंट्स को for-each लूप की सहायता से प्रिंट कराया गया है।

class Demo
{
	public static void main(String[] args)
	{
		int a[] = new int[]{100, 200, 300};
		for(int i : a)
		{
			System.out.print(i + "\t");
		}
	}
}

Output:

100     200     300

परिवर्तनीय संख्या में आरग्यूमेंट्स (Variable number of arguments)

जावा 1.5 से हम किसी फंक्शन में कितने भी प्रकार के आरग्यूमेंट्स पास करा सकते हैं। ये आरग्यूमेंट्स एक एरे के रुप में स्टोर हो जाते हैं। इसे निम्नलिखित प्रोग्राम द्वारा समझा जा सकता है -

class Main
{
	public static void main(String[] args)
	{
		add(2, 3);
		add(2, 3, 4);
		add(2, 3, 4, 5);
	}
	static void add(int...x)
	{
		for(int i=0; i < x.length; i++)
			System.out.print(" " + x[i]);
		
		System.out.println();
	}
}

Output:

2 3
2 3 4
2 3 4 5

ऐरे कॉपी करना

एक ऐरे को दुसरे ऐरे में कॉपी करने के लिए arraycopy मेथड का प्रयोग किया जा सकता है. यह मेथड System क्लास में होता है. इसे निम्नलिखित उदाहरण द्वारा समझा जा सकता है:

class Demo
{
  public static void main(String dfg[])
  {
	  int src[]=new int[]{10, 20, 30, 40, 50};
	  int dest[]=new int[10];
	  int x[]=new int[10];
	  
	  System.arraycopy(src, 2, dest, 0, 2);
	  for(int i=0; i < 10; i++)
	    System.out.print(dest[i] + " ");

	  System.out.println();
	  System.arraycopy(src, 0, x, 0, src.length);
	  for(int i=0; i < 10; i++)
	    System.out.print(x[i] + " ");
  
  }
}

Output:

30 40 0 0 0 0 0 0 0 0 
10 20 30 40 50 0 0 0 0 0 

परिवर्तनीय संख्या में आरग्यूमेंट्स (Variable number of arguments)

जावा 1.5 से हम किसी फंक्शन में कितने भी प्रकार के आरग्यूमेंट्स पास करा सकते हैं। ये आरग्यूमेंट्स एक एरे के रुप में स्टोर हो जाते हैं। इसे निम्नलिखित प्रोग्राम द्वारा समझा जा सकता है -

class Main
{
	public static void main(String[] args)
	{
		add(2, 3);
		add(2, 3, 4);
		add(2, 3, 4, 5);
	}
	static void add(int...x)
	{
		for(int i=0; i < x.length; i++)
			System.out.print(" " + x[i]);
		
		System.out.println();
	}
}

Output:

2 3
2 3 4
2 3 4 5

ऐरे को आरग्यूमेंट की तरह पास करना (Passing array as arguments)

जावा में हम किसी अन्य वेरिएबल की तरह ऐरे को भी फंक्शन में पास करवा सकते हैं. इसे निम्नलिखित उदाहरण से समझा जा सकता है.

class Main
{
	public static void main(String[] args)
	{
		int a[] = {10, 20, 30};

		showElements(a);
	}
	static void showElements(int x[])
	{
		for(int i=0; i < x.length; i++)
			System.out.print(x[i] + " ");
	}
}

Output:

10 20 30

ऐरे को फंक्शन से return करना (Returning array from function)

निम्नलिखित उदाहरण के माध्यम से समझाया गया है कि फंक्शन से ऐरे को किस प्रकार return कराया जा सकता है.

class Main
{
	public static void main(String[] args)
	{
		int a[] = {10, 20, 30, 40, 50};
		int b[];

		for(int i=0; i < a.length; i++)
			System.out.print(a[i] + " ");

		b = reverse(a);

		System.out.println();
		for(int i=0; i < b.length; i++)
			System.out.print(b[i] + " ");
	}
	static int[] reverse(int x[])
	{
		int t[] = new int[x.length];
		for(int i=0; i < x.length; i++)
			t[i] = x[x.length - (i+1)];

		return t;
	}
}

Output:

10 20 30 40 50 
50 40 30 20 10

निम्नलिखित उदाहरण 2 इन्टिजर सख्याओं को फंक्शन में पास कराया गया है तथा उनके जोड़, घटाव, गुना, भाग को ऐरे के रूप में return कराया गया है.

class Main
{
	public static void main(String[] args)
	{
		int a[];
		a = calc(10, 2);

		for(int i=0; i < a.length; i++)
			System.out.println(a[i]);
	}
	static int[] calc(int x, int y)
	{
		int t[] = new int[4];
		t[0] = x + y;
		t[1] = x - y;
		t[2] = x * y;
		t[3] = x / y;
		return t;
	}
}

Output:

12
8
20
5

ऐरे को डिक्लेअर करने का अन्य तरीका

ऐरे को डिक्लेअर करते समय ऐरे नाम के बाद लगाये जाने वाले कोष्ठक को ऐरे नाम से पहले भी लगाया जा सकता है. इसे निम्नलिखित उदाहरण में समझाया गया है.

class Main
{
  public static void main(String[] args)
  {
	int []a;
	a = new int[5];
	for(int i=0; i < a.length; i++)
		System.out.print(a[i] + " ");
  }
}

Output:

0 0 0 0 0

ध्यान दें, इस प्रकार से ऐरे को डिक्लेअर करने पर साथ के सभी वेरिएबल भी ऐरे बन जाते हैं. निम्नलिखित स्टेटमेंट में a तथा b दोनों ही ऐरे बनेंगे.

int []a, b;
class Main
{
  public static void main(String[] args)
  {
	int []a, b;  //both are 1D array

	a = new int[5];
	b = new int[3];

	int i;
	for(i=0; i < a.length; i++)
		System.out.print(a[i] + " ");

	System.out.println();
	for(i=0; i < b.length; i++)
		System.out.print(b[i] + " ");
  }
}

Output:

0 0 0 0 0 
0 0 0
सुझाव / कमेंट