I Java är en array en viktig linjär datastruktur som tillåter oss att lagra flera värden av samma typ.

• Arrayer i Java är objekt som alla andra objekt i Java-arrayer implicit ärver från klassen java.lang.Object. Detta låter dig anropa metoder definierade i Object (som toString() equals() och hashCode()).
• Matriser har en inbyggd längdegenskap som ger antalet element i matrisen

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // initializing array      int  []     arr     =     {  40       55       63       17       22  };      // size of array      int     n     =     arr  .  length  ;      // traversing array      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }   }   

40 55 63 17 22  

Huvudfunktioner i Arrays

• Lagra primitiver och objekt: Java-arrayer kan hålla både primitiva typer (som int char boolean etc.) och objekt (som String Integer etc.)
• Kontinuerlig minnestilldelning När vi använder arrayer av primitiva typer lagras elementen på sammanhängande platser. För icke primitiva typer lagras referenser till objekt på sammanhängande platser.
• Nollbaserad indexering: Det första elementet i arrayen är vid index 0.
• Fast längd: Efter att ha skapat en array är dess storlek fixerad; vi kan inte ändra det.

Grunder Användning på Arrays i Java

1. Deklarera en array

Den allmänna formen av matrisdeklaration är 

// Metod 1:
int arr[];

// Metod 2:
int[] arr;

Elementtypen bestämmer datatypen för varje element som består av arrayen. Liksom en array av heltal kan vi också skapa en array av andra primitiva datatyper som char float double etc. eller användardefinierade datatyper (objekt i en klass).

Notera: Det är bara hur vi kan skapa en arrayvariabel ingen faktisk array existerar. Den säger bara till kompilatorn att denna variabel (int Array) kommer att innehålla en array av heltalstypen.

2. Initiera en Array i Java

När en array deklareras skapas endast en referens till en array. Vi använder ny för att allokera en array av given storlek.

int arr[] = ny int[storlek];

• Array Declaration är i allmänhet statisk men om storleken inte är definierad är Arrayen dynamiskt dimensionerad.
• Minne för arrayer är alltid dynamiskt allokerat (på heap-segment) i Java. Detta skiljer sig från C/C++ där minnet antingen kan tilldelas statiskt eller dynamiskt.
• Elementen i arrayen som allokeras av new kommer automatiskt att initialiseras till noll (för numeriska typer), false (för boolean) eller null (för referenstyper).

Array Literal i Java

I en situation där storleken på arrayen och variabler i arrayen redan är kända arrayliterals kan användas. 

// Deklarerar array literal
int[] arr = ny int[]{ 12345678910 };

• Längden på denna array bestämmer längden på den skapade arrayen.
• Det finns inget behov av att skriva den nya delen int[] i de senaste versionerna av Java.

3. Ändra ett matriselement

För att ändra ett element tilldela ett nytt värde till ett specifikt index. Indexet börjar med 0 och slutar på (total arraystorlek)-1.

// Ändra det första elementet till 90
arr[0] = 90;

4. Arraylängd

Vi kan få längden på en array med hjälp av egenskapen length:

// Hämta längden på arrayen
int n = arr.längd;

5. Åtkomst och uppdatering av alla arrayelement

• Alla element i arrayen kan nås med Java for Loop.
• Varje element i arrayen nås via dess index.

Java-program för att illustrera att skapa en array av heltal lägger några värden i arrayen och skriver ut varje värde till standardutdata

   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // declares an Array of integers.      int  []     arr  ;      // allocating memory for 5 integers.      arr     =     new     int  [  5  ]  ;      // initialize the elements of the array      // first to last(fifth) element      arr  [  0  ]     =     2  ;      arr  [  1  ]     =     4  ;      arr  [  2  ]     =     8  ;      arr  [  3  ]     =     12  ;      arr  [  4  ]     =     16  ;      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at index '     +      i     +     ' : '     +     arr  [  i  ]  );      }   }   

Element at index 0 : 2 Element at index 1 : 4 Element at index 2 : 8 Element at index 3 : 12 Element at index 4 : 16  

Matriser av objekt i Java

En array av objekt skapas som en array av primitiva dataobjekt

Exempel : Här tar vi en elevklass och skapar en array av Student med fem Studentobjekt lagrade i arrayen. Studentobjekten måste instansieras med hjälp av konstruktorn för Studentklassen och deras referenser ska tilldelas arrayelementen.

   class   Student     {      public     int     roll_no  ;      public     String     name  ;          Student  (  int     roll_no       String     name  ){      this  .  roll_no     =     roll_no  ;      this  .  name     =     name  ;      }   }   public     class   Geeks     {      public     static     void     main  (  String  []     args  ){          // declares an Array of Student      Student  []     arr  ;      // allocating memory for 5 objects of type Student.      arr     =     new     Student  [  5  ]  ;      // initialize the elements of the array      arr  [  0  ]     =     new     Student  (  1       'aman'  );      arr  [  1  ]     =     new     Student  (  2       'vaibhav'  );      arr  [  2  ]     =     new     Student  (  3       'shikar'  );      arr  [  3  ]     =     new     Student  (  4       'dharmesh'  );      arr  [  4  ]     =     new     Student  (  5       'mohit'  );      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at '     +     i     +     ' : { '      +     arr  [  i  ]  .  roll_no     +     ' '      +     arr  [  i  ]  .  name  +  ' }'  );      }   }   

Element at 0 : { 1 aman } Element at 1 : { 2 vaibhav } Element at 2 : { 3 shikar } Element at 3 : { 4 dharmesh } Element at 4 : { 5 mohit }  

Vad händer om vi försöker komma åt element utanför arraystorleken?

JVM kastar ArrayIndexOutOfBoundsException för att indikera att arrayen har nåtts med ett olagligt index. Indexet är antingen negativt eller större än eller lika med storleken på en array.

Nedanstående kod visar vad som händer om vi försöker komma åt element utanför arraystorleken:

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      int  []     arr     =     new     int  [  4  ]  ;      arr  [  0  ]     =     10  ;      arr  [  1  ]     =     20  ;      arr  [  2  ]     =     30  ;      arr  [  3  ]     =     40  ;      System  .  out  .  println  (      'Trying to access element outside the size of array'  );      System  .  out  .  println  (  arr  [  5  ]  );      }   }   

Produktion:

Att skicka arrayer till metoder

Liksom variabler kan vi också skicka arrayer till metoder. Till exempel överför programmet nedan arrayen till metodsumma för att beräkna summan av arrayens värden.

Exempel:

   public     class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     {     3       1       2       5       4     };      // passing array to method m1      sum  (  arr  );      }      public     static     void     sum  (  int  []     arr  )      {      // getting sum of array values      int     sum     =     0  ;      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      sum     +=     arr  [  i  ]  ;      System  .  out  .  println  (  'sum of array values : '     +     sum  );      }   }   

sum of array values : 15  

Förklaring

• Detta Java-program visar hur man skickar en array till en metod.
• En heltalsmatris arr deklareras och initieras i huvudmetoden.
• Sum()-metoden anropas med arr som argument.
• Inuti sum()-metoden läggs alla arrayelement till med en for-loop.
• Den slutliga summan skrivs sedan ut på konsolen.

Returnera arrayer från metoder

Som vanligt kan en metod också returnera en array. Till exempel returnerar programmet nedan en array från metod m1. 

Exempel:

   class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     m1  ();      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }      public     static     int  []     m1  ()      {      // returning array      return     new     int  []     {     1       2       3     };      }   }   

1 2 3  

Fördelar med Java Arrays

• Effektiv åtkomst: Att komma åt ett element genom dess index är snabbt och har konstant tidskomplexitet O(1).
• Minneshantering: Arrayer har fast storlek vilket gör minneshanteringen enkel och förutsägbar.
• Dataorganisation: Matriser hjälper till att organisera data på ett strukturerat sätt vilket gör det lättare att hantera relaterade element.

Nackdelar med Java Arrays

• Fast storlek: När en array väl har skapats kan dess storlek inte ändras, vilket kan leda till minnesförlust om storleken överskattas eller otillräcklig lagring om den underskattas.
• Typhomogenitet: Matriser kan bara lagra element av samma datatyp som kan kräva ytterligare hantering för blandade typer av data.
• Insättning och radering: Att infoga eller ta bort element, särskilt i mitten av en array, kan vara kostsamt eftersom det kan kräva att element flyttas.

Relaterade inlägg

• Jagged Array i Java
• För varje slinga i Java
• Arrays klass i Java