ਜਾਵਾ ਵਿਚ ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਅਰੰਭ ਕਰਨਾ ਹੈ



ਅਰੇ ਜਾਵਾ

ਜਾਵਾ ਵਿਚ ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਅਰੰਭ ਕਰਨਾ ਹੈ

ਜਾਵਾ ਵਿਚ ਐਰੇ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਡਾਟਾ structureਾਂਚਾ ਹੈ ਜੋ ਇਕੋ ਡੇਟਾ ਕਿਸਮ ਦੇ ਮਲਟੀਪਲ ਵੈਲਯੂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਕ੍ਰਮ ਵਿਚ ਸਟੋਰ ਕਰਦਾ ਹੈ. ਐਰੇ ਦੀ ਇੱਕ ਨਿਸ਼ਚਤ ਲੰਬਾਈ ਹੁੰਦੀ ਹੈ ਅਤੇ ਸੂਚਕਾਂਕ 0 ਤੋਂ n-1 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ n ਇੱਕ ਐਰੇ ਦੀ ਲੰਬਾਈ ਹੈ. ਅਸੀਂ ਜਾਵਾ ਵਿੱਚ ਐਰੇ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੇ ਮੁੱਲ ਜਿਵੇਂ ਕਿ ਸਤਰ, ਪੂਰਨ ਅੰਕ, ਅੱਖਰ, ਬਾਈਟ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਆਬਜੈਕਟ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਕਰ ਸਕਦੇ ਹਾਂ. ਅਸੀਂ ਜਾਵਾ ਵਿਚ ਐਰੇ ਨੂੰ ਅਰੰਭ ਕਰਨ ਦੇ ਤਰੀਕੇ ਬਾਰੇ ਸਿਖਾਂਗੇ?

ਹੇਠਾਂ 11 ਤੱਤ ਹੋਣ ਵਾਲੇ ਪੂਰਨ ਅੰਕ ਦੇ ਇੱਕਲੇ-ਅਯਾਮੀ ਲੜੀ ਦੀ ਚਿੱਤਰਕਾਰੀ ਪ੍ਰਸਤੁਤੀ ਹੈ.

ਜਾਵਾ ਵਿਚ ਐਰੇ

ਵਿਸ਼ਾ - ਸੂਚੀ

ਜਾਵਾ ਐਰੇ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

  • ਐਰੇ ਦਾ ਇੱਕ ਅਕਾਰ ਦਾ ਅਕਾਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ
  • ਕਿਉਂਕਿ ਐਰੇ ਇੰਡੈਕਸ-ਅਧਾਰਤ ਹੈ, ਬੇਤਰਤੀਬੇ ਤੱਤ ਤੱਕ ਪਹੁੰਚਣਾ ਆਸਾਨ ਹੈ
  • ਐਰੇ ਐਲੀਮੈਂਟਸ ਲਈ ਨਿਰੰਤਰ ਮੈਮੋਰੀ ਜਾਰੀ ਕਰਦਾ ਹੈ.
  • ਦੋਵਾਂ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦਾ ਹੈ ਮੁੱimਲਾ ਅਤੇ ਗੈਰ-ਮੁੱimਲਾ ਡੇਟਾ ਮੁੱਲ

ਜਾਵਾ ਵਿਚ ਐਰੇ ਦਾ ਐਲਾਨ ਕਿਵੇਂ ਕਰੀਏ?

ਜਾਵਾ ਐਰੇ ਘੋਸ਼ਣਾ

ਇੱਕ ਐਰੇ ਨੂੰ ਹੇਠਾਂ ਤਰੀਕਿਆਂ ਨਾਲ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਐਰੇ ਘੋਸ਼ਣਾ ਵਿੱਚ 2 ਹਿੱਸੇ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਪਹਿਲਾਂ ਉਹ ਤੱਤ ਦਾ ਡੇਟਾ ਟਾਈਪ ਹੁੰਦਾ ਹੈ ਜਿਸਦੀ ਸਾਨੂੰ ਐਰੇ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ (ਜਿਵੇਂ ਇੰਟ, ਸਟਰਿੰਗ, ਆਦਿ) ਅਤੇ ਐਰੇ ਨਾਮ ਤੋਂ ਬਾਅਦ. [] ਬਰੈਕਟ ਸੰਕੇਤ ਦਿੰਦੇ ਹਨ ਕਿ ਇਹ ਇੱਕ ਐਰੇ ਹੈ. ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਐਰੇ ਘੋਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਇਹ ਸਿਰਫ ਕੰਪਾਈਲਰ ਨੂੰ ਕਹਿੰਦਾ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਇੱਕ ਐਰੇ ਹੈ ਅਤੇ ਅਸਲ ਵਿੱਚ ਕੋਈ ਐਰੇ ਨਹੀਂ ਬਣਾਉਂਦਾ.

ਡੈਟਾ ਟਾਈਪ [] ਐਰੇਨੇਮ; (ਜਾਂ)

ਡੈਟਾ ਟਾਈਪ [] ਐਰੇਨੇਮ; (ਜਾਂ)

ਡੈਟਾਟਾਈਪ ਐਰੇਨੇਮ []; -> ਆਮ ਤੌਰ 'ਤੇ ਅਸੀਂ ਇਸ methodੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਪਸੰਦ ਨਹੀਂ ਕਰਦੇ ਹਾਲਾਂਕਿ ਇਹ ਯੋਗ ਹੈ.

ਐਰੇ ਘੋਸ਼ਣਾ ਦੀ ਉਦਾਹਰਣ

int[] arrNumbers;
String[] arrNames;
float[] arrValues;
boolean[] arrBoolean;
char[] arrLetters;
byte[] arrBytes;
double[] arrWeight;

ਜਾਵਾ ਵਿਚ ਐਰੇ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ?

ਜਾਵਾ ਵਿੱਚ ਸਤਰ ਐਰੇ

ਅਸੀ ਵਰਤ ਕੇ ਇੱਕ ਐਰੇ ਬਣਾਉਂਦੇ ਹਾਂ ਨ੍ਯੂ ਚਾਲਕ ਇਸ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਐਰੇ ਦਾ ਅਕਾਰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ [] ਜੋ ਐਰੇ ਵੇਰੀਏਬਲ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀ ਮੈਮੋਰੀ ਦੀ ਮਾਤਰਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ.

ਐਰਨਨਾਮ = ਨਵਾਂ ਡੇਟਾ ਟਾਈਪ [ਆਕਾਰ];

ਅਸੀ ਘੋਸ਼ਿਤ ਵੀ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਐਰੇ ਹੇਠ ਦਿੱਤੇ ਅਨੁਸਾਰ ਇੱਕ ਬਿਆਨ ਵਿੱਚ. ਪਹਿਲਾ ਬਿਆਨ ਇੱਕ ਪੂਰਨ ਅੰਕ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸਦਾ ਆਕਾਰ ਨੰਬਰ 5 ਹੁੰਦਾ ਹੈ. ਦੂਜਾ ਸਟਰਿੰਗ ਐਰੇ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸਦਾ ਆਕਾਰ 2 ਦੇ ਨਾਮ ਹਨ

int[] arrNumbers = new int[5];
String[] arrNames = new String[2];

ਜਾਵਾ ਵਿਚ ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਅਰੰਭ ਕਰਨਾ ਹੈ?

ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਸਥਾਪਤ ਕਰਨਾ ਹੈ?

ਐਰੇ ਅਰੰਭੀਕਰਨ ਜਾਂ ਇੰਸਟਾਂਟੀਗੇਸ਼ਨ ਦਾ ਅਰਥ ਹੈ ਐਰੇ ਦੇ ਅਕਾਰ ਦੇ ਅਧਾਰ ਤੇ ਐਰੇ ਨੂੰ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ. ਅਸੀਂ ਮਿਲ ਕੇ ਇੱਕ ਐਰੇ ਬਣਾ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸਥਾਪਤ ਵੀ ਕਰ ਸਕਦੇ ਹਾਂ (ਹੇਠਾਂ Methੰਗ 1 ਵੇਖੋ). ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਇੱਕ ਐਰੇ ਦੀ ਲੰਬਾਈ ਜਾਂ ਅਕਾਰ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ. ਵਿਧੀ 2 ਵਿੱਚ, ਅਸੀਂ ਹਰੇਕ ਤੱਤ ਨੂੰ ਵੱਖਰੇ ਤੌਰ ਤੇ t0 ਨਿਰਧਾਰਤ ਕਰ ਰਹੇ ਹਾਂ. ਕਿਉਂਕਿ ਐਰੇ ਇੰਡੈਕਸ 0 ਨਾਲ ਅਰੰਭ ਹੁੰਦਾ ਹੈ ਅਤੇ ਐਰੇ ਦਾ ਆਕਾਰ ਇਥੇ 3 ਹੈ, ਤੀਜਾ ਤੱਤ ਦੂਜਾ ਸਥਾਨ ਰੱਖਦਾ ਹੈ ਜੋ n-3 ਹੈ ਜਿੱਥੇ n ਐਰੇ ਦਾ ਆਕਾਰ ਹੈ.

//Method 1
int[] arrNumbers = {1,2,3};

//Method 2
int[] arrNumbers = new int[3];
arrNumbers[0] = 1;
arrNumbers[1] = 2;
arrNumbers[2] = 3;

ਜਾਵਾ ਵਿੱਚ ਐਰੇ ਐਲੀਮੈਂਟਸ ਐਕਸੈਸ ਕਰਨਾ

ਅਸੀਂ ਇਸਦੇ ਇੰਡੈਕਸ ਵੈਲਯੂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਰੇ ਐਲੀਮੈਂਟਸ ਤੱਕ ਪਹੁੰਚ ਕਰਦੇ ਹਾਂ. ਆਮ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ ਲਈ ਲੂਪ ਜ ਹਰ ਇੱਕ ਲਈ ਐਰੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਲਈ ਲੂਪ ਕਿਉਂਕਿ ਸਾਰੇ ਐਲੀਮੈਂਟਸ ਇਕੋ ਕਿਸਮ ਦੇ ਹੁੰਦੇ ਹਨ ਅਤੇ ਇਕ ਨਿਸ਼ਚਤ ਆਕਾਰ ਹੁੰਦੇ ਹਨ.

ਉਦਾਹਰਣ: ਐਰੇ ਐਲੀਮੈਂਟਸ ਬਣਾਓ, ਅਰੰਭ ਕਰੋ ਅਤੇ ਐਕਸੈਸ ਕਰੋ

ਇਥੇ, ਅਸੀਂ ਇਕੱਲੇ ਸਟੇਟਮੈਂਟ ਵਿਚ ਸਤਰਾਂ ਦੀ ਐਰੇ ਬਣਾਉਂਦੇ ਅਤੇ ਅਰੰਭ ਕਰ ਰਹੇ ਹਾਂ ਅਤੇ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹਰੇਕ ਐਲੀਮੈਂਟ ਨੂੰ ਐਕਸੈਸ ਕਰ ਰਹੇ ਹਾਂ

public class ArrayDemo1 {

  public static void main(String[] args) {
    String[] arrMonths = {"May","June","July"};
    System.out.println("Length of array is: " + arrMonths.length);
    for(int i=0;i<arrMonths.length;i++)
    {
      System.out.println(arrMonths[i]); 
    }

  }

}
Output:
Length of array is: 3
May
June
July

ਉਦਾਹਰਣ: ਐਰੇ ਨੂੰ ਅਰੰਭ ਕਰਨ ਅਤੇ ਐਰੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਦਾ ਇਕ ਹੋਰ ਤਰੀਕਾ

ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਪੂਰਨ ਅੰਕ ਦੀ ਐਰੇ ਘੋਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਅਤੇ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਵਿਅਕਤੀਗਤ ਐਰੇ ਤੱਤਾਂ ਨੂੰ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ. ਇਥੇ, ਅਰੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਲਈ ਅਸੀਂ ਹਰ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ.

public class ArrayDemo2 {

  public static void main(String[] args) {
    int[] numbers = new int[5];
    numbers[0] = 100;
    numbers[1] = 101;
    numbers[2] = 103;
    numbers[3] = 104;
    numbers[4] = 105;
    
    for(int i: numbers)
    {
      System.out.println(i);
    }

  }

}
Output:
100
101
103
104
105

ਜਾਵਾ ਵਿਚ ਐਰੇ ਦੀਆਂ ਕਿਸਮਾਂ

ਜਾਵਾ ਵਿੱਚ ਐਰੇ ਦੀਆਂ 2 ਕਿਸਮਾਂ ਹਨ:

  • ਸਿੰਗਲ ਅਯਾਮੀ ਐਰੇ - ਇਸ ਵਿੱਚ ਸਿਰਫ 1 ਕਤਾਰ ਅਤੇ 1 ਕਾਲਮ ਹੈ. ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਇੱਕ ਅਯਾਮੀ ਐਰੇ ਨਾਲ ਸਬੰਧਤ ਹਨ
  • ਬਹੁਮੰਤਵੀ ਐਰੇ - ਇਸ ਵਿੱਚ ਮਲਟੀਪਲ ਕਤਾਰਾਂ ਅਤੇ ਮਲਟੀਪਲ ਕਾਲਮ ਹਨ. ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਇਹ ਐਰੇ ਦੀ ਇਕ ਐਰੇ ਹੈ ਜਿੱਥੇ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਵਿਚ ਇਕੋ ਜਿਹੇ ਕਾਲਮ ਹਨ. ਉਦਾਹਰਣ: 2 * 2 ਮੈਟ੍ਰਿਕਸ
  • ਜੱਗੇ ਹੋਏ ਐਰੇ - ਹਰੇਕ ਕਤਾਰ ਵਿੱਚ ਵੱਖੋ ਵੱਖਰੇ ਨੰਬਰਾਂ ਦੇ ਕਾਲਮ ਹੁੰਦੇ ਹਨ

ਜਾਵਾ ਵਿਚ ਬਹੁਪੱਖੀ ਐਰੇ

ਬਹੁਮੰਤਵੀ ਐਰੇ ਵਿੱਚ ਕਈ ਕਤਾਰਾਂ ਅਤੇ ਕਾਲਮ ਹੋ ਸਕਦੇ ਹਨ. ਪਹਿਲੇ [] ਵਿਚ ਇੰਡੈਕਸ ਕਤਾਰਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਦੂਜਾ [] ਕਾਲਮਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ.

ਉਦਾਹਰਣ: ਇੰਟ [] [] ਏ = ਨਵੀਂ ਇੰਟ [2] [3]

ਇਸਦਾ ਅਰਥ ਹੈ ਐਰੇ ਵਿੱਚ 2 ਕਤਾਰਾਂ ਅਤੇ 3 ਕਾਲਮ ਹਨ. ਹੇਠਾਂ ਇਕ ਬਹੁ-ਅਯਾਮੀ ਐਰੇ ਦੀ ਚਿੱਤਰਕਾਰੀ ਪ੍ਰਸਤੁਤੀ ਹੈ

ਜਾਵਾ ਵਿਚ ਐਰੇ

ਸਤਰਾਂ ਦੀਆਂ ਬਹੁਪੱਖੀ ਐਰੇ ਬਣਾਉਣ ਦੀ ਉਦਾਹਰਣ

ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਬਹੁ-ਅਯਾਮੀ ਐਰੇ ਤੱਤ ਕਿਵੇਂ ਬਣਾਏ, ਘੋਸ਼ਿਤ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਨ. ਇੱਥੇ, ਅਸੀਂ ਕਤਾਰ ਅਤੇ ਕਾਲਮ ਇੰਡੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਰੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਸਿੱਧੇ ਐਕਸੈਸ ਕਰਦੇ ਹਾਂ.

public class ArrayMulti {

  public static void main(String[] args) {
    String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
    System.out.println(arrNames[0][0] + " " + arrNames[0][1]);
    System.out.println(arrNames[1][0] + " " + arrNames[1][1]);

  }

}
Output:
John Jacob 
Thomas Martin

ਪੂਰਨ ਅੰਕ ਦੀ 2D ਐਰੇ ਦੀ ਉਦਾਹਰਣ

ਇੱਥੇ, ਅਸੀਂ ਪੂਰਨ ਅੰਕ ਦੀ ਇੱਕ 2-ਅਯਾਮੀ ਲੜੀ ਬਣਾ ਰਹੇ ਹਾਂ ਜਿਸ ਵਿੱਚ 2 ਕਤਾਰਾਂ ਅਤੇ 3 ਕਾਲਮ ਹਨ. ਅਸੀਂ ਲੂਪ ਦੇ ਅੰਦਰ ਅੰਦਰ ਐਰੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ. ਲੂਪ ਲਈ ਪਹਿਲਾ ਕਤਾਰਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਲੂਪ ਲਈ ਦੂਜਾ ਕਾਲਮ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ.

public class ArrayMulti {

  public static void main(String[] args) {
    //Declare and create multidimensional array
    int[][] arrnum = new int[2][3];
    for(int i=0;i<2;i++) {
      for(int j=0;j<3;j++) {
        //Assign values to array elements
        arrnum[i][j] = i+1;
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }

  }

}
Output:
1 1 1 
2 2 2 

ਜਾਵਾ ਵਿਚ ਜਾਗੀ ਐਰੇ

ਜੱਗੇਡ ਐਰੇ ਵੀ ਇੱਕ 2-ਅਯਾਮੀ ਲੜੀ ਹੈ ਜਿਸ ਵਿੱਚ ਵੱਖੋ ਵੱਖਰੇ ਕਾਲਮ ਹਨ. ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਹਰੇਕ ਕਤਾਰ ਵਿਚ ਵੱਖੋ ਵੱਖਰੇ ਕਾਲਮ ਹੁੰਦੇ ਹਨ. ਜੱਗੇਡ ਐਰੇ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਨਾ ਆਮ 2D ਐਰੇ ਤੋਂ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ.

ਜਾਗੀਡ ਐਰੇ ਦੀ ਸ਼ੁਰੂਆਤ

ਐਰੇ ਬਣਾਉਣ ਵੇਲੇ, ਅਸੀਂ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ. ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਇਹ 2 ਹੈ. ਅਗਲੇ 2 ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚ, ਹਰ ਰੋ ਕਤਾਰ ਵਿੱਚ, ਅਸੀਂ ਕਾਲਮਾਂ ਦੀ ਸੰਖਿਆ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ. ਇੱਥੇ, ਪਹਿਲੀ ਕਤਾਰ ਵਿੱਚ 1 ਕਾਲਮ ਹਨ ਅਤੇ ਦੂਜੀ ਕਤਾਰ ਵਿੱਚ 3 ਕਾਲਮ ਹਨ.

int[][] arrnum = new int[2][];
arrnum[0] = new int[3];
arrnum[1] = new int[4];

ਲੂਪ ਵਿਚ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਕੇ ਜੱਗੇਡ ਐਰੇ ਦੀ ਉਦਾਹਰਣ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arrnum = new int[2][];
    arrnum[0] = new int[3];
    arrnum[1] = new int[4];

    int val=1;
    //Assign values
    for(int i=0;i<arrnum.length;i++) {
      for(int j=0;j<arrnum[i].length;j++) {
        arrnum[i][j] = val;
      }
    }
    
    //Print the values
    for(int i=0;i<arrnum.length;i++)
    {
      for(int j=0;j<arrnum[i].length;j++)
      {
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }
  }

}
Output:
1 1 1 
1 1 1 1 

ਐਰੇ ਬਣਾਉਣ ਵੇਲੇ ਮੁੱਲਾਂ ਨੂੰ ਅਰੰਭ ਕਰਕੇ ਐਰੇ ਉਦਾਹਰਣ ਨੂੰ ਜੱਗ ਕੀਤਾ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arr = {{4,5,6},{1,2},{7,9,8}};
    for(int i=0;i<3;i++)
    {
      for(int j=0;j<arr[i].length;j++) {
        System.out.print(arr[i][j] + " ");
      }
      System.out.println();
    }
  }
}
Output:
4 5 6 
1 2 
7 9 8 

ਜਾਵਾ ਐਰੇ odੰਗ

ਹੇਠਾਂ ਜਾਵਾ ਵਿੱਚ ਐਰੇ ਦੁਆਰਾ ਸਹਿਯੋਗੀ ਸਿੱਧੇ .ੰਗ ਹਨ

ਢੰਗਵੇਰਵਾ
ਰੱਦ ਕਲੋਨ ()ਮੌਜੂਦਾ ਐਰੇ ਮੁੱਲ ਨੂੰ ਕਲੋਨ ਕਰਦਾ ਹੈ ਜਿਥੇ ਹਵਾਲਿਆਂ ਦੀ ਨਕਲ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ
ਬੁਲੀਅਨ ਬਰਾਬਰ (ਆਬਜੈਕਟ 0)ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੁਝ ਹੋਰ ਆਬਜੈਕਟ ਮੌਜੂਦਾ ਇਕਾਈ ਦੇ ਬਰਾਬਰ ਹਨ ਜਾਂ ਨਹੀਂ
ਕਲਾਸ ਗੇਟ ਕਲਾਸ ()ਕਲਾਸ ਦਾ ਨਾਮ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਸਟ੍ਰਿੰਗ ਟੂ ਸਟ੍ਰਿੰਗ ()ਆਬਜੈਕਟ ਦੀ ਇੱਕ ਸਤਰ ਦੀ ਨੁਮਾਇੰਦਗੀ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਇੰਟ ਲੰਬਾਈ ()ਐਰੇ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰਦਾ ਹੈ

ਜਾਵਾ ਐਰੇ ਅਪਵਾਦ

ਵਿਚ ਐਰੇ ਜਾਵਾ ਸੁੱਟ ਦਿੰਦਾ ਹੈ ਹੇਠਾਂ ਅਪਵਾਦ:

  • ਐਰੇਇੰਡੇਕਸ ਆਉਟਫਾoundsਂਡਜ਼ ਐਕਸੈਪਸ਼ਨ: ਇਹ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਅਸੀਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਇੰਡੈਕਸ ਮੁੱਲ ਇੱਕ ਐਰੇ ਦੀ ਲੰਬਾਈ ਤੋਂ ਵੱਧ ਹੁੰਦਾ ਹੈ ਜਾਂ ਜਦੋਂ ਇਹ ਨਕਾਰਾਤਮਕ ਹੁੰਦਾ ਹੈ. ਇਹ ਮੁੱਖ ਤੌਰ ਤੇ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ ਜਾਂ ਐਰੇ ਐਲੀਮੈਂਟਸ ਤੱਕ ਪਹੁੰਚਣ ਵੇਲੇ ਹੁੰਦਾ ਹੈ.

ਇੱਕ ਐਰੇ ਦੀ ਨਕਲ ਕਰੋ

ਅਸੀਂ ਕਲਾਸ ਸਿਸਟਮ ਦੀ methodੰਗ ਐਰੇਕੋਪੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਐਰੇ ਤੋਂ ਦੂਜੇ ਐਰੇ ਵਿੱਚ ਐਲੀਮੈਂਟਸ ਦੀ ਨਕਲ ਕਰ ਸਕਦੇ ਹਾਂ.

ਐਰੇ ਸਿੰਟੈਕਸ ਦੀ ਨਕਲ ਕਰੋ

ਪਬਲਿਕ ਵੋਇਡ ਐਰੇਕੋਪੀ (sਬਜੈਕਟ src, ਇੰਟ srcPos, ਆਬਜੈਕਟ ਡੈਸਟ, ਇੰਟ ਡੈਸਟਪੋਸ, ਇੰਟ ਲੰਬਾਈ)

ਤੋਂ ਕਾਪੀ ਕਰਨ ਲਈ src- ਸਰੋਤ ਐਰੇ ਆਬਜੈਕਟ

srcPos - ਸਰੋਤ ਐਰੇ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ

ਟਿਕਾਣਾ - ਟਿਕਾਣਾ ਐਰੇ ਆਬਜੈਕਟ ਨੂੰ ਕਾਪੀ ਕਰਨ ਲਈ

ਡੈਸਟਪੋਸ - ਮੰਜ਼ਿਲ ਐਰੇ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ

ਲੰਬਾਈ - ਕਾਪੀ ਕਰਨ ਲਈ ਐਰੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ

ਐਰੇ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਉਦਾਹਰਣ

ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਸਰੋਤ ਐਰੇ ਤੋਂ 4 ਐਲੀਮੈਂਟਸ ਨੂੰ ਮੰਜ਼ਿਲ ਐਰੇ ਵਿੱਚ ਨਕਲ ਕਰ ਰਹੇ ਹਾਂ. ਇਸ ਲਈ ਆਉਟਪੁਟ "ਜਾਵਾ" ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ

public class ArrayCopy {

  public static void main(String[] args) {
    char[] a = {'d','l','h','y','j','a','v','a','g','r','t'};
    char[] b = new char[4];
    
    System.arraycopy(a, 4, b, 0, 4);
    System.out.println(String.valueOf(b));

  }

}
Output:
java

ਇੱਕ ਵਿਧੀ ਨੂੰ ਐਰੇ ਪਾਸ ਕਰੋ

ਜਾਵਾ ਵਿੱਚ, ਅਸੀਂ ਕਿਸੇ ਹੇਰਾਫੇਰੀ ਜਾਂ ਹੋਰ ਕਾਰਜਾਂ ਲਈ ਇੱਕ rayੰਗ ਨੂੰ ਇੱਕ ਐਰੇ ਆਬਜੈਕਟ ਪਾਸ ਕਰ ਸਕਦੇ ਹਾਂ. ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਅਸੀਂ ਕਿਸੇ ਵਿਧੀ ਨਾਲ ਪੂਰਨ ਅੰਕ ਦੇ ਐਰੇ objectਬਜੈਕਟ ਨੂੰ ਪਾਸ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸਾਰੇ ਐਰੇ ਐਲੀਮੈਂਟਸ ਦੇ ਜੋੜ ਨੂੰ ਪੂਰਾ ਕਰ ਸਕਦੇ ਹਾਂ.

public class ArrayDemo3 {

  public static void main(String[] args) {
    int[] num = {5,7,3,2,8};
    add(num);

  }
  
  public static void add(int[] num) {
    int sum = 0;
    for(int i=0;i<num.length;i++) {
      sum = sum + num[i];
    }
    System.out.println("Sum of array elements is : " + sum);
  }

}
Output:
Sum of array elements is : 25

ਇੱਕ ਵਿਧੀ ਤੋਂ ਐਰੇ ਵਾਪਸ ਕਰੋ

ਅਸੀਂ ਵੀ ਕਰ ਸਕਦੇ ਹਾਂ ਇੱਕ ਐਰੇ ਵਾਪਸ ਕਰੋ ਲੋੜੀਂਦੀ ਕਾਰਵਾਈ ਕਰਨ ਤੋਂ ਬਾਅਦ methodੰਗ ਤੋਂ ਮੁੱਖ methodੰਗ ਵੱਲ ਆਬਜੈਕਟ.

public class ArrayDemo4 {

  public static void main(String[] args) {
    String[] arr = getArrayValues();
    for(String cities:arr) {
      System.out.println(cities);
    }
      

  }
  
  public static String[] getArrayValues() {
    String[] arrCities = {"Chennai","Bangalore","Delhi"};
    return arrCities;
  }

}
Output:
Chennai
Bangalore
Delhi

ਐਰੇ ਹੇਰਾਫੇਰੀ

ਵਿਚ ਐਰੇ ਜਾਵਾ java.util ਪੈਕੇਜ ਨਾਲ ਸਬੰਧਤ ਹੈ. ਹੇਠ ਦਿੱਤੇ ਅਨੁਸਾਰ ਜਾਵਾ.ਯੂਟਿਲ.ਅਰੇ ਕਲਾਸ ਦੁਆਰਾ ਸਹਿਯੋਗੀ ਕਈ ਓਪਰੇਸ਼ਨ ਹਨ:

  • ਅਸੀਂ ਐਰੇ ਕਲਾਸ ਦੇ copyOfRange methodੰਗ ਦੀ ਵਰਤੋਂ ਇਕ ਐਰੇ ਤੋਂ ਦੂਜੇ ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਸੀਮਾ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਕਰ ਸਕਦੇ ਹਾਂ
  • ਇੱਕ ਇੰਡੈਕਸ ਦੇ ਅਧਾਰ ਤੇ ਖਾਸ ਮੁੱਲ ਲਈ ਇੱਕ ਐਰੇ ਖੋਜੋ (ਬਾਈਨਰੀ ਖੋਜ)
  • ਬਰਾਬਰ methodੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਰਾਬਰੀ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਐਰੇ ਦੀ ਤੁਲਨਾ ਕਰੋ
  • ਇੰਡੈਕਸ ਤੇ ਇੱਕ ਖਾਸ ਮੁੱਲ ਰੱਖਣ ਲਈ ਐਰੇ ਨੂੰ ਭਰਨ ਲਈ ਭਰੋ methodੰਗ ਦੀ ਵਰਤੋਂ ਕਰੋ
  • ਲੜੀਬੱਧ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਰੇ ਨੂੰ ਸੌਰਟ ਕਰਨਾ

ਇੱਕ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਰੇ ਬਣਾਉਣਾ

ਜਾਵਾ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਆਬਜੈਕਟ ਵੀ ਬਣਾ ਸਕਦੇ ਹਾਂ ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਸਤਰਾਂ, ਪੂਰਨ ਅੰਕ, ਆਦਿ ਦੀ ਇੱਕ ਐਰੇ ਕਿਵੇਂ ਬਣਾਉਂਦੇ ਹਾਂ ਇਹ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਕਿਵੇਂ ਅਸੀਂ ਇੱਕ ਵਿਦਿਆਰਥੀ ਐਰੇ ਆਬਜੈਕਟ ਬਣਾ ਸਕਦੇ ਹਾਂ ਅਤੇ ਐਰੇ ਆਬਜੈਕਟ ਨੂੰ ਅਰੰਭ ਕਰ ਸਕਦੇ ਹਾਂ.

public class ArrayDemo5 {

  public static void main(String[] args) {
    Student[] s = new Student[2];
    s[0] = new Student(111,"Ajit");
    s[1] = new Student(112,"Biju");
  }

}
 class Student{
  public int rollno;
  public String name;
  public Student(int rno,String n) {
    rollno = rno;
    name = n;
  }
}

ਸਿੱਟਾ

ਇਹ ਟਿਯੂਟੋਰਿਅਲ ਜਾਵਾ ਵਿਚ ਐਰੇ ਕਲਾਸ, ਜਾਵਾ ਵਿਚ ਐਰੇ ਦੀਆਂ ਕਿਸਮਾਂ, ਘੋਸ਼ਣਾ, ਬਣਾਉਣਾ ਅਤੇ ਅਰੰਭ ਕਰਨ ਲਈ ਵਿਸਥਾਰ ਨਾਲ ਵੇਰਵੇ ਦਿੰਦਾ ਹੈ.

ਹਵਾਲਾ