ജാവയിൽ ഒരു അറേ എങ്ങനെ സമാരംഭിക്കാം



അറേ ജാവ

ജാവയിൽ ഒരു അറേ എങ്ങനെ സമാരംഭിക്കാം

ഒരേ ഡാറ്റാ തരത്തിന്റെ ഒന്നിലധികം മൂല്യങ്ങൾ തുടർച്ചയായ ക്രമത്തിൽ സംഭരിക്കുന്ന ഏറ്റവും വ്യാപകമായി ഉപയോഗിക്കുന്ന ഡാറ്റാ ഘടനയാണ് ജാവയിലെ അറേകൾ. അറേയ്‌ക്ക് ഒരു നിശ്ചിത നീളമുണ്ട്, ഒപ്പം സൂചിക 0 മുതൽ n-1 വരെ ആരംഭിക്കുന്നു, ഇവിടെ n എന്നത് ഒരു അറേയുടെ നീളമാണ്. സ്‌ട്രിംഗ്, ഇൻറിജർ, ക്യാരക്ടർ, ബൈറ്റ്, ഉപയോക്തൃ നിർവചിക്കപ്പെട്ട ഒബ്‌ജക്റ്റുകൾ എന്നിവപോലുള്ള ഏത് തരത്തിലുള്ള മൂല്യവും സംഭരിക്കാൻ നമുക്ക് ജാവയിൽ അറേ ക്ലാസ് ഉപയോഗിക്കാം. ജാവയിൽ ഒരു ശ്രേണി എങ്ങനെ സമാരംഭിക്കാമെന്ന് ഞങ്ങൾ പഠിക്കും?

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 എന്ന സംഖ്യകളുള്ള ഒരു സംഖ്യ ശ്രേണി സൃഷ്ടിക്കുന്നു. രണ്ടാമത്തേത് വലുപ്പം 2 ന്റെ പേരുകൾ എന്ന സ്‌ട്രിംഗ് അറേ സൃഷ്‌ടിക്കുന്നു

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

ജാവയിൽ ഒരു ശ്രേണി എങ്ങനെ സമാരംഭിക്കാം?

ഒരു ശ്രേണി എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം?

അറേ ഓർഗനൈസേഷൻ അല്ലെങ്കിൽ ഇൻസ്റ്റന്റേഷൻ എന്നാൽ അറേ വലുപ്പത്തെ അടിസ്ഥാനമാക്കി ഒരു അറേയിലേക്ക് മൂല്യങ്ങൾ നിയോഗിക്കുക എന്നാണ് അർത്ഥമാക്കുന്നത്. നമുക്ക് ഒരുമിച്ച് ഒരു അറേ സൃഷ്ടിക്കാനും സമാരംഭിക്കാനും കഴിയും (ചുവടെയുള്ള രീതി 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 മാട്രിക്സ്
  • ജാഗ്ഡ് അറേ - ഓരോ വരിയിലും വ്യത്യസ്ത നിരകൾ അടങ്ങിയിരിക്കുന്നു

ജാവയിൽ മൾട്ടി-ഡൈമെൻഷണൽ അറേ

മൾട്ടി-ഡൈമെൻഷണൽ അറേകൾക്ക് ഒന്നിലധികം വരികളും നിരകളും ഉണ്ടാകാം. ആദ്യ [] ലെ സൂചിക വരികളെ പ്രതിനിധീകരിക്കുന്നു, രണ്ടാമത്തേത് [] നിരകളെ പ്രതിനിധീകരിക്കുന്നു.

ഉദാ: 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-ഡൈമൻഷണൽ അറേ ഞങ്ങൾ സൃഷ്ടിക്കുന്നു. ലൂപ്പിനായി ഈ അറേ ഘടകങ്ങളിലേക്ക് ഞങ്ങൾ മൂല്യങ്ങൾ നൽകുന്നു. ലൂപ്പിനായുള്ള ആദ്യത്തേത് വരികളെ സൂചിപ്പിക്കുന്നു, ലൂപ്പിന് രണ്ടാമത്തേത് നിരകളെ സൂചിപ്പിക്കുന്നു.

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-ഡൈമൻഷണൽ അറേ കൂടിയാണ്. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഓരോ വരിയിലും വ്യത്യസ്ത നിരകളുണ്ട്. ഒരു ജാഗ്ഡ് അറേ സമാരംഭിക്കുന്നത് സാധാരണ 2 ഡി അറേയിൽ നിന്ന് വ്യത്യസ്തമാണ്.

ജാഗ്ഡ് അറേയുടെ സമാരംഭം

അറേ സൃഷ്ടിക്കുന്നതിനിടയിൽ, ഞങ്ങൾ വരികളുടെ എണ്ണം വ്യക്തമാക്കുന്നു. ഈ ഉദാഹരണത്തിൽ, ഇത് 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 

ജാവ അറേ രീതികൾ

ജാവയിലെ അറേകൾ പിന്തുണയ്ക്കുന്ന നേരിട്ടുള്ള രീതികൾ ചുവടെയുണ്ട്

രീതിവിവരണം
അസാധുവായ ക്ലോൺ ()റഫറൻ‌സുകൾ‌ പകർ‌ത്താത്ത നിലവിലുള്ള അറേ മൂല്യങ്ങൾ‌ ക്ലോൺ‌ ചെയ്യുന്നു
ബൂളിയൻ സമം (ഒബ്ജക്റ്റ് 0)മറ്റേതെങ്കിലും ഒബ്ജക്റ്റ് നിലവിലെ ഒബ്ജക്റ്റിന് തുല്യമാണോ എന്ന് പരിശോധിക്കുന്നു
ക്ലാസ് getClass ()ക്ലാസ് നാമം നൽകുന്നു
സ്ട്രിംഗ് ടോററിംഗ് ()ഒബ്‌ജക്റ്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നു
int ദൈർഘ്യം ()അറേയുടെ ദൈർഘ്യം നൽകുന്നു

ജാവ അറേ ഒഴിവാക്കലുകൾ

അറേ ജാവ എറിയുന്നു ചുവടെയുള്ള അപവാദം:

  • ArrayIndexOutOfBoundsException: ഞങ്ങൾ സൂചിപ്പിക്കുന്ന സൂചിക മൂല്യം ഒരു അറേയുടെ നീളത്തേക്കാൾ വലുതാകുമ്പോഴോ അല്ലെങ്കിൽ നെഗറ്റീവ് ആയിരിക്കുമ്പോഴോ ഇത് സംഭവിക്കുന്നു. മൂല്യം നിർണ്ണയിക്കുമ്പോഴോ അറേ ഘടകങ്ങൾ ആക്‌സസ് ചെയ്യുമ്പോഴോ ആണ് ഇത് പ്രധാനമായും സംഭവിക്കുന്നത്.

ഒരു ശ്രേണി പകർത്തുക

ക്ലാസ് സിസ്റ്റത്തിന്റെ രീതി അറേകോപ്പി ഉപയോഗിച്ച് നമുക്ക് ഒരു അറേയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് ഘടകങ്ങൾ പകർത്താൻ കഴിയും.

അറേ വാക്യഘടന പകർത്തുക

പബ്ലിക് ശൂന്യ അറേകോപ്പി (ഒബ്‌ജക്റ്റ് src, int srcPos, ഒബ്‌ജക്റ്റ് ഡെസ്റ്റ്, int destPos, int ദൈർഘ്യം);

പകർത്താനുള്ള src- ഉറവിട അറേ ഒബ്‌ജക്റ്റ്

srcPos - ഉറവിട അറേയിലെ ആരംഭ സ്ഥാനം

dest - പകർത്താനുള്ള ലക്ഷ്യസ്ഥാന അറേ ഒബ്‌ജക്റ്റ്

destPos - ഉദ്ദിഷ്ടസ്ഥാന അറേയിലെ ആരംഭ സ്ഥാനം

നീളം - പകർത്താനുള്ള അറേ ഘടകങ്ങളുടെ എണ്ണം

ഒരു അറേ പകർത്തുന്നതിനുള്ള ഉദാഹരണം

ചുവടെയുള്ള ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഉറവിട അറേയിൽ നിന്ന് ലക്ഷ്യസ്ഥാന അറേയിലേക്ക് 4 ഘടകങ്ങൾ പകർത്തുന്നു. അതിനാൽ java ട്ട്‌പുട്ട് “ജാവ” പ്രിന്റുചെയ്യുന്നു

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

തീരുമാനം

ഈ ട്യൂട്ടോറിയൽ ജാവയിലെ അറേ ക്ലാസ്, ജാവയിലെ അറേ തരങ്ങൾ, വിവിധ ചിത്രീകരണങ്ങളോടെ അറേകൾ പ്രഖ്യാപിക്കുക, സൃഷ്ടിക്കുക, സമാരംഭിക്കുക എന്നിവയുടെ വിശദമായ വിവരണം നൽകുന്നു.

അവലംബം