I Java, Array er en gruppe av like-type variabler referert til med et felles navn. Arrays i Java fungerer annerledes enn de gjør i C/C++. Følgende er noen viktige punkter om Java-matriser.

Arrays i Java

• I Java er alle arrays dynamisk tildelt. (diskutert nedenfor)
• Matriser kan lagres i sammenhengende minne [konsekutive minneplasseringer].
• Siden matriser er objekter i Java, kan vi finne lengden deres ved å bruke objektegenskapen lengde . Dette er forskjellig fra C/C++, hvor vi finner lengde ved å bruke sizeof.
• En Java-matrisevariabel kan også deklareres som andre variabler med [] etter datatypen.
• Variablene i matrisen er ordnet, og hver har en indeks som begynner med 0.
• Java-array kan også brukes som et statisk felt, en lokal variabel eller en metodeparameter.

En matrise kan inneholde primitiver (int, char, etc.) og objekt- (eller ikke-primitive) referanser til en klasse avhengig av definisjonen av matrisen. Når det gjelder primitive datatyper, kan de faktiske verdiene være lagret i sammenhengende minneplasseringer (JVM garanterer ikke denne oppførselen). Når det gjelder klasseobjekter, de faktiske objektene er lagret i et haugsegment .

css første barn

Merk: Denne lagringen av arrays hjelper oss med tilfeldig tilgang til elementene i en array [Support Random Access].

Opprette, initialisere og få tilgang til en matrise

Endimensjonale matriser

Den generelle formen for en endimensjonal matriseerklæring er

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

En matriseerklæring har to komponenter: typen og navnet. type erklærer elementtypen til matrisen. Elementtypen bestemmer datatypen for hvert element som består av matrisen. Som en rekke heltall, kan vi også lage en rekke andre primitive datatyper som char, float, double, etc., eller brukerdefinerte datatyper (objekter av en klasse). Dermed bestemmer elementtypen for matrisen hvilken type data matrisen skal inneholde.

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

Selv om den første erklæringen fastslår at int Array er en matrisevariabel, ingen faktisk array eksisterer . Den forteller bare kompilatoren at denne variabelen (int Array) vil inneholde en matrise av heltallstypen. For å koble int Array med en faktisk, fysisk matrise av heltall, må du tildele en ved å bruke ny og tilordne den til int Array.

Instantiering av en matrise i Java

Når en matrise erklæres, opprettes bare en referanse til en matrise. For å lage eller gi minne til matrisen, lager du en matrise som dette: Den generelle formen for ny som det gjelder endimensjonale arrays ser ut som følger:

var-name = new type [size];>

Her, type spesifiserer typen data som tildeles, størrelse bestemmer antall elementer i matrisen, og var-name er navnet på matrisevariabelen som er koblet til matrisen. Å bruke ny å tildele en matrise, du må spesifisere typen og antall elementer som 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];>

Merk: Elementene i matrisen tildelt av ny vil automatisk initialiseres til null (for numeriske typer), falsk (for boolsk), eller null (for referansetyper). referer til standard matriseverdier i Java .

Å skaffe en matrise er en to-trinns prosess. Først må du deklarere en variabel av ønsket matrisetype. For det andre må du tildele minnet til å holde matrisen, ved å bruke ny, og tilordne den til matrisevariabelen. Dermed, i Java , alle arrays er dynamisk allokert.

Array Literal i Java

I en situasjon der størrelsen på matrisen og variablene til matrisen allerede er kjent, kan matriseliteraler brukes.

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

• Lengden på denne matrisen bestemmer lengden på den opprettede matrisen.
• Det er ikke nødvendig å skrive den nye int[]-delen i de nyeste versjonene av Java.

Få tilgang til Java Array Elements ved å bruke for Loop

Hvert element i matrisen er tilgjengelig via sin indeks. Indeksen begynner med 0 og slutter på (total matrisestørrelse) -1. Alle elementene i array kan nås ved å bruke Java for Loop.

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

Gjennomføring:

// 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 til metoden ovenfor:

Tidskompleksitet: O(n)
Hjelpeområde: O(1)

Du kan også få tilgang til java-arrays ved å bruke for hver løkke .

int i streng

Arrays av objekter i Java

En rekke objekter opprettes som en rekke dataelementer av primitiv type på følgende måte.

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

Syntaks:

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

Eksempel på matriser av objekter

Eksempel 1:

Nedenfor er implementeringen av det ovennevnte emnet:

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>

Studentarrayet inneholder fem minneplasser hver på størrelse med elevklassen der adressen til fem studentobjekter kan lagres. Student-objektene må instansieres ved å bruke konstruktøren til Student-klassen, og referansene deres skal tilordnes array-elementene på følgende måte.

Eksempel 2:

Nedenfor er implementeringen av det ovennevnte emnet:

// 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 til metoden ovenfor:

Tidskompleksitet: O(n)
Hjelpeområde: O(1)

Eksempel 3

En rekke objekter er også laget 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>

Hva skjer hvis vi prøver å få tilgang til elementer utenfor matrisestørrelsen?

JVM kaster ArrayIndexOutOfBoundsException for å indikere at matrisen har blitt åpnet med en ulovlig indeks. Indeksen er enten negativ eller større enn eller lik størrelsen på en matrise.

Koden nedenfor viser hva som skjer hvis vi prøver å få tilgang til elementer utenfor matrisestø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]); } }>

Produksjon

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 (gjentakelse av matrisen):

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 til metoden ovenfor:

Tidskompleksitet: O(n), her er n størrelsen på matrisen.
Hjelpeområde: O(1) , siden ingen ekstra plass kreves.

Flerdimensjonale matriser i Java

Flerdimensjonale arrays er arrays av arrays med hvert element i matrisen som inneholder referansen til andre matriser. Disse er også kjent som Jagged Arrays . En flerdimensjonal matrise opprettes ved å legge til ett sett med firkantede parenteser ([]) per dimensjon.

Syntaks for Java Multidimensional Array

Det er 2 metoder for å erklære Java Multidimensional Arrays som nevnt 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>

Flerdimensjonal array-erklæring

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 av metoden ovenfor:

wumpus verden

// 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øring av matriser til metoder

I likhet med variabler kan vi også overføre matriser til metoder. For eksempel overfører programmet nedenfor matrisen til metoden sum for å beregne summen av matrisens verdier.

// 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 til metoden ovenfor:

Tidskompleksitet: På)
Hjelpeplass: O(1)

Returnerer matriser fra metoder

Som vanlig kan en metode også returnere en matrise. For eksempel returnerer programmet nedenfor en matrise fra 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>

Kompleksiteten til metoden ovenfor:

Tidskompleksitet: O(n)
Hjelpeområde: O(1)

Klasseobjekter for matriser

Hver matrise har et tilknyttet klasseobjekt, delt med alle andre matriser 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 av metoden ovenfor:

1. Strengen [I er kjøretidstypesignaturen for klasseobjektmatrisen med komponenttype int .
2. Den eneste direkte superklassen av en matrisetype er java.lang.Object .
3. Strengen [B er kjøretidstypesignaturen for klasseobjektmatrisen med komponenttype byte .
4. Strengen [S er kjøretidstypesignaturen for klasseobjektmatrisen med komponenttype kort .
5. Strengen [L er kjøretidstypesignaturen for klasseobjektmatrisen med komponenttypen til en klasse. Klassenavnet følges deretter.

Java Array-medlemmer

Nå, som du vet, er matriser objekter av en klasse, og en direkte superklasse av matriser er et klasseobjekt. Medlemmene av en matrisetype er alle følgende:

• Det offentlige finalefeltet lengde inneholder antall komponenter i matrisen. Lengden kan være positiv eller null.
• Alle medlemmene er arvet fra klassen Object; den eneste metoden for objekt som ikke er arvet er dens klone metode.
• Den offentlige metoden klone() overstyrer klonemetoden i klassen Object og kaster no sjekket unntak .

Matrisetyper og deres tillatte elementtyper

Kloning av endimensjonal array i Java

Når du kloner en endimensjonal matrise, for eksempel Objekt[], utføres en dyp kopi med den nye matrisen som inneholder kopier av den originale matrisens elementer i motsetning til referanser.

java objekt til json

Nedenfor er implementeringen av metoden ovenfor:

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

En klone av en flerdimensjonal matrise (som Objekt[][]) er imidlertid en grunn kopi, det vil si at den bare oppretter en enkelt ny matrise med hver elementmatrise en referanse til en original elementmatrise, men subarrayer 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 stilte spørsmål i Java Arrays

1. Kan vi spesifisere størrelsen på matrisen så lang?

Nei, vi kan ikke spesifisere størrelsen på matrisen så lang, men vi kan spesifisere den som int eller kort.

2. Hvilken er den direkte superklassen til en matrise i Java?

An Gjenstand er direkte superklasse av en matrise i Java.

3. Hvilke grensesnitt implementeres av Arrays i Java?

Hver matrisetype implementerer grensesnittene Cloneable og java.io.Serialiserbar .

4. Kan vi endre størrelsen på Array?

Størrelsen på matrisen kan ikke endres (når den er initialisert). Imidlertid kan en matrisereferanse gjøres til å peke til en annen matrise.

Relaterte artikler til emnet

• Jagged Array i Java
• For hver sløyfe i Java
• Arrays-klassen i Java