Java, Array yra panašaus tipo kintamųjų, vadinamų bendriniu pavadinimu, grupė. Java masyvai veikia kitaip nei C/C++. Toliau pateikiami keli svarbūs dalykai apie „Java“ masyvus.

Masyvai Java

• Java programoje visi masyvai paskirstomi dinamiškai. (aptarta žemiau)
• Masyvai gali būti saugomi gretimoje atmintyje [nuosekliose atminties vietose].
• Kadangi masyvai yra Java objektai, jų ilgį galime rasti naudodami objekto ypatybę ilgio . Tai skiriasi nuo C/C++, kur ilgį nustatome naudodami sizeof.
• „Java“ masyvo kintamąjį taip pat galima deklaruoti kaip ir kitus kintamuosius su [] po duomenų tipo.
• Kintamieji masyve yra sutvarkyti ir kiekvienas turi indeksą, prasidedantį 0.
• Java masyvas taip pat gali būti naudojamas kaip statinis laukas, vietinis kintamasis arba metodo parametras.

Masyve gali būti primityvių (int, char ir kt.) ir objektų (arba neprimityvių) klasės nuorodų, priklausomai nuo masyvo apibrėžimo. Primityvių duomenų tipų atveju tikrosios reikšmės gali būti saugomos gretimose atminties vietose (JVM tokio elgesio negarantuoja). Klasės objektų atveju tikrieji objektai saugomi krūvos segmente .

c eilučių masyvas

Pastaba: Ši masyvų saugykla padeda mums atsitiktinai pasiekti masyvo elementus [Support Random Access].

Masyvų kūrimas, inicijavimas ir prieiga prie jų

Vienmačiai masyvai

Bendroji vienmačio masyvo deklaracijos forma yra

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

Masyvo deklaraciją sudaro du komponentai: tipas ir pavadinimas. tipo deklaruoja masyvo elemento tipą. Elemento tipas nustato kiekvieno elemento, kurį sudaro masyvas, duomenų tipą. Kaip ir sveikųjų skaičių masyvas, taip pat galime sukurti kitų primityvių duomenų tipų masyvą, pvz., char, float, double ir kt., arba vartotojo apibrėžtus duomenų tipus (klasės objektus). Taigi, masyvo elemento tipas nustato, kokio tipo duomenys bus masyve.

Pavyzdys:

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

Nors pirmoji deklaracija nustato, kad int Array yra masyvo kintamasis, tikrojo masyvo nėra . Tai tik nurodo kompiliatoriui, kad šis kintamasis (int Array) turės sveikojo skaičiaus masyvą. Norėdami susieti int Array su tikruoju, fiziniu sveikųjų skaičių masyvu, turite jį priskirti naudodami naujas ir priskirti jį int Array.

Masyvo kūrimas Java

Kai deklaruojamas masyvas, sukuriama tik masyvo nuoroda. Norėdami sukurti masyvą arba suteikti jam atmintį, sukuriate tokį masyvą: Bendroji forma naujas tai taikoma vienmačiams masyvams, atrodo taip:

var-name = new type [size];>

Čia tipo nurodo paskirstomų duomenų tipą, dydis nustato elementų skaičių masyve, ir var-vardas yra masyvo kintamojo, susieto su masyvu, pavadinimas. Naudoti naujas paskirstyti masyvą, turite nurodyti paskirstomų elementų tipą ir skaičių.

Pavyzdys:

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

Pastaba: Elementai masyve, kuriuos paskirstė naujas bus automatiškai inicijuotas nulis (skaitiniams tipams), klaidinga (loginiam), arba nulinis (referenciniams tipams). Pasidomėkite numatytosios masyvo reikšmės Java .

Masyvo gavimas yra dviejų etapų procesas. Pirmiausia turite deklaruoti norimo masyvo tipo kintamąjį. Antra, turite skirti atmintį masyvei laikyti, naudodami naują, ir priskirti ją masyvo kintamajam. Taigi, Java kalboje , visi masyvai paskirstomi dinamiškai.

„Array Literal“ Java kalba

Esant situacijai, kai masyvo dydis ir masyvo kintamieji jau žinomi, galima naudoti masyvo literalus.

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

• Šio masyvo ilgis lemia sukurto masyvo ilgį.
• Nereikia rašyti naujos int[] dalies naujausiose Java versijose.

Prieiga prie Java masyvo elementų naudojant for Loop

Kiekvienas masyvo elementas pasiekiamas per jo indeksą. Indeksas prasideda 0 ir baigiasi (bendras masyvo dydis) -1. Visus masyvo elementus galima pasiekti naudojant „Java for Loop“.

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

Įgyvendinimas:

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

Pirmiau nurodyto metodo sudėtingumas:

Laiko sudėtingumas: O(n)
Pagalbinė erdvė: O(1)

Taip pat galite pasiekti „Java“ masyvus naudodami kiekvienai kilpai .

seleno pamoka

Objektų masyvai Java

Objektų masyvas sukuriamas kaip primityvaus tipo duomenų elementų masyvas tokiu būdu.

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

Sintaksė:

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

Objektų masyvų pavyzdys

1 pavyzdys:

Žemiau pateikiamas aukščiau nurodytos temos įgyvendinimas:

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>

Mokinių masyve yra penkios atminties vietos, kurių kiekviena yra mokinio klasės dydžio, kurioje gali būti saugomi penkių Mokinio objektų adresai. Studentų objektai turi būti sukurti naudojant Studento klasės konstruktorių, o jų nuorodos masyvo elementams turi būti priskirtos tokiu būdu.

2 pavyzdys:

Žemiau pateikiamas aukščiau nurodytos temos įgyvendinimas:

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

Pirmiau nurodyto metodo sudėtingumas:

Laiko sudėtingumas: O(n)
Pagalbinė erdvė: O(1)

3 pavyzdys

Taip pat sukuriamas objektų masyvas, pavyzdžiui:

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

Kas atsitiks, jei bandysime pasiekti elementus, kurie nėra masyvo dydžio?

JVM metimai ArrayIndexOutOfBoundsException nurodyti, kad masyvas buvo pasiektas naudojant neteisėtą indeksą. Indeksas yra neigiamas arba didesnis arba lygus masyvo dydžiui.

Žemiau esantis kodas rodo, kas atsitiks, jei bandysime pasiekti elementus, kurie nėra masyvo dydžio:

// 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]); } }>

Išvestis

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

Pavyzdys (masyvo kartojimas):

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>

Pirmiau nurodyto metodo sudėtingumas:

Laiko sudėtingumas: O(n), čia n yra masyvo dydis.
Pagalbinė erdvė: O(1) , nes nereikia papildomos vietos.

Daugiamačiai masyvai Java

Daugiamačiai masyvai yra masyvų masyvai kiekvienas masyvo elementas turi kitų masyvų nuorodą. Jie taip pat žinomi kaip Nelygūs masyvai . Daugiamatis masyvas sukuriamas kiekvienam matmeniui pridedant vieną laužtinių skliaustų rinkinį ([]).

Java daugiamačio masyvo sintaksė

Yra 2 būdai, kaip deklaruoti Java daugiamačius masyvus, kaip nurodyta toliau:

javascript miegas

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

Pavyzdys:

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

Daugiamatis masyvo deklaracija

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

„Muilti Dimensional Array“ pavyzdys „Java“.

1 pavyzdys:

Žemiau pateikiamas pirmiau minėto metodo įgyvendinimas:

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

Masyvų perdavimas metodams

Kaip ir kintamuosius, masyvus taip pat galime perduoti metodams. Pavyzdžiui, toliau pateikta programa perduoda masyvą metodui suma norėdami apskaičiuoti masyvo reikšmių sumą.

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

Pirmiau nurodyto metodo sudėtingumas:

Laiko sudėtingumas: O(n)
Pagalbinė erdvė: O(1)

Masyvų grąžinimas iš metodų

Kaip įprasta, metodas taip pat gali grąžinti masyvą. Pavyzdžiui, toliau pateikta programa grąžina masyvą iš metodo 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>

Pirmiau nurodyto metodo sudėtingumas:

Laiko sudėtingumas: O(n)
Pagalbinė erdvė: O(1)

Klasės objektai masyvams

Kiekvienas masyvas turi susietą klasės objektą, bendrinamą su visais kitais masyvais su to paties tipo komponentais.

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

Aukščiau pateikto metodo paaiškinimas:

1. Eilutė [I yra klasės objekto masyvo su komponento tipu vykdymo laiko tipo parašas tarpt .
2. Vienintelė tiesioginė masyvo tipo superklasė yra java.lang.Object .
3. Eilutė [B yra klasės objekto masyvo su komponento tipu vykdymo laiko tipo parašas baitas .
4. Eilutė [S yra klasės objekto masyvo su komponento tipu vykdymo laiko tipo parašas trumpas .
5. Eilutė [L yra klasės objekto masyvo vykdymo laiko tipo parašas su klasės komponento tipu. Tada seka klasės pavadinimas.

Java masyvo nariai

Dabar, kaip žinote, masyvai yra klasės objektai, o tiesioginė masyvų superklasė yra klasės objektas. Masyvo tipo nariai yra visi šie:

• Viešas finalinis laukas ilgio yra masyvo komponentų skaičius. Ilgis gali būti teigiamas arba nulis.
• Visi nariai yra paveldėti iš klasės Object; vienintelis Objekto metodas, kuris nėra paveldimas, yra jo klonas metodas.
• Viešasis metodas klonas () nepaiso klonavimo metodo klasėje Object ir išmeta Nr patikrintos išimtys .

Masyvų tipai ir jų leidžiami elementų tipai

Vienmačio masyvo klonavimas Java

Kai klonuojate vienmatį masyvą, pvz., Object[], gilioji kopija atliekama naudojant naują masyvą, kuriame yra originalaus masyvo elementų kopijos, o ne nuorodos.

matematikos atsitiktinis java

Žemiau pateikiamas pirmiau minėto metodo įgyvendinimas:

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

Daugiamačio masyvo klonavimas Java

Tačiau daugiamačio masyvo klonas (pvz., Objektas[][]) yra sekli kopija, o tai reiškia, kad jis sukuria tik vieną naują masyvą, kuriame kiekvienas elementų masyvas yra nuoroda į pradinį elementų masyvą, tačiau pogrupiai yra pasidalino.

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

Dažniausiai užduodami klausimai Java masyvuose

1. Ar galime nurodyti ilgo masyvo dydį?

Ne, mes negalime nurodyti ilgo masyvo dydžio, bet galime jį nurodyti kaip int arba short.

2. Kuri yra tiesioginė Java masyvo superklasė?

An Objektas yra tiesioginė Java masyvo superklasė.

3. Kurias sąsajas „Java“ įdiegia „Arrays“?

Kiekvienas masyvo tipas įgyvendina sąsajas Cloneable ir java.io.Serializuojama .

4. Ar galime pakeisti masyvo dydį?

Masyvo dydis negali būti pakeistas (paleidus). Tačiau masyvo nuoroda gali būti nukreipta į kitą masyvą.

Susiję straipsniai su tema

• Jagged Array Java
• Kiekvienai „Java“ kilpai
• Masyvų klasė Java