જાવામાં એરે કેવી રીતે શરૂ કરવી



અરે જાવા

જાવામાં એરે કેવી રીતે શરૂ કરવી

જાવામાં એરે એ મોટા પ્રમાણમાં ઉપયોગમાં લેવાતા ડેટા સ્ટ્રક્ચર છે જે સમાન ડેટા પ્રકારનાં બહુવિધ મૂલ્યોને ક્રમિક ક્રમમાં સંગ્રહિત કરે છે. એરેની નિશ્ચિત લંબાઈ હોય છે અને અનુક્રમણિકા 0 થી n-1 થી શરૂ થાય છે જ્યાં n એ એરેની લંબાઈ છે. આપણે જાવામાં એરે વર્ગનો ઉપયોગ કોઈપણ પ્રકારનાં મૂલ્ય જેવા કે શબ્દમાળા, પૂર્ણાંક, પાત્ર, બાઇટ અને વપરાશકર્તા વ્યાખ્યાયિત storeબ્જેક્ટ્સને સંગ્રહિત કરવા માટે કરી શકીએ છીએ. આપણે શીખીશું કે જાવા માં એરે કેવી રીતે શરૂ કરવી?

નીચે 11 તત્વો ધરાવતા પૂર્ણાંકોના એક-પરિમાણીય એરેની આકૃતિની રજૂઆત છે.

જાવામાં એરે

વિષયસુચીકોષ્ટક

જાવા એરે સુવિધાઓ

  • એરેમાં નિશ્ચિત કદ હોય છે અને બદલી શકાતું નથી
  • એરે અનુક્રમણિકા આધારિત હોવાથી, રેન્ડમ તત્વો accessક્સેસ કરવાનું સરળ છે
  • એરે તત્વો માટે સતત મેમરી ફાળવે છે.
  • બંને સ્ટોર કરી શકે છે આદિમ અને બિન-આદિમ ડેટા કિંમતો

જાવામાં એરે કેવી રીતે જાહેર કરવું?

જાવા એરેની ઘોષણા

એરે નીચેની રીતે જાહેર કરી શકાય છે. એરે ઘોષણામાં 2 ભાગો હોય છે, પ્રથમ એલિમેન્ટ્સનો ડેટાટાઇપ છે જેને આપણે એરે (ઇન્ટ, સ્ટ્રિંગ, વગેરે) માં સ્ટોર કરવાની જરૂર છે અને એરે નામ પછી. [] કૌંસ સૂચવે છે કે તે એરે છે. જ્યારે આપણે એરે જાહેર કરીએ છીએ, તે ફક્ત કમ્પાઇલરને કહે છે કે ચલ એરે છે અને ખરેખર એરે બનાવતો નથી.

ડેટાટાઇપ [] એરેનામ; (અથવા)

ડેટાટાઇપ [] એરેનામ; (અથવા)

ડેટાટાઇપ એરેનેમ []; -> સામાન્ય રીતે આપણે આ પદ્ધતિ માન્ય હોવા છતાં તેનો ઉપયોગ કરવાનું પસંદ કરતા નથી.

એરે જાહેરનામું ઉદાહરણ

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 છે, 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;

જાવામાં એરે તત્વોને Accessક્સેસ કરવું

અમે તેના અનુક્રમણિકા મૂલ્યનો ઉપયોગ કરીને એરે તત્વોને .ક્સેસ કરીએ છીએ. સામાન્ય રીતે, અમે ઉપયોગ માટે લૂપ અથવા દરેક માટે એરે તત્વો accessક્સેસ કરવા માટે લૂપ, કારણ કે બધા તત્વો સમાન પ્રકારના હોય છે અને તેનું કદ ચોક્કસ હોય છે.

ઉદાહરણ: એરે તત્વો બનાવો, પ્રારંભ કરો અને Accessક્સેસ કરો

અહીં, આપણે એક જ સ્ટેટમેન્ટમાં શબ્દમાળાઓની એરે બનાવી રહ્યા છીએ અને પ્રારંભ કરી રહ્યા છીએ અને લૂપનો ઉપયોગ કરીને દરેક તત્વને એક્સેસ કરી શકીએ છીએ

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

ઉદાહરણ: એરે પ્રારંભ કરવાની અને એરે તત્વોને ingક્સેસ કરવાની બીજી પદ્ધતિ

નીચેના ઉદાહરણમાં, આપણે પહેલા પૂર્ણાંકોની એરે જાહેર કરીએ છીએ અને બનાવીએ છીએ અને પછી વ્યક્તિગત એરે તત્વોને મૂલ્યો સોંપીએ છીએ. અહીં, આપણે એરે તત્વોને toક્સેસ કરવા માટે દરેક લૂપનો ઉપયોગ કરીશું.

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 ક columnલમ છે. ઉપરોક્ત તમામ ઉદાહરણો એક પરિમાણીય એરેના છે
  • બહુપરીમાણીય એરે - આમાં અનેક પંક્તિઓ અને બહુવિધ ક colલમ છે. બીજા શબ્દોમાં કહીએ તો, તે એરેની એરે છે જ્યાં બધી હરોળમાં સમાન સંખ્યામાં કumnsલમ છે. દા.ત.: 2 * 2 મેટ્રિક્સ
  • જેગ્ડ એરે - દરેક પંક્તિમાં ક numberલમની સંખ્યા જુદી હોય છે

જાવામાં બહુપરીમાણીય એરે

બહુપરીમાણીય એરેમાં ઘણી પંક્તિઓ અને કumnsલમ હોઈ શકે છે. પ્રથમ [] માં અનુક્રમણિકા પંક્તિઓ રજૂ કરે છે અને બીજો [] કumnsલમ રજૂ કરે છે.

દા.ત. પૂર્ણાંક [] [] એ = નવી પૂર્ણાહુતિ [૨] []]

આનો અર્થ એ કે એરેમાં 2 પંક્તિઓ અને 3 કumnsલમ છે. નીચે મલ્ટિ-ડાયમેન્શનલ એરેનું આકૃતિ રજૂઆત છે

જાવામાં એરે

સ્ટ્રિંગ્સના બહુ-પરિમાણીય એરે બનાવવાનું ઉદાહરણ

નીચેનું ઉદાહરણ બતાવે છે કે મલ્ટિડેમેન્શનલ એરે તત્વો કેવી રીતે બનાવવી, ઘોષણા કરવી અને accessક્સેસ કરવું. અહીં, આપણે પંક્તિ અને ક columnલમ અનુક્રમણિકાનો ઉપયોગ કરીને સીધા એરે તત્વોને accessક્સેસ કરીએ છીએ.

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 કumnsલમ ધરાવતા પૂર્ણાંકોનો 3-પરિમાણીય એરે બનાવી રહ્યા છીએ. આપણે લૂપ માટે અંદરના આ એરે તત્વોને કિંમતો સોંપીએ છીએ. લૂપ માટે 1 લી પંક્તિઓ સૂચવે છે અને 2 લૂપ ક denલમ સૂચવે છે.

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 સ્ટેટમેન્ટમાં, દરેક પંક્તિ એરે માટે, અમે ક colલમની સંખ્યા નિર્દિષ્ટ કરીએ છીએ. અહીં, પહેલી પંક્તિમાં 1 કumnsલમ છે અને બીજી પંક્તિમાં 3 કumnsલમ છે.

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બ્જેક્ટ XNUMX)કોઈ અન્ય objectબ્જેક્ટ વર્તમાન objectબ્જેક્ટની બરાબર છે કે કેમ તે તપાસે છે
વર્ગ getClass ()વર્ગનું નામ આપે છે
સ્ટ્રિંગ ટૂ સ્ટ્રિંગ ()Ofબ્જેક્ટની શબ્દમાળા રજૂઆત પરત કરે છે
પૂર્ણાંક લંબાઈ ()એરેની લંબાઈ પરત કરે છે

જાવા એરે અપવાદો

અંદર એરે જાવા ફેંકી દે છે નીચે અપવાદ:

  • એરેઇન્ડેક્સઆઉટઓફબાઉન્ડ્સએક્સેપ્શન: આ ત્યારે થાય છે જ્યારે આપણે નિર્દેશિત કરેલ ઇન્ડેક્સ મૂલ્ય એરેની લંબાઈ કરતા વધારે હોય છે અથવા જ્યારે તે નકારાત્મક હોય છે. આ મુખ્યત્વે મૂલ્ય સોંપતી વખતે અથવા એરે તત્વોને ingક્સેસ કરતી વખતે થાય છે.

એરે ક Copyપિ કરો

આપણે વર્ગ સિસ્ટમની મેથડ એરેકોપીની મદદથી તત્વોને એક એરેથી બીજામાં ક copyપિ કરી શકીએ છીએ.

એરે સિન્ટેક્સની ક Copyપિ કરો

સાર્વજનિક રદબાતલ એરેકોપી (sબ્જેક્ટ src, પૂર્ણાંક srcPos, destબ્જેક્ટ ડેસ્ટ, પૂર્ણાંક ડેસ્ટપોસ, પૂર્ણાંક લંબાઈ);

માંથી નકલ કરવા માટે src- સ્રોત એરે objectબ્જેક્ટ

srcPos - સ્ત્રોત એરેમાં પ્રારંભિક સ્થિતિ

ડેસ્ટિનેશન - ગંતવ્ય એરે toબ્જેક્ટ પર નકલ કરવા

ડેસ્ટપોસ - ગંતવ્ય એરેમાં પ્રારંભિક સ્થિતિ

લંબાઈ - નકલ કરવા માટે એરે તત્વોની સંખ્યા

એરેની નકલ કરવાનું ઉદાહરણ

નીચે આપેલા ઉદાહરણમાં, અમે સ્રોત એરેથી 4 તત્વોની ગંતવ્ય એરેમાં કyingપિ કરીએ છીએ. તેથી આઉટપુટ "જાવા" છાપે છે

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

પદ્ધતિને એરે પસાર કરો

જાવામાં, આપણે વધુ મેનીપ્યુલેશન અથવા અન્ય કામગીરી માટેની પદ્ધતિમાં એરે objectબ્જેક્ટ પસાર કરી શકીએ છીએ. નીચેનું ઉદાહરણ બતાવે છે કે આપણે કોઈ પદ્ધતિમાં પૂર્ણાંકોના એરે 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

પદ્ધતિથી એરે રીટર્ન કરો

આપણે પણ કરી શકીએ છીએ એરે પરત કરો આવશ્યક કામગીરી કર્યા પછી પદ્ધતિથી મુખ્ય પદ્ધતિમાં objectબ્જેક્ટ.

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 પેકેજથી સંબંધિત છે. નીચે જણાવેલ કેટલાક જાવા.યુટિલ.અરે વર્ગ દ્વારા સંચાલિત અનેક કામગીરી છે.

  • એક એરેથી બીજામાં તત્વોની શ્રેણીને કોપી કરવા માટે આપણે એરે વર્ગની કોપીઓફરેંજ પદ્ધતિનો ઉપયોગ કરી શકીએ છીએ
  • અનુક્રમણિકાના આધારે વિશિષ્ટ મૂલ્ય માટે એરે શોધો (દ્વિસંગી શોધ)
  • સમાન પદ્ધતિનો ઉપયોગ કરીને સમાનતા તપાસવા માટે એરેની તુલના કરો
  • અનુક્રમણિકા પર વિશિષ્ટ મૂલ્ય મૂકવા માટે એરે ભરવા માટે ભરણ પદ્ધતિનો ઉપયોગ કરો
  • સ theર્ટ પદ્ધતિની મદદથી એરેને સortર્ટ કરી રહ્યા છીએ

વપરાશકર્તા નિર્ધારિત objectબ્જેક્ટનો ઉપયોગ કરીને એરે બનાવવી

જાવામાં, આપણે યુઝર-ડિફાઇન્ડ objectબ્જેક્ટ પણ બનાવી શકીએ છીએ જેમ કે આપણે કેવી રીતે શબ્દમાળાઓ, પૂર્ણાંકો, વગેરેનો એરે બનાવીએ છીએ, આ ઉદાહરણ છે કે આપણે કેવી રીતે સ્ટુડન્ટ એરે createબ્જેક્ટ બનાવી શકીએ અને એરે initialબ્જેક્ટને ઈનીશીલાઇઝ કરી શકીએ.

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

ઉપસંહાર

આ ટ્યુટોરીયલ જાવામાં એરેઝ ક્લાસ, જાવામાં એરેના પ્રકારો, ઘોષણા, બનાવટ અને વિવિધ ચિત્રો સાથે એરે પ્રારંભિક વિગતવાર વર્ણન પ્રદાન કરે છે.

સંદર્ભ