Massivlar - Java dasturlash tili

Massiv - o'lchami o'zgarmaydigan, bir xil turdagi elementlar ketma-ketligi. Java'da u eng past darajadagi to'plam turi.

Yaratish #

Java

import java.util.Arrays;

public class Yaratish {
    public static void main(String[] args) {
        int[] a = {85, 92, 78};                  // qisqa yozuv
        int[] b = new int[3];                    // nollar bilan
        int[] c = new int[]{1, 2, 3};            // to'liq yozuv
        String[] d = new String[2];              // null lar bilan

        System.out.println("a: " + Arrays.toString(a));
        System.out.println("b: " + Arrays.toString(b));
        System.out.println("c: " + Arrays.toString(c));
        System.out.println("d: " + Arrays.toString(d));
        System.out.println("a uzunligi: " + a.length);
    }
}

Natija

a: [85, 92, 78]
b: [0, 0, 0]
c: [1, 2, 3]
d: [null, null]
a uzunligi: 3

Sukut qiymatlari

new int[3] uchta nol beradi, bo'sh emas. Har bir tur uchun sukut qiymati bor:

Tur	Sukut qiymati
`int`, `long`, `short`, `byte`	`0`
`double`, `float`	`0.0`
`boolean`	`false`
`char`	`''`
Har qanday obyekt	`null`

Oxirgi qator muhim: new String[2] ikkita null beradi va ularga murojaat qilish NullPointerException beradi.

Arrays sinfi #

Massivlar bilan ishlashning deyarli barcha vositalari shu sinfda:

Java

import java.util.Arrays;

public class Vositalar {
    public static void main(String[] args) {
        int[] sonlar = {5, 3, 9, 1, 7};

        int[] nusxa = Arrays.copyOf(sonlar, sonlar.length);
        Arrays.sort(nusxa);

        System.out.println("Asl:        " + Arrays.toString(sonlar));
        System.out.println("Saralangan: " + Arrays.toString(nusxa));
        System.out.println("9 ning o'rni: " + Arrays.binarySearch(nusxa, 9));
        System.out.println("Birinchi 3 ta: "
                + Arrays.toString(Arrays.copyOfRange(nusxa, 0, 3)));

        int[] toldirilgan = new int[4];
        Arrays.fill(toldirilgan, 7);
        System.out.println("To'ldirilgan: " + Arrays.toString(toldirilgan));

        System.out.println("Yig'indi: " + Arrays.stream(sonlar).sum());
        System.out.println("Eng katta: "
                + Arrays.stream(sonlar).max().getAsInt());
    }
}

Natija

Asl:        [5, 3, 9, 1, 7]
Saralangan: [1, 3, 5, 7, 9]
9 ning o'rni: 4
Birinchi 3 ta: [1, 3, 5]
To'ldirilgan: [7, 7, 7, 7]
Yig'indi: 25
Eng katta: 9

Metod	Vazifasi
`Arrays.toString`	Chop etish uchun matnga o'giradi
`Arrays.sort`	Saralaydi (asl massivni o'zgartiradi)
`Arrays.copyOf`	Nusxa oladi
`Arrays.copyOfRange`	Bir qismini nusxalaydi
`Arrays.fill`	Bir xil qiymat bilan to'ldiradi
`Arrays.equals`	Mazmunini solishtiradi
`Arrays.binarySearch`	Saralangan massivda qidiradi
`Arrays.stream`	Stream'ga o'giradi (16-bo'lim)

binarySearch faqat saralangan massivda

Arrays.binarySearch ikkilik qidiruv qiladi va u massiv saralangan deb faraz qiladi.

Saralanmagan massivda u xato bermaydi - shunchaki noto'g'ri javob qaytaradi. Bu topilishi qiyin xato turi.

Avval Arrays.sort, keyin binarySearch.

Massivni chop etish #

Java

import java.util.Arrays;

public class ChopEtish {
    public static void main(String[] args) {
        int[] sonlar = {1, 2, 3};

        String xom = sonlar.toString();
        int belgi = xom.indexOf('@');

        System.out.println("Turi:         " + xom.substring(0, belgi));
        System.out.println("Manzil qismi: "
                + xom.substring(belgi + 1).length()
                + " belgidan iborat va har safar boshqacha");
        System.out.println("Arrays bilan: " + Arrays.toString(sonlar));
    }
}

Natija

Turi:         [I
Manzil qismi: 8 belgidan iborat va har safar boshqacha
Arrays bilan: [1, 2, 3]

Massivni to'g'ridan-to'g'ri chop etmang

System.out.println(sonlar) yozsangiz, [I@2a139a55 kabi narsa chiqadi. Uning qismlari:

[ - bu massiv;
I - elementlar turi int (I - integer);
@ dan keyin - obyektning o'n oltilik xesh kodi.

Massivlar toString() ni qayta belgilamaydi, shuning uchun Object dagi sukut versiyasi ishlaydi.

Yuqoridagi misolda manzil qismi ataylab chop etilmadi: u har ishga tushirishda boshqacha bo'ladi. Shuning uchun kod faqat uning uzunligini ko'rsatadi.

Bu muhim qoida: bunday chiqishni hech qachon solishtirmang, faylga yozmang yoki sinovda kutilgan qiymat sifatida ishlatmang.

Har doim Arrays.toString ishlating, ko'p o'lchovli massiv uchun esa Arrays.deepToString.

Massivlarni solishtirish #

Java

import java.util.Arrays;

public class Solishtirish {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};

        System.out.println("a == b            : " + (a == b));
        System.out.println("a.equals(b)       : " + a.equals(b));
        System.out.println("Arrays.equals(a,b): " + Arrays.equals(a, b));
    }
}

Natija

a == b            : false
a.equals(b)       : false
Arrays.equals(a,b): true

Massivlarda equals ham qayta belgilanmagan - u == bilan bir xil ishlaydi. Mazmunni solishtirish uchun faqat Arrays.equals.

Nusxalash #

Java

import java.util.Arrays;

public class Nusxa {
    public static void main(String[] args) {
        int[] asl = {1, 2, 3};

        int[] havola = asl;                          // nusxa EMAS
        int[] haqiqiy = Arrays.copyOf(asl, asl.length);

        havola[0] = 99;
        System.out.println("Havoladan keyin: " + Arrays.toString(asl));

        haqiqiy[1] = 77;
        System.out.println("Nusxadan keyin:  " + Arrays.toString(asl));
        System.out.println("Nusxaning o'zi:  " + Arrays.toString(haqiqiy));
    }
}

Natija

Havoladan keyin: [99, 2, 3]
Nusxadan keyin:  [99, 2, 3]
Nusxaning o'zi:  [1, 77, 3]

int[] havola = asl nusxa yaratmaydi - u bitta massivga ikkinchi nom beradi. Shuning uchun havola[0] = 99 asl massivda ham ko'rindi.

Nusxaning birinchi elementi esa 1 bo'lib qoldi - chunki Arrays.copyOf 99 yozilishidan oldin bajarilgan. Bu nusxaning haqiqatan mustaqil ekanini yana bir bor tasdiqlaydi: keyingi o'zgarishlar unga yetib bormadi.

Haqiqiy nusxa uchun Arrays.copyOf yoki clone() kerak.

Ko'p o'lchovli massivlar #

Java

import java.util.Arrays;

public class KopOlchov {
    public static void main(String[] args) {
        int[][] jadval = new int[3][4];

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                jadval[i][j] = (i + 1) * (j + 1);
            }
        }

        for (int[] qator : jadval) {
            for (int qiymat : qator) {
                System.out.printf("%4d", qiymat);
            }
            System.out.println();
        }

        System.out.println(Arrays.deepToString(jadval));
    }
}

Natija

   1   2   3   4
   2   4   6   8
   3   6   9  12
[[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12]]

Tishli massivlar #

Java'da "ko'p o'lchovli massiv" aslida massivlar massivi, shuning uchun qatorlar turli uzunlikda bo'lishi mumkin:

Java

public class Tishli {
    public static void main(String[] args) {
        int[][] tishli = {
                {1},
                {1, 2},
                {1, 2, 3}
        };

        for (int[] qator : tishli) {
            System.out.println(qator.length + " ta element");
        }

        System.out.println("Qatorlar soni: " + tishli.length);
        System.out.println("Ikkinchi qator uzunligi: " + tishli[1].length);
    }
}

Natija

1 ta element
2 ta element
3 ta element
Qatorlar soni: 3
Ikkinchi qator uzunligi: 2

Massiv kovariantligi #

Bu Java'ning kam ma'lum, lekin xavfli xususiyati:

Java

public class Kovariantlik {
    public static void main(String[] args) {
        String[] satrlar = {"a", "b"};
        Object[] obyektlar = satrlar;        // ruxsat etiladi

        System.out.println("Kompilyatsiya o'tdi");

        try {
            obyektlar[0] = 42;               // ishga tushganda qulaydi
        } catch (ArrayStoreException x) {
            System.out.println("Istisno: " + x.getClass().getSimpleName());
            System.out.println("Sabab:   " + x.getMessage());
        }
    }
}

Natija

Kompilyatsiya o'tdi
Istisno: ArrayStoreException
Sabab:   java.lang.Integer

Kompilyator ruxsat berdi, JVM esa qaytardi

String[] ni Object[] ga o'zlashtirishga Java ruxsat beradi - bunga kovariantlik deyiladi.

Muammo shundaki, Object[] ga har qanday obyekt yozish mumkindek tuyuladi. Kompilyator qarshilik qilmaydi. Lekin ishga tushganda JVM massivning haqiqiy turini tekshiradi va ArrayStoreException tashlaydi.

Ya'ni bu xato kompilyatsiyada emas, ishlash paytida topiladi - eng yomon variant.

Aynan shu sabab generiklar kovariant emas: List<String> ni List<Object> ga o'zlashtirib bo'lmaydi. Bu boshida noqulay tuyuladi, lekin u sizni shu xatodan himoya qiladi. 14-bo'limda bu masalaga qaytamiz.

Amaliy xulosa: massiv o'rniga List ishlating - u xavfsizroq.

Massiv yoki List? #

Holat	Tanlov
O'lcham qat'iy va ma'lum	Massiv
Elementlar soni o'zgaradi	`List`
Primitivlar, million element, tezlik muhim	Massiv
Oddiy kundalik ish	`List`
API qaytaradigan qiymat	`List` - xavfsizroq

Amalda Java dasturchilari massivni kamdan-kam ishlatadi. Asosiy sabablar: o'lcham o'zgarmaydi, toString foydasiz, equals ishlamaydi va kovariantlik xavfli.

Keyingi bo'limlardan birida List va boshqa kolleksiyalarni ko'ramiz.

Amaliy topshiriq

To'rt xil usulda massiv yarating va sukut qiymatlarini ko'ring.
new String[3] yaratib, elementlariga murojaat qiling.
Massivni System.out.println bilan to'g'ridan-to'g'ri chop eting.
Arrays.toString bilan qayta chop eting va farqni tushuntiring.
Ikki massivni ==, equals va Arrays.equals bilan solishtiring.
Arrays.copyOf bilan haqiqiy nusxa oling va tekshiring.
Saralanmagan massivda binarySearch ni sinab, natijani baholang.
3x4 ko'p o'lchovli massiv yarating va deepToString bilan chiqaring.
Har xil uzunlikdagi tishli massiv yarating.
Massiv kovariantligi tuzog'ini takrorlang.

Xulosa #

Massiv o'lchami o'zgarmas; new int[3] nollar, new String[3] esa null lar beradi.
Massivda length maydon, satrda length() metod.
Massivni to'g'ridan-to'g'ri chop etsangiz manzil chiqadi - Arrays.toString ishlating.
Mazmunni solishtirish uchun Arrays.equals; == va equals havolani solishtiradi.
int[] b = a nusxa emas - Arrays.copyOf ishlating.
binarySearch faqat saralangan massivda to'g'ri ishlaydi.
Java'da ko'p o'lchovli massiv - massivlar massivi, qatorlar turli uzunlikda bo'lishi mumkin.
Massiv kovariantligi ArrayStoreException ga olib keladi - shuning uchun amalda List afzal.

Keyingi bo'limda metodlarni o'rganamiz.

Yaratish #

Arrays sinfi #

Massivni chop etish #

Massivlarni solishtirish #

Nusxalash #

Ko'p o'lchovli massivlar #

Tishli massivlar #

Massiv kovariantligi #

Massiv yoki List? #

Xulosa #

Xatolik topdingizmi?