Java valodā masīvs ir līdzīga tipa mainīgo grupa, kas apzīmēta ar parastu nosaukumu. Java masīvi darbojas savādāk nekā C/C++. Tālāk ir minēti daži svarīgi punkti par Java masīviem.

Masīvi Java valodā

• Java visi masīvi tiek dinamiski piešķirti. (apspriests tālāk)
• Masīvus var saglabāt blakus esošajā atmiņā [secīgās atmiņas vietās].
• Tā kā masīvi ir Java objekti, mēs varam atrast to garumu, izmantojot objekta rekvizītu garums . Tas atšķiras no C/C++, kur mēs atrodam garumu, izmantojot sizeof.
• Java masīva mainīgo var arī deklarēt tāpat kā citus mainīgos ar [] aiz datu tipa.
• Mainīgie lielumi masīvā ir sakārtoti, un katram ir indekss, kas sākas ar 0.
• Java masīvu var izmantot arī kā statisku lauku, lokālo mainīgo vai metodes parametru.

Masīvs var saturēt klases primitīvus (int, char utt.) un objektu (vai neprimitīvas) atsauces atkarībā no masīva definīcijas. Primitīvu datu tipu gadījumā faktiskās vērtības var tikt saglabātas blakus esošās atmiņas vietās (JVM negarantē šo darbību). Klases objektu gadījumā faktiskie objekti tiek glabāti kaudzes segmentā .

java krāsas

Piezīme: Šī masīvu krātuve palīdz mums nejauši piekļūt masīva elementiem [Atbalsts Random Access].

Masīvu izveide, inicializācija un piekļuve tiem

Viendimensijas masīvi

Viendimensijas masīva deklarācijas vispārējā forma ir

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

Masīva deklarācijai ir divas sastāvdaļas: veids un nosaukums. veids deklarē masīva elementa veidu. Elementa veids nosaka katra elementa datu tipu, kas veido masīvu. Tāpat kā veselu skaitļu masīvu, mēs varam izveidot arī citu primitīvu datu tipu masīvu, piemēram, char, float, double utt., vai lietotāja definētus datu tipus (klases objektus). Tādējādi masīva elementa tips nosaka, kāda veida dati masīvā tiks glabāti.

Piemērs:

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

Lai gan pirmā deklarācija nosaka, ka int Array ir masīva mainīgais, faktiskais masīvs nepastāv . Tas tikai norāda kompilatoram, ka šim mainīgajam (int Array) būs vesela skaitļa tipa masīvs. Lai saistītu int Array ar faktisku, fizisku veselu skaitļu masīvu, jums tas ir jāpiešķir, izmantojot jauns un piešķiriet to int Array.

Masīva izveide Java valodā

Kad tiek deklarēts masīvs, tiek izveidota tikai atsauce uz masīvu. Lai izveidotu masīvu vai piešķirtu tam atmiņu, izveidojiet šādu masīvu: Vispārīgā forma jauns tā, kā tas attiecas uz viendimensijas masīviem, izskatās šādi:

var-name = new type [size];>

Šeit, veids norāda piešķiramo datu veidu, Izmērs nosaka elementu skaitu masīvā, un var-nosaukums ir masīva mainīgā nosaukums, kas ir saistīts ar masīvu. Izmantot jauns piešķirt masīvu, jānorāda piešķiramo elementu veids un skaits.

Piemērs:

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

Piezīme: Elementi masīvā, ko piešķir jauns tiks automātiski inicializēts uz nulle (ciparu veidiem), viltus (būla vērtībai) vai null (atsauces veidiem). Atsaucieties uz noklusējuma masīva vērtības Java .

Masīva iegūšana ir divpakāpju process. Pirmkārt, jums ir jādeklarē vēlamā masīva veida mainīgais. Otrkārt, jums ir jāpiešķir atmiņa masīva turēšanai, izmantojot jaunu, un jāpiešķir tas masīva mainīgajam. Tādējādi Java valodā , visi masīvi tiek dinamiski piešķirti.

Masīvs Literāls Java valodā

Situācijā, kad masīva lielums un masīva mainīgie jau ir zināmi, var izmantot masīva literāļus.

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

• Šī masīva garums nosaka izveidotā masīva garumu.
• Jaunākajās Java versijās nav jāraksta jaunā int[] daļa.

Piekļuve Java masīva elementiem, izmantojot for Loop

Katram masīva elementam var piekļūt, izmantojot tā indeksu. Indekss sākas ar 0 un beidzas ar (kopējais masīva lielums) -1. Visiem masīva elementiem var piekļūt, izmantojot Java for Loop.

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

Īstenošana:

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

Iepriekš minētās metodes sarežģītība:

Laika sarežģītība: O(n)
Palīgtelpa: O(1)

Varat arī piekļūt Java masīviem, izmantojot katrai cilpai .

int virknē

Objektu masīvi Java valodā

Objektu masīvs tiek izveidots kā primitīva tipa datu vienumu masīvs šādā veidā.

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

Sintakse:

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

Objektu masīvu piemērs

1. piemērs:

Zemāk ir aprakstīta iepriekš minētās tēmas īstenošana:

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>

Studentu masīvā ir piecas atmiņas vietas, katra no studentu klases lieluma, kurās var saglabāt piecu studentu objektu adreses. Studentu objekti ir jāizveido, izmantojot Studentu klases konstruktoru, un to atsauces jāpiešķir masīva elementiem šādā veidā.

2. piemērs:

Zemāk ir aprakstīta iepriekš minētās tēmas īstenošana:

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

Iepriekš minētās metodes sarežģītība:

Laika sarežģītība: O(n)
Palīgtelpa: O(1)

3. piemērs

Tiek izveidots arī objektu masīvs, piemēram:

// 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 notiek, ja mēģinām piekļūt elementiem ārpus masīva lieluma?

JVM met ArrayIndexOutOfBoundsException lai norādītu, ka masīvam ir piekļūts ar nelegālu indeksu. Indekss ir negatīvs vai lielāks vai vienāds ar masīva lielumu.

Zemāk redzamais kods parāda, kas notiek, ja mēģinām piekļūt elementiem ārpus masīva lieluma:

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

Izvade

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

Piemērs (masīva atkārtošana):

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>

Iepriekš minētās metodes sarežģītība:

Laika sarežģītība: O(n), šeit n ir masīva lielums.
Palīgtelpa: O(1) , jo nav nepieciešama papildu vieta.

Daudzdimensiju masīvi Java valodā

Daudzdimensiju masīvi ir masīvu masīvi katram masīva elementam ir atsauce uz citiem masīviem. Tie ir pazīstami arī kā Robains masīvs . Daudzdimensiju masīvs tiek izveidots, katrai dimensijai pievienojot vienu kvadrātiekavu kopu ([]).

Java daudzdimensiju masīva sintakse

Ir 2 metodes Java daudzdimensiju masīvu deklarēšanai, kā minēts tālāk:

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

Piemērs:

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

Daudzdimensiju masīva deklarācija

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

Muilti dimensiju masīva piemērs Java valodā

1. piemērs:

Zemāk ir aprakstīta iepriekš minētās metodes ieviešana:

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

Masīvu nodošana metodēm

Tāpat kā mainīgie, mēs varam arī nodot masīvus metodēm. Piemēram, zemāk esošā programma nodod masīvu metodei summa lai aprēķinātu masīva vērtību summu.

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

Iepriekš minētās metodes sarežģītība:

Laika sarežģītība: O(n)
Palīgtelpa: O(1)

Masīvu atgriešana no metodēm

Kā parasti, metode var arī atgriezt masīvu. Piemēram, tālāk esošā programma atgriež masīvu no metodes m1 .

mašīnmācīšanās veidi

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

Iepriekš minētās metodes sarežģītība:

Laika sarežģītība: O(n)
Palīgtelpa: O(1)

Klases objekti masīviem

Katram masīvam ir saistīts klases objekts, kas koplietots ar visiem citiem masīviem ar tādu pašu komponenta tipu.

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

Iepriekš minētās metodes skaidrojums:

1. Virkne [I ir izpildlaika tipa paraksts klases objekta masīvam ar komponenta tipu starpt .
2. Vienīgā tiešā masīva tipa virsklase ir java.lang.Object .
3. Virkne [B ir izpildlaika tipa paraksts klases objekta masīvam ar komponenta tipu baits .
4. Virkne [S ir izpildlaika tipa paraksts klases objekta masīvam ar komponenta tipu īss .
5. Virkne [L ir izpildlaika tipa paraksts klases objekta masīvam ar klases komponenta tipu. Pēc tam seko klases nosaukums.

Java masīva dalībnieki

Tagad, kā jūs zināt, masīvi ir klases objekti, un tieša masīvu virsklase ir klases objekts. Masīva tipa dalībnieki ir visi šie:

• Publiskais fināla lauks garums satur masīva komponentu skaitu. Garums var būt pozitīvs vai nulle.
• Visi dalībnieki ir mantoti no klases Object; vienīgā objekta metode, kas nav mantota, ir tā klons metodi.
• Publiskā metode klons () ignorē klona metodi klasē Object un met Nr pārbaudīti izņēmumi .

Masīvu veidi un to atļautie elementu veidi

Viendimensiju masīva klonēšana Java

Klonējot viendimensijas masīvu, piemēram, Object[], tiek veikta dziļā kopija, izmantojot jauno masīvu, kurā ir sākotnējā masīva elementu kopijas, nevis atsauces.

java oops jēdzieni

Zemāk ir aprakstīta iepriekš minētās metodes ieviešana:

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

Daudzdimensiju masīva klonēšana Java

Daudzdimensiju masīva klons (piemēram, objekts[][]) tomēr ir sekla kopija, kas nozīmē, ka tas rada tikai vienu jaunu masīvu ar katru elementu masīvu atsauci uz sākotnējo elementu masīvu, bet apakšmasīvi ir dalīts.

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

Bieži uzdotie jautājumi Java masīvos

1. Vai mēs varam norādīt masīva lielumu tik ilgi?

Nē, mēs nevaram norādīt tik gara masīva lielumu, bet mēs varam norādīt to kā int vai īsu.

2. Kura ir Java tiešā masīva virsklase?

An Objekts ir tieša masīva virsklase Java valodā.

3. Kuras saskarnes Java programmā ievieš masīvi?

Katrs masīva veids ievieš saskarnes Cloneable un java.io.Serializējams .

4. Vai mēs varam mainīt masīva lielumu?

Masīva lielumu nevar mainīt (pēc inicializācijas). Tomēr masīva atsauci var veikt, lai norādītu uz citu masīvu.

Ar tēmu saistīti raksti

• Robains masīvs Java valodā
• Katrai cilpai Java
• Masīvu klase Java valodā