Javassa Array on ryhmä samantyyppisiä muuttujia, joihin viitataan yleisellä nimellä. Javan taulukot toimivat eri tavalla kuin C/C++:ssa. Seuraavassa on joitakin tärkeitä kohtia Java-taulukoista.

Taulukot Javassa

• Javassa kaikki taulukot allokoidaan dynaamisesti. (käsitelty alla)
• Matriisit voidaan tallentaa viereiseen muistiin [peräkkäisiin muistipaikkoihin].
• Koska taulukot ovat Java-objekteja, voimme selvittää niiden pituuden objektiominaisuuden avulla pituus . Tämä eroaa C/C++:sta, josta löydämme pituuden sizeof:n avulla.
• Java-taulukkomuuttuja voidaan myös ilmoittaa muiden muuttujien tapaan käyttämällä []-merkkiä tietotyypin jälkeen.
• Matriisin muuttujat ovat järjestyksessä, ja jokaisella on 0:lla alkava indeksi.
• Java-taulukkoa voidaan käyttää myös staattisena kenttänä, paikallisena muuttujana tai menetelmäparametrina.

Taulukko voi sisältää luokan primitiivejä (int, char jne.) ja objektiviittauksia (tai ei-primitiivisiä) taulukon määritelmästä riippuen. Primitiivisten tietotyyppien tapauksessa todelliset arvot saatetaan tallentaa vierekkäisiin muistipaikkoihin (JVM ei takaa tätä toimintaa). Luokkaobjektien tapauksessa todelliset objektit tallennetaan kasasegmenttiin .

Madhubala

Huomautus: Tämä taulukoiden tallennus auttaa meitä pääsemään satunnaisesti taulukon elementteihin [Support Random Access].

Taulukon luominen, alustaminen ja käyttäminen

Yksiulotteiset taulukot

Yksiulotteisen taulukkoilmoituksen yleinen muoto on

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

Taulukkomäärityksessä on kaksi osaa: tyyppi ja nimi. tyyppi ilmoittaa taulukon elementtityypin. Elementtityyppi määrittää kunkin taulukon muodostavan elementin tietotyypin. Kuten kokonaislukutaulukko, voimme myös luoda joukon muita primitiivisiä tietotyyppejä, kuten char, float, double jne., tai käyttäjän määrittämiä tietotyyppejä (luokan objekteja). Siten taulukon elementtityyppi määrittää, minkä tyyppistä dataa taulukko sisältää.

Esimerkki:

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

Vaikka ensimmäinen ilmoitus määrittää, että int Array on taulukkomuuttuja, varsinaista joukkoa ei ole olemassa . Se vain kertoo kääntäjälle, että tämä muuttuja (int Array) sisältää kokonaislukutyyppisen taulukon. Jos haluat linkittää int-taulukon todelliseen, fyysiseen kokonaislukutaulukkoon, sinun on allokoitava yksi käyttämällä Uusi ja määritä se int Arraylle.

Array:n luominen Javassa

Kun taulukko on ilmoitettu, vain taulukon viite luodaan. Jos haluat luoda taulukon tai antaa sille muistia, luo taulukon seuraavasti: Yleinen muoto Uusi koska se koskee yksiulotteisia taulukoita, näyttää seuraavalta:

var-name = new type [size];>

Tässä, tyyppi määrittää allokoitavien tietojen tyypin, koko määrittää taulukon elementtien lukumäärän ja var-nimi on taulukkomuuttujan nimi, joka on linkitetty taulukkoon. Käyttää Uusi varata joukko, sinun on määritettävä allokoitavien elementtien tyyppi ja lukumäärä.

Esimerkki:

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

Huomautus: Matriisin elementit, jotka on allokoinut Uusi alustetaan automaattisesti nolla (numeerisille tyypeille), väärä (boolean), tai tyhjä (viitetyypeille). Viittaa oletustaulukon arvot Javassa .

Taulukon saaminen on kaksivaiheinen prosessi. Ensin sinun on ilmoitettava halutun taulukon tyyppinen muuttuja. Toiseksi, sinun on varattava muisti taulukon säilyttämiseksi käyttämällä uutta ja määritettävä se taulukon muuttujalle. Täten, Javassa , kaikki taulukot allokoidaan dynaamisesti.

Array Literal Javassa

Tilanteessa, jossa taulukon koko ja taulukon muuttujat ovat jo tiedossa, voidaan käyttää taulukkoliteraaaleja.

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

• Tämän taulukon pituus määrittää luodun taulukon pituuden.
• Uusissa Java-versioissa ei tarvitse kirjoittaa uutta int[]-osaa.

Java Array Elements -elementtien käyttö silmukan avulla

Jokaista taulukon elementtiä käytetään sen indeksin kautta. Indeksi alkaa 0:lla ja päättyy (kokonaiskoko)-1. Kaikki taulukon elementit ovat käytettävissä Java for Loop -sovelluksella.

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

Toteutus:

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

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n)
Aputila: O(1)

Voit myös käyttää Java-taulukoita käyttämällä jokaiselle silmukalle .

mitä google tarkoittaa

Objektijoukot Javassa

Objektijoukko luodaan kuten primitiivityyppisten tietokohteiden joukko seuraavalla tavalla.

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

Syntaksi:

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

Esimerkki objektitaulukoista

Esimerkki 1:

Alla on edellä mainitun aiheen toteutus:

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>

Opiskelijataulukko sisältää viisi opiskelijaluokan kokoista muistitilaa, joihin voidaan tallentaa viiden opiskelijaobjektin osoitteet. Student-objektit on instantoitava Student-luokan konstruktorilla ja niiden viittaukset tulee osoittaa taulukon elementteihin seuraavasti.

Esimerkki 2:

Alla on edellä mainitun aiheen toteutus:

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

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n)
Aputila: O(1)

Esimerkki 3

Luodaan myös joukko objekteja, kuten:

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

Mitä tapahtuu, jos yritämme päästä käsiksi taulukon koon ulkopuolisiin elementteihin?

JVM heittää ArrayIndexOutOfBoundsException ilmaisemaan, että taulukkoa on käytetty laittomalla indeksillä. Indeksi on joko negatiivinen tai suurempi tai yhtä suuri kuin taulukon koko.

Alla oleva koodi näyttää, mitä tapahtuu, jos yritämme käyttää taulukon koon ulkopuolisia elementtejä:

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

Lähtö

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

Esimerkki (Matriisin iterointi):

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>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n), tässä n on taulukon koko.
Aputila: O(1) , koska lisätilaa ei tarvita.

Moniulotteiset taulukot Javassa

Moniulotteiset taulukot ovat taulukoita jossa jokaisella taulukon elementillä on muiden taulukoiden viite. Nämä tunnetaan myös nimellä Jagged Arrays . Moniulotteinen taulukko luodaan lisäämällä yksi hakasulkusarja ([]) ulottuvuutta kohti.

Java-moniulotteisen taulukon syntaksi

Java-moniulotteisten taulukoiden ilmoittamiseen on kaksi tapaa, kuten alla on mainittu:

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

Esimerkki:

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

vertaa javaan

Moniulotteinen taulukkoilmoitus

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

Esimerkki Muilti Dimensional Arraysta Javassa

Esimerkki 1:

Alla on yllä olevan menetelmän toteutus:

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

Taulukkojen siirtäminen menetelmiin

Kuten muuttujat, voimme myös välittää taulukoita menetelmille. Esimerkiksi alla oleva ohjelma välittää taulukon menetelmälle summa laskeaksesi taulukon arvojen summan.

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

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: Päällä)
Aputila: O(1)

Taulukon palauttaminen menetelmistä

Kuten tavallista, menetelmä voi myös palauttaa taulukon. Esimerkiksi alla oleva ohjelma palauttaa taulukon menetelmästä 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>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: O(n)
Aputila: O(1)

Luokkaobjektit taulukoille

Jokaiseen taulukkoon liittyy luokkaobjekti, joka jaetaan kaikkien muiden saman komponenttityypin taulukoiden kanssa.

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

Selitys yllä olevasta menetelmästä:

1. Merkkijono [I on komponenttityypin luokan objektitaulukon ajonaikainen allekirjoitus int .
2. Ainoa suora taulukkotyypin superluokka on java.lang.Object .
3. Merkkijono [B on ajonaikaisen tyypin allekirjoitus luokan objektitaulukolle, jossa on komponenttityyppi tavu .
4. Merkkijono [S on ajonaikaisen tyypin allekirjoitus luokan objektitaulukolle, jossa on komponenttityyppi lyhyt .
5. Merkkijono [L on ajonaikaisen tyypin allekirjoitus luokan objektitaulukolle, jonka komponenttityyppi on luokka. Tämän jälkeen seuraa luokan nimeä.

Java Array -jäsenet

Kuten tiedät, taulukot ovat luokan objekteja ja taulukoiden suora superluokka on luokan Object. Taulukkotyypin jäsenet ovat kaikki seuraavat:

• Julkinen finaalikenttä pituus sisältää taulukon komponenttien määrän. Pituus voi olla positiivinen tai nolla.
• Kaikki jäsenet ovat peritty luokasta Object; Ainoa Objektin menetelmä, joka ei ole peritty, on sen klooni menetelmä.
• Julkinen menetelmä klooni() ohittaa kloonimenetelmän luokassa Object ja heittää no tarkistetut poikkeukset .

Taulukkotyypit ja niiden sallitut elementtityypit

Yksiulotteisen taulukon kloonaus Javassa

Kun kloonaat yksiulotteisen taulukon, kuten Object[], syväkopio tehdään uudella taulukolla, joka sisältää kopioita alkuperäisen taulukon elementeistä viittausten sijaan.

kulmikas materiaali

Alla on yllä olevan menetelmän toteutus:

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

Moniulotteisen taulukon kloonaus Javassa

Moniulotteisen taulukon klooni (kuten Object[][]) on kuitenkin matala kopio, mikä tarkoittaa, että se luo vain yhden uuden taulukon, jossa jokainen elementtitaulukko viittaa alkuperäiseen elementtitaulukkoon, mutta alitaulukot ovat jaettu.

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

Usein kysytyt kysymykset Java-taulukoissa

1. Voimmeko määrittää taulukon koon niin pitkäksi?

Ei, emme voi määrittää taulukon kokoa niin pitkäksi, mutta voimme määrittää sen int tai short.

2. Mikä on Java-taulukon suora superluokka?

An Esine on Java-taulukon suora superluokka.

3. Mitä rajapintoja Arrays toteuttaa Javassa?

Jokainen taulukkotyyppi toteuttaa liitännät Cloneable ja java.io.Serialoitavissa .

4. Voimmeko muuttaa Arrayn kokoa?

Matriisin kokoa ei voi muuttaa (kun se on alustettu). Matriisiviittaus voidaan kuitenkin tehdä osoittamaan toiseen taulukkoon.

Aiheeseen liittyviä artikkeleita

• Jagged Array Javassa
• Jokaiselle silmukalle Javassa
• Arrays-luokka Javassa