I Java, Array er en gruppe af variabler med samme type, der henvises til med et almindeligt navn. Arrays i Java fungerer anderledes, end de gør i C/C++. Følgende er nogle vigtige punkter om Java-arrays.

Arrays i Java

• I Java er alle arrays dynamisk allokeret. (diskuteret nedenfor)
• Arrays kan gemmes i sammenhængende hukommelse [konsekutive hukommelsesplaceringer].
• Da arrays er objekter i Java, kan vi finde deres længde ved hjælp af objektegenskaben længde . Dette er forskelligt fra C/C++, hvor vi finder længde ved hjælp af sizeof.
• En Java-array-variabel kan også erklæres som andre variabler med [] efter datatypen.
• Variablerne i arrayet er ordnet, og hver har et indeks, der begynder med 0.
• Java-array kan også bruges som et statisk felt, en lokal variabel eller en metodeparameter.

Et array kan indeholde primitiver (int, char osv.) og objekt- (eller ikke-primitive) referencer for en klasse afhængigt af arrayets definition. I tilfælde af primitive datatyper kan de faktiske værdier være gemt i sammenhængende hukommelsesplaceringer (JVM garanterer ikke denne adfærd). I tilfælde af klasseobjekter, de faktiske objekter er gemt i et heap-segment .

modem vs router

Bemærk: Denne lagring af arrays hjælper os med tilfældig adgang til elementerne i et array [Support Random Access].

Oprettelse, initialisering og adgang til et arrays

Endimensionelle arrays

Den generelle form for en endimensionel array-deklaration er

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

En matrixdeklaration har to komponenter: typen og navnet. type erklærer elementtypen for arrayet. Elementtypen bestemmer datatypen for hvert element, der omfatter arrayet. Ligesom en matrix af heltal kan vi også oprette en matrix af andre primitive datatyper som char, float, double osv., eller brugerdefinerede datatyper (objekter i en klasse). Elementtypen for arrayet bestemmer således, hvilken type data arrayet skal indeholde.

Eksempel:

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

Selvom den første erklæring fastslår, at int Array er en array-variabel, der eksisterer ikke noget egentligt array . Det fortæller blot compileren, at denne variabel (int Array) vil indeholde et array af heltalstypen. For at linke int Array med en faktisk, fysisk matrix af heltal, skal du allokere en vha ny og tildel den til int Array.

Instantiering af et array i Java

Når et array erklæres, oprettes kun en reference til et array. For at skabe eller give hukommelse til arrayet, opretter du et array som dette: Den generelle form for ny som det gælder for endimensionelle arrays, ser ud som følger:

var-name = new type [size];>

Her, type specificerer typen af ​​data, der allokeres, størrelse bestemmer antallet af elementer i arrayet, og var-navn er navnet på den array-variabel, der er knyttet til arrayet. At bruge ny at allokere et array, du skal angive typen og antallet af elementer, der skal tildeles.

Eksempel:

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

Bemærk: Elementerne i arrayet tildelt af ny vil automatisk blive initialiseret til nul (for numeriske typer), falsk (for boolesk), eller nul (for referencetyper). Henvis til standard array-værdier i Java .

At opnå et array er en to-trins proces. Først skal du erklære en variabel af den ønskede matrixtype. For det andet skal du allokere hukommelsen til at holde arrayet ved at bruge new og tildele den til arrayvariablen. Dermed, i Java , alle arrays er dynamisk allokeret.

Array Literal i Java

I en situation, hvor størrelsen af ​​arrayet og variablerne af arrayet allerede er kendt, kan arrayliterals bruges.

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

• Længden af ​​dette array bestemmer længden af ​​det oprettede array.
• Der er ingen grund til at skrive den nye int[]-del i de seneste versioner af Java.

Adgang til Java Array Elements ved hjælp af for Loop

Hvert element i arrayet tilgås via dets indeks. Indekset begynder med 0 og slutter ved (samlet matrixstørrelse) -1. Alle elementer i array kan tilgås ved hjælp af Java for Loop.

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

Implementering:

// 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>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n)
Hjælpeplads: O(1)

Du kan også få adgang til java-arrays vha for hver sløjfe .

datastrukturer i java

Arrays af objekter i Java

En matrix af objekter oprettes som en matrix af primitiv type dataelementer på følgende måde.

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

Syntaks:

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

Eksempel på arrays af objekter

Eksempel 1:

Nedenfor er implementeringen af ​​ovennævnte emne:

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>

Elev-arrayet indeholder fem hukommelsespladser hver på størrelse med elevklassen, hvor adressen på fem Student-objekter kan gemmes. Student-objekterne skal instansieres ved hjælp af konstruktøren af ​​Student-klassen, og deres referencer skal tildeles array-elementerne på følgende måde.

Eksempel 2:

Nedenfor er implementeringen af ​​ovennævnte emne:

// 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>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n)
Hjælpeplads: O(1)

Eksempel 3

En række objekter oprettes også 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>

Hvad sker der, hvis vi forsøger at få adgang til elementer uden for matrixstørrelsen?

JVM kaster ArrayIndexOutOfBoundsException for at indikere, at arrayet er blevet tilgået med et ulovligt indeks. Indekset er enten negativt eller større end eller lig med størrelsen af ​​et array.

Nedenstående kode viser, hvad der sker, hvis vi forsøger at få adgang til elementer uden for matrixstørrelsen:

// 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)>

Eksempel (gentagelse af arrayet):

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>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), her er n størrelsen af ​​array.
Hjælpeplads: O(1) , da der ikke kræves ekstra plads.

Multidimensionelle arrays i Java

Multidimensionelle arrays er arrays af arrays med hvert element i arrayet, der holder referencen for andre arrays. Disse er også kendt som Jagged Arrays . En multidimensional matrix oprettes ved at tilføje et sæt firkantede parenteser ([]) pr. dimension.

Syntaks for Java Multidimensional Array

Der er 2 metoder til at erklære Java Multidimensional Arrays som nævnt nedenfor:

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

Eksempel:

// 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>

Multidimensional Array Declaration

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

Eksempel på Muilti Dimensional Array i Java

Eksempel 1:

Nedenfor er implementeringen af ​​ovenstående metode:

indstilling af python-sti

// 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>

Overførsel af arrays til metoder

Ligesom variabler kan vi også overføre arrays til metoder. For eksempel overfører nedenstående program arrayet til metoden sum for at beregne summen af ​​arrayets værdier.

// 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>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: På)
Hjælpeplads: O(1)

Returnering af arrays fra metoder

Som sædvanlig kan en metode også returnere et array. For eksempel returnerer nedenstående program et array fra metode 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>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n)
Hjælpeplads: O(1)

Klasseobjekter til arrays

Hvert array har et tilknyttet klasseobjekt, der deles med alle andre arrays med samme komponenttype.

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

Forklaring af ovenstående metode:

1. Strengen [I er runtime-typesignaturen for klasseobjekt-arrayet med komponenttype int .
2. Den eneste direkte superklasse af en matrixtype er java.lang.Object .
3. Strengen [B er runtime-typesignaturen for klasseobjektarrayet med komponenttype byte .
4. Strengen [S er runtime-typesignaturen for klasseobjekt-arrayet med komponenttype kort .
5. Strengen [L er runtime-typesignaturen for klasseobjektarrayet med komponenttypen af ​​en klasse. Klassenavnet følges derefter.

Java Array medlemmer

Som du ved, er arrays objekter af en klasse, og en direkte superklasse af arrays er et klasseobjekt. Medlemmerne af en matrixtype er alle følgende:

• Det offentlige finalefelt længde indeholder antallet af komponenter i arrayet. Længden kan være positiv eller nul.
• Alle medlemmerne er nedarvet fra klassen Object; den eneste metode til objekt, der ikke er nedarvet, er dens klon metode.
• Den offentlige metode klone() tilsidesætter klonemetoden i klassen Object og kaster no kontrollerede undtagelser .

Arraytyper og deres tilladte elementtyper

Kloning af Single-Dimensional Array i Java

Når du kloner et enkeltdimensionelt array, såsom Objekt[], udføres en dyb kopi med det nye array, der indeholder kopier af det originale arrays elementer i modsætning til referencer.

java objekt til json

Nedenfor er implementeringen af ​​ovenstående metode:

// 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 af multidimensional array i Java

En klon af et multidimensionelt array (som Objekt[][]) er imidlertid en overfladisk kopi, hvilket vil sige, at den kun opretter et enkelt nyt array med hver elementarray en reference til en original elementarray, men subarrays er delt.

// 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>

Ofte stillede spørgsmål i Java Arrays

1. Kan vi angive størrelsen af ​​array så lang?

Nej, vi kan ikke angive størrelsen på arrayet så langt, men vi kan angive det som int eller kort.

2. Hvilken er den direkte superklasse af et array i Java?

An Objekt er direkte superklasse af et array i Java.

3. Hvilke grænseflader implementeres af Arrays i Java?

Hver array-type implementerer grænsefladerne Cloneable og java.io.Serialiserbar .

4. Kan vi ændre størrelsen på Array?

Størrelsen af ​​arrayet kan ikke ændres (når den er initialiseret). Imidlertid kan en array-reference fås til at pege på et andet array.

Relaterede artikler til emnet

• Jagged Array i Java
• For-hver sløjfe i Java
• Arrays klasse i Java