ජාවා හි අරාවක් ආරම්භ කරන්නේ කෙසේද



අරා ජාවා

ජාවා හි අරාවක් ආරම්භ කරන්නේ කෙසේද

ජාවා හි අරා යනු එකම දත්ත වර්ගයක බහුවිධ අගයන් අනුක්‍රමික අනුපිළිවෙලෙහි ගබඩා කරන වඩාත් පුළුල් ලෙස භාවිතා වන දත්ත ව්‍යුහයකි. අරාවෙහි ස්ථාවර දිගක් ඇති අතර දර්ශකය 0 සිට n-1 දක්වා ආරම්භ වන අතර n යනු අරාවෙහි දිග වේ. String, integer, character, byte, සහ පරිශීලක අර්ථ දක්වන ලද වස්තු වැනි ඕනෑම ආකාරයක අගයක් ගබඩා කිරීමට අපට ජාවාහි අරා පන්තිය භාවිතා කළ හැකිය. ජාවා හි අරාවක් ආරම්භ කරන්නේ කෙසේදැයි අපි ඉගෙන ගනිමු?

පහත දැක්වෙන්නේ මූලද්‍රව්‍ය 11 ක් ඇති පූර්ණ සංඛ්‍යා සමූහයක රූප සටහනකි.

ජාවා වල අරා

පටුන

ජාවා අරා විශේෂාංග

  • අරාව ස්ථාවර ප්‍රමාණයක් ඇති අතර එය වෙනස් කළ නොහැක
  • අරාව දර්ශක මත පදනම් වූ බැවින් අහඹු මූලද්‍රව්‍යයන්ට ප්‍රවේශ වීම පහසුය
  • අරාව මූලද්‍රව්‍ය සඳහා අඛණ්ඩ මතකය වෙන් කරයි.
  • දෙකම ගබඩා කළ හැකිය ප්‍රාථමික සහ ප්‍රාථමික නොවන දත්ත වටිනාකම්

ජාවා හි අරාවක් ප්‍රකාශ කරන්නේ කෙසේද?

ජාවා අරා ප්‍රකාශය

අරාව පහත ආකාරවලින් ප්‍රකාශ කළ හැකිය. අරාව ප්‍රකාශනයේ කොටස් 2 ක් අඩංගු වේ, පළමුවැන්න නම් අපි අරාව තුළ ගබඩා කළ යුතු මූලද්‍රව්‍යයන්ගේ දත්ත කාණ්ඩයයි (int, String, ආදිය) ඉන්පසු අරාවෙහි නම. [] වරහන් මඟින් දැක්වෙන්නේ එය අරාවකි. අපි අරාවක් ප්‍රකාශ කරන විට, එය සම්පාදකයාට පවසන්නේ විචල්‍යය අරාව බවත් එය සැබවින්ම අරාවක් නිර්මාණය නොකරන බවත්ය.

datatype [] arrayName; (හෝ)

datatype [] arrayName; (හෝ)

datatype arrayName []; -> සාමාන්‍යයෙන් මෙම ක්‍රමය වලංගු වුවද එය භාවිතා කිරීමට අපි කැමති නැත.

අරාව ප්‍රකාශ කිරීමේ උදාහරණය

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

ජාවා හි අරා නිර්මාණය කරන්නේ කෙසේද?

ජාවා හි නූල් අරාව

අපි භාවිතා කරමින් අරාවක් නිර්මාණය කරමු අළුත් ක්රියාකරු. මෙහි දී, අපි අරාවෙහි විශාලත්වය [] හි සඳහන් කර ඇති අතර එයින් දැක්වෙන්නේ අරාව විචල්‍යය ගබඩා කිරීමට අවශ්‍ය මතක ප්‍රමාණයයි.

arrname = නව දත්ත සමුදාය [ප්‍රමාණය];

අපට ප්‍රකාශ කිරීමට හා නිර්මාණය කිරීමට ද හැකිය අරාව පහත දැක්වෙන පරිදි තනි ප්‍රකාශයකින්. පළමු ප්‍රකාශය ප්‍රමාණයේ අංක 5 නම් වූ පූර්ණ සංඛ්‍යා අරාවක් නිර්මාණය කරයි

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

ජාවා හි අරාවක් ආරම්භ කරන්නේ කෙසේද?

අරාව ක්ෂණිකව සකසන්නේ කෙසේද?

අරාව ආරම්භ කිරීම හෝ ස්ථාපනය කිරීම යනු අරාවෙහි ප්‍රමාණය මත පදනම්ව අරාවකට අගයන් පැවරීමයි. අපට එකට අරාවක් නිර්මාණය කර ආරම්භ කළ හැකිය (පහත දැක්වෙන ක්‍රමය 1 බලන්න). මෙම අවස්ථාවේ දී, මූලද්රව්ය සංඛ්යාව අරාවෙහි දිග හෝ ප්රමාණය දක්වයි. ක්රමය 2 හි, අපි එක් එක් මූලද්රව්යය t0 වෙන වෙනම අගයන් පවරමු. අරාව දර්ශකය 0 සමඟ ආරම්භ වන අතර මෙහි අරාවෙහි ප්‍රමාණය 3 ක් වන බැවින්, 3 වන මූලද්‍රව්‍යය 2 වන ස්ථානය හිමි වන අතර එය n-1 වන අතර 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 න්‍යාසය
  • හකුරු අරා - සෑම පේළියකම වෙනස් තීරු ගණනක් අඩංගු වේ

ජාවා හි බහුමානීය අරා

බහුවිධ අරා වලට පේළි සහ තීරු කිහිපයක් තිබිය හැකිය. පළමු [] හි දර්ශකය පේළි නියෝජනය කරන අතර දෙවැන්න [] තීරු නියෝජනය කරයි.

උදා: int [] [] a = new int [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 වන ලූපය පේළි ද 1 වන ලූපය තීරු ද දක්වයි.

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 

ජාවා හි හකුරු අරා

හකුරු අරාව යනු වෙනස් තීරු ගණනක් සහිත ද්විමාන අරාවකි. වෙනත් වචන වලින් කිවහොත්, සෑම පේළියකම වෙනස් තීරු ගණනක් ඇත. හකුරු අරාව ආරම්භ කිරීම සාමාන්‍ය 2D අරාවකට වඩා වෙනස් වේ.

හකුරු අරාව ආරම්භ කිරීම

අරාව සෑදීමේදී, අපි පේළි ගණන නියම කරමු. මෙම උදාහරණයේ දී එය 2 වේ. ඊළඟ ප්‍රකාශ 2 හි, එක් එක් පේළි අරාව සඳහා, අපි තීරු ගණන නියම කරමු. මෙන්න, 1 වන පේළියට තීරු 3 ක් සහ 2 වන පේළියට තීරු 4 ක් ඇත.

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 

ජාවා අරා ක්‍රම

පහත දැක්වෙන්නේ ජාවා හි අරා විසින් සහාය දක්වන සෘජු ක්‍රම වේ

ක්රමයවිස්තර
අවලංගු ක්ලෝන ()යොමු පිටපත් නොකෙරෙන පවතින අරාව අගයන් ක්ලෝන කරයි
බූලියන් සමාන (වස්තුව 0)වෙනත් වස්තුවක් වත්මන් වස්තුවට සමාන දැයි පරීක්ෂා කරයි
පන්තියේ getClass ()පන්ති නාමය ලබා දෙයි
String toString ()වස්තුවෙහි තන්තු නිරූපණයක් ලබා දෙයි
int දිග ()අරාවේ දිග ලබා දෙයි

ජාවා අරාව ව්‍යතිරේක

අරා ඇතුලට ජාවා විසි කරයි පහත ව්‍යතිරේකය:

  • ArrayIndexOutOfBoundsException: මෙය සිදුවන්නේ අප විසින් නියම කරන ලද දර්ශක අගය අරාවක දිගට වඩා වැඩි වූ විට හෝ එය .ණාත්මක වූ විටය. මෙය ප්‍රධාන වශයෙන් සිදුවන්නේ අගය පැවරීමේදී හෝ අරාව මූලද්‍රව්‍ය වෙත ප්‍රවේශ වන අතරතුර ය.

අරාව පිටපත් කරන්න

පංති පද්ධතියේ අරාකෝපි ක්‍රමය භාවිතා කරමින් අපට එක් අරාවකින් තවත් පෙළකට මූලද්‍රව්‍ය පිටපත් කළ හැකිය.

අරාව සින්ටැක්ස් පිටපත් කරන්න

public void arraycopy (වස්තුව src, int srcPos, Object dest, int destPos, int length);

පිටපත් කිරීමට src-source array වස්තුව

srcPos - ප්‍රභව අරාවෙහි ආරම්භක ස්ථානය

dest - ගමනාන්ත අරාව වස්තුව පිටපත් කිරීමට

destPos - ගමනාන්ත අරාවෙහි ආරම්භක ස්ථානය

දිග - පිටපත් කිරීමට අරාව මූලද්‍රව්‍ය ගණන

අරාව පිටපත් කිරීමේ උදාහරණය

පහත උදාහරණයේ දී, අපි ප්‍රභව අරාවේ සිට ගමනාන්ත අරාව දක්වා මූලද්‍රව්‍ය 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

අරාව ක්‍රමයකට යොමු කරන්න

ජාවා හි දී, අපට තවදුරටත් හැසිරවීම හෝ වෙනත් මෙහෙයුම් සඳහා ක්‍රමවේදයකට අරාව වස්තුවක් යැවිය හැකිය. පහත උදාහරණයෙන් දැක්වෙන්නේ අපට පූර්ණ සංඛ්‍යා වල අරාව වස්තුවක් ක්‍රමයකට යොමු කර සියලු අරා මූලද්‍රව්‍ය එකතු කිරීම සිදු කරන්නේ කෙසේද යන්නයි.

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

ක්‍රමයකින් අරා ආපසු එවන්න

අපට ද හැකිය අරාව ආපසු දෙන්න අවශ්‍ය මෙහෙයුම සිදු කිරීමෙන් පසු ක්‍රමයෙන් ප්‍රධාන ක්‍රමයට වස්තුව.

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 පැකේජයටයි. පහත සඳහන් පරිදි java.util.Array පන්තියේ සහය දක්වන මෙහෙයුම් කිහිපයක් තිබේ:

  • එක් අරාවකින් තවත් පෙළකට මූලද්‍රව්‍ය පරාසයක් පිටපත් කිරීමට අපට අරේ පන්තියේ පිටපත් ඕෆ් රේන්ජ් ක්‍රමය භාවිතා කළ හැකිය
  • දර්ශකයක් මත පදනම්ව නිශ්චිත අගය සඳහා අරාවක් සොයන්න (ද්විමය සෙවීම)
  • සමානාත්මතා ක්‍රමය භාවිතා කරමින් සමානාත්මතාවය පරීක්ෂා කිරීමට අරා සමඟ සසඳන්න
  • දර්ශකයක නිශ්චිත අගයක් තැබීම සඳහා අරාවක් පිරවීම සඳහා පිරවුම් ක්‍රමය භාවිතා කරන්න
  • වර්ග කිරීමේ ක්‍රමය භාවිතා කරමින් අරාව වර්ග කිරීම

පරිශීලක අර්ථ දක්වන ලද වස්තුවක් භාවිතා කරමින් අරාවක් නිර්මාණය කිරීම

ජාවා වලදී, අපට නූල්, නිඛිල ආදිය නිර්මාණය කරන ආකාරයටම පරිශීලක අර්ථ දක්වන ලද වස්තුවක් නිර්මාණය කළ හැකිය. මෙය අපට ශිෂ්‍ය අරාව වස්තුවක් නිර්මාණය කර අරා වස්තුව ආරම්භ කළ හැකි ආකාරය පිළිබඳ උදාහරණයකි.

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

නිගමනය

මෙම නිබන්ධනය ජාවාහි අරා පන්තිය, ජාවාහි අරා වර්ග, විවිධ නිදර්ශන සහිත අරා ප්‍රකාශ කිරීම, නිර්මාණය කිරීම සහ ආරම්භ කිරීම පිළිබඳ සවිස්තරාත්මක විස්තරයක් සපයයි.

විමර්ශන