I Java, Array är en grupp av liknande variabler som hänvisas till med ett vanligt namn. Arrayer i Java fungerar annorlunda än de gör i C/C++. Nedan följer några viktiga punkter om Java-arrayer.

Arrayer i Java

• I Java är alla arrayer dynamiskt allokerade. (diskuteras nedan)
• Matriser kan lagras i angränsande minne [konsekutiva minnesplatser].
• Eftersom arrayer är objekt i Java kan vi hitta deras längd med hjälp av objektegenskapen längd . Detta skiljer sig från C/C++, där vi hittar längd med sizeof.
• En Java-arrayvariabel kan också deklareras som andra variabler med [] efter datatypen.
• Variablerna i arrayen är ordnade och var och en har ett index som börjar med 0.
• Java-array kan också användas som ett statiskt fält, en lokal variabel eller en metodparameter.

En array kan innehålla primitiva (int, char, etc.) och objekt (eller icke-primitiva) referenser för en klass beroende på definitionen av arrayen. I fallet med primitiva datatyper kan de faktiska värdena lagras på angränsande minnesplatser (JVM garanterar inte detta beteende). När det gäller klassobjekt, de faktiska objekten lagras i ett högsegment .

konkatenera java-strängar

Notera: Denna lagring av arrayer hjälper oss att slumpmässigt komma åt elementen i en array [Support Random Access].

Skapa, initiera och komma åt en array

Endimensionella arrayer

Den allmänna formen för en endimensionell matrisdeklaration är

-- type var-name[]; -- type[] var-name;>

En matrisdeklaration har två komponenter: typen och namnet. typ deklarerar elementtypen för arrayen. 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). Således bestämmer elementtypen för arrayen vilken typ av data som arrayen kommer att innehålla.

Exempel:

// both are valid declarations int intArray[]; int[] intArray; // similar to int we can declare // byte , short, boolean, long, float // double, char // an array of references to objects of // the class MyClass (a class created by user) MyClass myClassArray[]; // array of Object Object[] ao, // array of Collection // of unknown type Collection[] ca;>

Även om den första deklarationen fastställer att int Array är 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. För att länka int Array med en faktisk, fysisk array av heltal måste du allokera en med hjälp av ny och tilldela den till int Array.

Instantiera en Array i Java

När en matris deklareras skapas endast en referens för en matris. För att skapa eller ge minne till arrayen skapar du en array så här: Den allmänna formen av ny eftersom det gäller endimensionella arrayer ser det ut som följer:

var-name = new type [size];>

Här, typ anger vilken typ av data som tilldelas, storlek bestämmer antalet element i arrayen, och var-namn är namnet på arrayvariabeln som är länkad till arrayen. Att använda ny att tilldela en array, du måste ange typen och antalet element som ska allokeras.

Exempel:

//declaring array int intArray[]; // allocating memory to array intArray = new int[20]; // combining both statements in one int[] intArray = new int[20];>

Notera: Elementen i arrayen tilldelade av ny initieras automatiskt till noll (för numeriska typer), falsk (för booleskt), eller null (för referenstyper). Hänvisa till standardmatrisvärden i Java .

Att erhålla en array är en process i två steg. Först måste du deklarera en variabel av önskad matristyp. För det andra måste du allokera minnet för att hålla arrayen, med nytt, och tilldela det till arrayvariabeln. Således, i Java , alla arrayer är dynamiskt allokerade.

Array Literal i Java

I en situation där storleken på arrayen och variablerna för arrayen redan är kända kan arrayliterals användas.

// Declaring array literal int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };>

• 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.

Åtkomst till Java Array Elements med för Loop

Varje element i arrayen nås via dess index. Indexet börjar med 0 och slutar på (total arraystorlek)-1. Alla element i arrayen kan nås med Java for Loop.

 // accessing the elements of the specified array for (int i = 0; i>

Genomförande:

// Java program to illustrate creating an array // of integers, puts some values in the array, // and prints each value to standard output. class GFG { public static void main(String[] args) { // declares an Array of integers. int[] arr; // allocating memory for 5 integers. arr = new int[5]; // initialize the first elements of the array arr[0] = 10; // initialize the second elements of the array arr[1] = 20; // so on... arr[2] = 30; arr[3] = 40; arr[4] = 50; // 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 : 10 Element at index 1 : 20 Element at index 2 : 30 Element at index 3 : 40 Element at index 4 : 50>

Komplexiteten hos ovanstående metod:

Tidskomplexitet: O(n)
Hjälputrymme: O(1)

Du kan också komma åt java-arrayer med hjälp av för varje slinga .

sortera en arraylist java

Matriser av objekt i Java

En array av objekt skapas som en array av primitiva dataobjekt på följande sätt.

Student[] arr = new Student[5]; //student is a user-defined class>

Syntax:

-- data type[] arrName; -- datatype arrName[]; -- datatype [] arrName;>

Exempel på arrayer av objekt

Exempel 1:

Nedan är implementeringen av ovan nämnda ämne:

import java.io.*; class GFG { public static void main (String[] args) { int [] arr=new int [4]; // 4 is the size of arr System.out.println('Array Size:'+arr.length); } }>

Array Size:4>

Studentarrayen innehåller fem minnesutrymmen vardera av storleken på elevklassen där adressen till fem Studentobjekt kan lagras. Studentobjekten måste instansieras med hjälp av konstruktorn för Studentklassen, och deras referenser bör tilldelas arrayelementen på följande sätt.

Exempel 2:

Nedan är implementeringen av ovan nämnda ämne:

// Java program to illustrate creating // an array of objects class Student { public int roll_no; public String name; Student(int roll_no, String name) { this.roll_no = roll_no; this.name = name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main(String[] args) { // declares an Array of Students Student[] arr; // allocating memory for 5 objects of type Student. arr = new Student[5]; // initialize the first elements of the array arr[0] = new Student(1, 'aman'); // initialize the second elements of the array arr[1] = new Student(2, 'vaibhav'); // so on... 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>

Komplexiteten hos ovanstående metod:

Tidskomplexitet: O(n)
Hjälputrymme: O(1)

Exempel 3

En array av objekt skapas också som:

// Java program to illustrate creating // an array of objects class Student { public String name; Student(String name) { this.name = name; } @Override public String toString(){ return name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main (String[] args) { // declares an Array and initializing the elements of the array Student[] myStudents = new Student[]{new Student('Dharma'),new Student('sanvi'),new Student('Rupa'),new Student('Ajay')}; // accessing the elements of the specified array for(Student m:myStudents){ System.out.println(m); } } }>

Dharma sanvi Rupa Ajay>

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:

// Code for showing error 'ArrayIndexOutOfBoundsException' public class GFG { 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

Trying to access element outside the size of array Exception in thread 'main' java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 4 at GFG.main(GFG.java:13)>

Exempel (iterera arrayen):

public class GFG { public static void main(String[] args) { int[] arr = new int[2]; arr[0] = 10; arr[1] = 20; for (int i = 0; i < arr.length; i++) System.out.println(arr[i]); } }>

10 20>

Komplexiteten hos ovanstående metod:

Tidskomplexitet: O(n), här är n storleken på arrayen.
Hjälputrymme: O(1) , eftersom inget extra utrymme krävs.

Flerdimensionella arrayer i Java

Flerdimensionella arrayer är arrayer av arrayer med varje element i arrayen som håller referensen för andra arrayer. Dessa är också kända som Jagged Arrays . En flerdimensionell array skapas genom att lägga till en uppsättning hakparenteser ([]) per dimension.

Syntax för Java Multidimensional Array

Det finns två metoder för att deklarera Java Multidimensional Arrays som nämns nedan:

-- datatype [][] arrayrefvariable; -- datatype arrayrefvariable[][];>

Exempel:

// Java Program to demonstrate // Java Multidimensional Array import java.io.*; // Driver class class GFG { public static void main(String[] args) { // Syntax int[][] arr = new int[3][3]; // 3 row and 3 column // Number of Rows System.out.println('Number of Rows:'+ arr.length); // Number of Columns System.out.println('Number of Columns:'+ arr[0].length); } }>

Number of Rows:3 Number of Columns:3>

1 miljon i siffror

Flerdimensionell matrisdeklaration

int[][] intArray = new int[10][20]; //a 2D array or matrix int[][][] intArray = new int[10][20][10]; //a 3D array>

Exempel på Muilti Dimensional Array i Java

Exempel 1:

Nedan är implementeringen av ovanstående metod:

// Java Program to Multidimensional Array // Driver Class public class multiDimensional { // main function public static void main(String args[]) { // declaring and initializing 2D array int arr[][] = { { 2, 7, 9 }, { 3, 6, 1 }, { 7, 4, 2 } }; // printing 2D array for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) System.out.print(arr[i][j] + ' '); System.out.println(); } } }>

2 7 9 3 6 1 7 4 2>

Att skicka arrayer till metoder

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

// Java program to demonstrate // passing of array to method public class Test { // 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>

Komplexiteten hos ovanstående metod:

Tidskomplexitet: På)
Hjälputrymme: O(1)

Returnera matriser från metoder

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

// Java program to demonstrate // return of array from method class Test { // 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>

Komplexiteten hos ovanstående metod:

Tidskomplexitet: O(n)
Hjälputrymme: O(1)

Klassobjekt för arrayer

Varje array har ett associerat Class-objekt, delat med alla andra arrayer med samma komponenttyp.

// Java program to demonstrate // Class Objects for Arrays class Test { public static void main(String args[]) { int intArray[] = new int[3]; byte byteArray[] = new byte[3]; short shortsArray[] = new short[3]; // array of Strings String[] strArray = new String[3]; System.out.println(intArray.getClass()); System.out.println( intArray.getClass().getSuperclass()); System.out.println(byteArray.getClass()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); } }>

class [I class java.lang.Object class [B class [S class [Ljava.lang.String;>

Förklaring av ovanstående metod:

1. Strängen [I är körtidstypsignaturen för klassobjektmatrisen med komponenttyp int .
2. Den enda direkta superklassen av en arraytyp är java.lang.Object .
3. Strängen [B är körtidstypsignaturen för klassobjektmatrisen med komponenttyp byte .
4. Strängen [S är körtidstypsignaturen för klassobjektmatrisen med komponenttyp kort .
5. Strängen [L är körtidstypsignaturen för klassobjektmatrisen med komponenttyp av en klass. Klassnamnet följs sedan.

Java Array-medlemmar

Som ni vet är arrayer objekt i en klass, och en direkt superklass av arrayer är ett klassobjekt. Medlemmarna i en matristyp är alla följande:

• Det offentliga finalfältet längd innehåller antalet komponenter i arrayen. Längden kan vara positiv eller noll.
• Alla medlemmar ärvs från klassen Object; den enda metoden för objekt som inte ärvs är dess klona metod.
• Den offentliga metoden klona() åsidosätter klonmetoden i klassen Object och kastar nr kontrollerade undantag .

Arraytyper och deras tillåtna elementtyper

Kloning av Single-Dimensional Array i Java

När du klona en endimensionell array, till exempel Object[], utförs en djupkopiering med den nya arrayen som innehåller kopior av den ursprungliga arrayens element i motsats till referenser.

blockerade kontakter

Nedan är implementeringen av ovanstående metod:

// Java program to demonstrate // cloning of one-dimensional arrays class Test { public static void main(String args[]) { int intArray[] = { 1, 2, 3 }; int cloneArray[] = intArray.clone(); // will print false as deep copy is created // for one-dimensional array System.out.println(intArray == cloneArray); for (int i = 0; i < cloneArray.length; i++) { System.out.print(cloneArray[i] + ' '); } } }>

false 1 2 3>

Kloning av flerdimensionell array i Java

En klon av en flerdimensionell array (som Object[][]) är dock en ytlig kopia, vilket vill säga att den bara skapar en enda ny array med varje element array en referens till en original element array, men subarrays är delad.

// Java program to demonstrate // cloning of multi-dimensional arrays class Test { public static void main(String args[]) { int intArray[][] = { { 1, 2, 3 }, { 4, 5 } }; int cloneArray[][] = intArray.clone(); // will print false System.out.println(intArray == cloneArray); // will print true as shallow copy is created // i.e. sub-arrays are shared System.out.println(intArray[0] == cloneArray[0]); System.out.println(intArray[1] == cloneArray[1]); } }>

false true true>

Vanliga frågor i Java Arrays

1. Kan vi ange storleken på arrayen så lång?

Nej, vi kan inte ange storleken på arrayen så lång men vi kan ange den som int eller kort.

2. Vilken är den direkta superklassen för en array i Java?

En Objekt är direkt superklass av en array i Java.

3. Vilka gränssnitt implementeras av Arrays i Java?

Varje arraytyp implementerar gränssnitten Cloneable och java.io.Serialiserbar .

4. Kan vi ändra storleken på Array?

Storleken på arrayen kan inte ändras (när den har initierats). En arrayreferens kan emellertid göras för att peka på en annan array.

Relaterade artiklar till ämnet

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