Java'da yeni bir dizi oluşturun. Java'da diziler - tanımlama ve oluşturma, başlatma ve doldurma

dizi aynı türden verileri depolamak için tasarlanmış bir veri yapısıdır. Java'daki diziler, C/C++'dakinden farklı çalışır. Özellikler:

• Diziler nesne olduğu için uzunluklarını bulabiliriz. Bu, uzunluğu sizeof kullanarak bulduğumuz C/C++'dan farklıdır.
• Bir dizi değişkeni de olabilir.
• Değişkenler sıralanmıştır ve 0'dan başlayan bir dizine sahiptir.
• Statik alan, yerel değişken veya yöntem parametresi olarak da kullanılabilir.
• Bir dizinin boyutu, uzun veya kısa değil, bir int olmalıdır.
• Bir dizi türünün doğrudan üst sınıfı Object'tir.
• Her dizi türü, Cloneable ve Java.io.Serializable arabirimlerini uygular.

Başlatma ve dizi erişimi

Tek Boyutlu Diziler: Genel Bildirim Formu

Var-name yazın; veya var-name yazın;

Bir bildirimin iki bileşeni vardır: bir tür ve bir ad. type, bir dizi öğesinin türünü bildirir. Öğe türü, her öğenin veri türünü belirler.

int tipine ek olarak, char, float, double veya kullanıcı tanımlı veri tipi (sınıf nesneleri) gibi başka veri tiplerinden oluşan bir dizi de oluşturabiliriz.Böylece, eleman tipi ne tip veri olacağını belirler. dizide saklanır. Örneğin:

// ikisi de geçerli bildirimlerdir int intArray; veya int dizisi; bayt byteArray; şortArray; boolean booleanArray; uzun longArray; float floatArray; çift ​​doubleArray; char charArray; // MyClass sınıfının ( // user tarafından oluşturulan bir sınıf) MyClass myClassArray'in // nesnelerine referans dizisi; Object ao, // Object Collection dizisi ca; // Koleksiyon dizisi // bilinmeyen türde

Yukarıdaki ilk bildirim, intArray öğesinin bir dizi değişkeni olduğu gerçeğini ortaya koysa da, dizi aslında mevcut değildir. Derleyiciye bu değişkenin tamsayı türünde olduğunu söyler.

Bir int dizisini gerçek bir fiziksel tamsayı dizisiyle ilişkilendirmek için onu new ile belirtmeli ve int'ye atamalısınız.

Java'da bir dizi nasıl oluşturulur

Bir dizi bildirildiğinde, yalnızca diziye bir başvuru oluşturulur. Bir diziyi gerçekten oluşturmak veya depolamak için şuna benzer bir dizi yaratırsınız: new öğesinin tek boyutlu olanlara uygulandığındaki genel biçimi şu şekildedir:
var-name = yeni tür ;

Burada tür, veri türünü, boyut dizideki öğelerin sayısını belirtir ve var-name, dizi değişkeninin adıdır.

int dizisi; //bildirim intArray = yeni int; // bellek ayırma

int intArray = yeni int; // bir ilişkilendirme

new tarafından atanan dizi öğelerinin otomatik olarak sıfıra (sayısal türler için), false (boole türleri için) veya sıfıra (referans türleri için) başlatıldığını bilmek önemlidir.
Dizi almak iki adımlı bir işlemdir. İlk olarak, istediğiniz türde bir değişken tanımlamanız gerekir. İkinci olarak, new kullanarak diziyi içerecek belleği ayırmanız ve onu bir değişkene atamanız gerekir. Yani Java'da tüm diziler dinamik olarak tahsis edilmiştir.

Dizi Değişmezleri

Dizi boyutunun ve değişkenlerin zaten bilindiği bir durumda, değişmez değerler kullanılabilir.

int intArray = yeni int( 1,2,3,4,5,6,7,8,9,10); // Dizi değişmezi bildiriliyor

• Bu dizinin uzunluğu, oluşturulan dizinin uzunluğunu belirler.
• Java'nın son sürümlerinde int yazmaya gerek yok

Bir for Döngüsü ile Java Dizi Öğelerine Erişme

Dizinin her elemanına kendi indeksi üzerinden erişilir. Dizin 0'dan başlar ve (toplam boyut)-1'de biter. Tüm öğelere bir for döngüsü ile erişilebilir.

(int i = 0; i için< arr.length; i++) System.out.println("Element at index " + i + " : "+ arr[i]);

// Bir dizinin oluşturulmasını gösteren bir örnek
// tamsayılar, bazı değerleri bir diziye koyar,
// ve her değeri çıkar.

sınıf GFG
{

{

int dizi;

// 5 tam sayı için bellek ayırma.
dizi = yeni int;

dizi = 10;

dizi = 20;

//yakında...
dizi = 30;
dizi = 40;
dizi=50;

// belirtilen dizinin elemanlarına erişim
for (int ben = 0; ben< arr.length; i++)
System.out.println("İndeksteki eleman" + i +
" : "+ dizi[i]);
}
}
Sonuç olarak şunları elde ederiz:

Dizin 0: 10 Dizin 1: 20 Dizin 2: 30 Dizin 3: 40 Dizin 4'teki öğe: 50

Nesne dizileri

Veri öğeleriyle aynı şekilde aşağıdaki gibi bir nesne dizisi oluşturulur:

Öğrenci arr = yeni Öğrenci;

StudentArray, her biri öğrenci sınıfından yedi adet Student nesnesinin adreslerinin saklanabileceği yedi depolama öğesi içerir. Öğrenci nesneleri, öğrenci sınıfı yapıcısı kullanılarak oluşturulmalı ve referansları aşağıdaki gibi dizi öğelerine atanmalıdır:

Öğrenci arr = yeni Öğrenci;

// Bir dizi oluşturmayı gösteren Java programı
// nesneler

sınıf Öğrenci
{
public int roll_no;
public Stringname;
Student(int roll_no, Dize adı)
{
this.roll_no = roll_no;
this.name = isim;
}
}

// Dizinin öğeleri, Student sınıfının nesneleridir.
genel sınıf GFG
{
public static void main(String args)
{
// bir tamsayı dizisi bildirir.
öğrenci arr;

// Student türündeki 5 nesne için bellek ayırma.
arr = yeni Öğrenci;

// dizinin ilk elemanlarını başlat
arr = new Student(1,"aman");

// dizinin ikinci elemanlarını başlat
arr = new Student(2,"vaibhav");

// yakında...
arr = new Student(3,"shikar");
arr = new Student(4,"dharmesh");
arr = new Student(5,"mohit");

// belirtilen dizinin elemanlarına erişim
for (int ben = 0; ben< arr.length; i++)
System.out.println("Element " + i + " : " +
dizi[i].roll_no +" "+ dizi[i].name);
}
}

Alırız:

0: 1 aman Öğe 1: 2 vaibhav Öğe 2: 3 shikar Öğe 3: 4 dharmesh Öğe 4: 5 mohit

Dizinin dışındaki bir öğeye erişmeye çalışırsak ne olur?
Derleyici, bir diziye geçersiz bir dizinle erişildiğini belirtmek için bir ArrayIndexOutOfBoundsException oluşturur. Dizin, dizinin boyutuna eşit veya ondan büyük veya ona eşit.

Çok boyutlu

Çok boyutlu diziler, her elemanın başka bir diziye referans içerdiği dizi dizileridir. Her boyut için bir dizi köşeli parantez () eklenerek oluşturulur. Bir örnek düşünün:

int intArray = yeni int; // bir 2B dizi veya matris int intArray = yeni int; // bir 3B dizi

sınıf çok boyutlu
{
genel statik boşluk ana (Stringargs)
{
// 2B diziyi bildirme ve başlatma
int dizi = ( (2,7,9),(3,6,1),(7,4,2) );

// 2B diziyi yazdırma
for (int i=0; ben< 3 ; i++)
{
for (int j=0; j< 3 ; j++)
System.out.print(arr[i][j] + " ");

System.out.println();
}
}
}

Çıktı: 2 7 9 3 6 1 7 4 2

Dizileri Bir Yönteme Geçmek

Tıpkı değişkenler gibi, dizileri de yöntemlere geçirebiliriz.

// Gösterilecek Java programı // dizinin yöntem sınıfına geçirilmesi Test ( // Sürücü yöntemi public static void main(String args) ( int arr = (3, 1, 2, 5, 4); // diziyi yönteme geçirme m1 toplam(dizi); ) genel statik geçersiz toplam(int dizi) ( // dizi değerlerinin toplamını alma int toplam = 0; for (int i = 0; i< arr.length; i++) sum+=arr[i]; System.out.println("sum of array values: " + sum); } }

Çıktıda şunları elde ederiz:

dizi değerlerinin toplamı: 15

Yöntemlerden dizi döndürme

Her zamanki gibi, yöntem bir dizi de döndürebilir. Örneğin, aşağıdaki program m1'den bir dizi döndürür.

// Gösterilecek Java programı // yöntem sınıfından dizi dönüşü Test ( // Sürücü yöntemi 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}; } }

sınıf nesneleri

Her dizinin, aynı bileşen türüne sahip diğer tüm dizilerle paylaşılan ilişkili bir sınıf nesnesi vardır.

// Gösterilecek Java programı // Diziler için Sınıf Nesneleri sınıf Test ( public static void main(String args) ( int intArray = yeni int; byte byteArray = yeni bayt; kısa shortsArray = yeni kısa; // Strings dizisi String strArray = new String;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()); ) )

sınıf+""); ) ))

Çok boyutlu bir dizinin klonu ( Object gibi) bir kopyadır; bu, her öğeyle yalnızca bir yeni dizi ve orijinal öğe dizisine bir başvuru oluşturduğu anlamına gelir, ancak iç içe diziler yaygındır.

// Çok boyutlu dizilerin klonlanmasını gösteren Java programı class Test ( public static void main(String args) ( int intArray = ((1,2,3),(4,5)); int cloneArray = intArray. klon(); // false yazdıracak System.out.println(intArray == cloneArray); // sığ kopya oluşturulduğunda doğru yazdıracak // yani alt diziler paylaşılıyor System.out.println(intArray == cloneArray) ;System.out.println(intArray == cloneArray); ) )

Tek boyutlu dizilerin nasıl oluşturulacağını öğrendik. Benzer şekilde Java'da iki boyutlu, üç boyutlu, dört boyutlu... çok boyutlu diziler Java'da çok boyutlu bir dizi, aslında bir dizi dizisidir.

Bu tür dizilerin kullanımının popüler bir örneği, iki boyutlu dizilerle temsil edilen matrislerdir. Peki, matris nedir ve Java'da iki boyutlu bir dizi kullanarak nasıl temsil edilir.

Java'da matrisler ve iki boyutlu diziler

Bir matris, kesişme noktalarında öğeleri olan satır ve sütunlardan oluşan dikdörtgen bir tablodur. Bir matrisin satır ve sütun sayısı onun boyutunu belirler.

Matris boyutunun genel görünümü m x n(m - satır sayısı, n- sütun sayısı) , aşağıdaki gibi:

Matrisin her bir elemanının kendi indeksi vardır, burada ilk basamak elemanın bulunduğu satırın numarasını, ikincisi ise sütunun numarasını gösterir.

Belirli matrislerin örneklerine bakalım ve bunları Java kullanarak oluşturalım.

Matris A 2'ye 3 (2 satır, 3 sütun) boyutuna sahiptir. Bu boyutun iki boyutlu bir dizisini oluşturalım:

int matrisA; matrixA = yeni int ;

İki boyutlu bir tamsayı dizisi ilan ettik (çünkü bu durumda matris tamsayılar içeriyor) ve bunun için ayrılmış bellek. Bunu yapmak için 2 dizin kullandık: ilk dizin satırı ve boyutunu tanımlar, ikinci dizin sütunu ve boyutunu tanımlar.

İki boyutlu bir dizinin öğelerine erişmek için 2 dizin kullanmalısınız: ilki satır için, ikincisi sütun için. Tek boyutlu dizilerde olduğu gibi, dizinler de sıfırdan başlar. Bu nedenle tablodaki satır ve sütunların numaralandırılması 0'dan başlar.

MatrisA=1; matrisA = -2; matrisA = 3; matrisA = 4; matrisA = 1; matrisA = 7;

Matrisi konsolda görüntülemek için tüm öğeleri iki döngü kullanarak gözden geçirmeniz gerekir. Dizinin öğelerinden geçerken döngü sayısı, boyutuna eşittir. Bizim durumumuzda, ilk döngü satırlarda, ikinci - sütunlarda gerçekleştirilir.

(int i = 0; i için< 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); }

Yani ilk önce ilk satırın tüm öğelerini "\t" sekme karakteriyle ayırarak görüntülüyoruz, satırı aktarıyoruz ve ikinci satırın tüm öğelerini görüntülüyoruz.

Matris için tam kod ANCAK aşağıdaki gibi:

Genel sınıf Matrix ( public static void main(String args) ( int matrixA; matrixA = yeni int; matrixA = 1; matrixA = -2; matrixA = 3; matrixA = 4; matrixA = 1; matrixA = 7; for (int i) = 0; ben< 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); } } }

matris için B hadi kullanalım basitleştirilmiş başlatma yolu- duyuru sırasında. Tek boyutlu dizilere benzeterek.

Int matrisB = ( (-9,1,0), (4,1,1), (-2,2,-1) );

Dizinin her satırı bir çift kaşlı ayraç içine alınmalı ve birbirinden virgülle ayrılmalıdır.

Matris için tam kod B:

Genel sınıf Matrisi ( public static void main(String args) ( int matrixB = ( (-9,1,0), (4,1,1), (-2,2,-1)); for (int i = 0 ben< 3; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixB[i][j] + "\t"); } System.out.println(); } } }

Düşünmek döngü başlatmaörnek olarak çarpım tablosunu kullanan iki boyutlu bir dizi için.

Genel sınıf Mult ( public static void main(String args) ( // 10'a 10'a iki boyutlu bir dizi oluştur int multipleTab = new int; // (int i = 0; i) için ilk boyut boyunca döngü yap< 10; i++) { // цикл по второй размерности for (int j = 0; j < 10; j++) { //инициализация элементов массива multiplyTab[i][j] = (i+1)*(j+1); //вывод элементов массива System.out.print(multiplyTab[i][j] + "\t"); } System.out.println(); } } }

Burada, çarpım tablosunun değerleri ile elemanların başlatılması, bir döngüde konsola çıktıları ile birleştirilir.

Çok boyutlu ve asimetrik diziler.

Java'da çok boyutlu diziler benzer şekilde oluşturulur. Köşeli parantezlerin sayısı boyutu belirtir.
Sabit uzunlukta diziler oluşturma örnekleri:

Int a = yeni int;// iki boyutlu dizi int b = yeni int;// üç boyutlu dizi int c = yeni int;// dört boyutlu dizi // vb.

Ancak, başlangıçta tüm düzeylerde boyutu belirtmek gerekli değildir, boyutu yalnızca ilk düzeyde belirtebilirsiniz.

int a1 = new int;// 5 satırlı iki boyutlu dizi

Bu durumda her satırda kaç eleman olacağı bilinmezken bu daha sonra belirlenebilir ayrıca dizi her satırda farklı sayıda eleman içerebilir, yani asimetrik. a1 dizisi için her satırdaki eleman sayısını belirleyelim.

A1 = yeni int ; a1 = yeni int ; a1 = yeni int ; a1 = yeni int ; a1 = yeni int ;

Sonuç olarak, ekranda görüntülendiğinde,

for(int ben = 0; ben

dizi şöyle görünecek:

0
0 0
0 0 0
0 0 0 0
0 0 0 0 0

Bir dizi oluşturulduğunda, öğeleri otomatik olarak sıfıra başlatılır, bu nedenle bu örnekte sıfırlar görüntülenir.

Java'da çok boyutlu diziler üzerinde alıştırmalar:

1. 5'e 6'lık bir dizi oluşturun ve onu rastgele sayılarla (0 ile 99 arasında değişen) doldurun. Üçüncü satırı konsola yazdır
2. C ve D matrisleri 3'e 3 boyutlarında verilir ve 0'dan 99'a kadar rastgele sayılarla doldurulur. Matrislerin birbirleri üzerinde önce toplamasını, sonra çarpmasını ayrı ayrı gerçekleştirin. Orijinal matrisleri ve hesaplamaların sonucunu konsola çıkarın.
3. İki boyutlu bir dizinin tüm öğelerini toplayın.
4. Negatif ve pozitif sayılar içeren iki boyutlu bir dizi verildi. Negatif sayılar içeren dizi hücrelerinin numaralarını görüntüleyin.
5. Öğeleri artan düzende iki boyutlu dizi satırlarında sıralayın

Son güncelleme: 09.11.2018

Bir dizi, aynı türdeki bir dizi değeri temsil eder. Bir diziyi bildirmek, tek bir değer depolayan sıradan bir değişkeni bildirmek gibidir ve bir diziyi bildirmenin iki yolu vardır:

data_type dizi_adı; // veya data_type dizi_adı;

Örneğin, bir sayı dizisi tanımlayalım:

int sayılar; int sayılar2;

Bir dizi bildirdikten sonra onu başlatabiliriz:

int sayılar; sayılar = yeni int; // 4 sayı dizisi

Şu yapı kullanılarak bir dizi oluşturulur: new data_type[number_of_elements] , burada new, parantez içinde belirtilen sayıda öğe için bellek ayıran bir anahtar sözcüktür. Örneğin, sayılar = yeni int; - bu ifade, dört int öğesinden oluşan bir dizi oluşturur ve her öğenin varsayılan bir değeri olur - 0 sayısı.

Ayrıca, bir diziyi bildirirken hemen başlatabilirsiniz:

int sayılar = yeni int; // 4 sayı dizisi int nums2 = yeni int; // 5 sayı dizisi

Bu başlatma ile tüm dizi öğelerinin varsayılan bir değeri vardır. Sayısal türler için (char türü dahil) bu 0 sayısıdır, boolean türü için bu false ve diğer nesneler için bu null . Örneğin, int türü için varsayılan değer 0 sayısıdır, bu nedenle yukarıda tanımlanan nums dizisi dört sıfırdan oluşacaktır.

Bununla birlikte, bir dizinin oluşturulduğunda öğeleri için belirli değerler ayarlamak da mümkündür:

// bu iki yol eşdeğerdir int nums = new int ( 1, 2, 3, 5 ); int sayılar2 = ( 1, 2, 3, 5 );

Bu durumda, küme parantezindeki öğe sayısı ile hesaplandığından, dizinin boyutunun köşeli parantez içinde gösterilmediğini belirtmekte fayda var.

Bir dizi oluşturduktan sonra, dizi değişkeninin adından sonra köşeli parantez içinde verilen dizine göre herhangi bir elemanına başvurabiliriz:

int sayılar = yeni int; // dizi elemanlarının değerlerini ayarlayın nums = 1; sayılar = 2; sayılar = 4; sayılar = 100; // üçüncü dizi elemanının değerini al System.out.println(nums); // dört

Dizi elemanı indeksleme 0'da başlar, bu durumda dizideki dördüncü elemana atıfta bulunmak için nums ifadesini kullanmamız gerekir.

Ve dizimiz sadece 4 eleman için tanımlandığından, örneğin altıncı elemana başvuramayız: nums = 5; . Bunu yapmaya çalışırsak, bir hata alırız.

Dizi Uzunluğu

Dizilerin sahip olduğu en önemli özellik, dizinin uzunluğunu yani elemanlarının sayısını döndüren length özelliğidir:

int sayılar = (1, 2, 3, 4, 5); int uzunluk = nums uzunluk; // 5

Son dizinin bilinmemesi nadir değildir ve bir dizinin son öğesini almak için bu özelliği kullanabiliriz:

int son = sayılar;

Çok boyutlu diziler

Daha önce, aynı türden bir değer zinciri veya dizisi olarak temsil edilebilecek tek boyutlu dizileri düşündük. Ancak tek boyutlu dizilere ek olarak çok boyutlu diziler de vardır. En iyi bilinen çok boyutlu dizi, iki boyutlu bir diziyi temsil eden bir tablodur:

int sayılar1 = yeni int (0, 1, 2, 3, 4, 5); int nums2 = ( ( 0, 1, 2 ), ( 3, 4, 5 ) );

Görsel olarak, her iki dizi de aşağıdaki gibi temsil edilebilir:

Tek boyutlu dizi nums1

İki boyutlu dizi nums2

nums2 dizisi iki boyutlu olduğu için basit bir tablodur. Ayrıca şu şekilde de oluşturulabilir: int nums2 = new int; . Köşeli parantezlerin sayısı dizinin boyutunu gösterir. Ve parantez içindeki sayılar - satır ve sütun sayısı. Ayrıca, dizinleri kullanarak programda dizi öğelerini kullanabiliriz:

// ikinci satırın ilk sütununun elemanını ayarla nums2=44; System.out.println(nums2);

Üç boyutlu bir dizi bildirimi şöyle görünebilir:

int sayılar3 = yeni int;

pürüzlü dizi

Çok boyutlu diziler aynı zamanda "tırtıklı diziler" olarak da gösterilebilir. Yukarıdaki örnekte, 2B dizide 3 satır ve 3 sütun vardı, bu yüzden düz bir tablo elde ettik. Ancak iki boyutlu bir dizideki her öğeye farklı sayıda öğeye sahip ayrı bir dizi atayabiliriz:

int sayılar = yeni int; sayılar = yeni int; sayılar = yeni int; sayılar = yeni int;

her biri için

For döngüsünün özel bir sürümü, diziler ve koleksiyonlar gibi öğe kümelerindeki öğeleri yinelemek için tasarlanmıştır. Diğer programlama dillerinde bulunan foreach döngüsüne benzer. Resmi beyan:

(veri türü değişken_adı: kapsayıcı) için ( // eylemler )

Örneğin:

int dizi = yeni int (1, 2, 3, 4, 5); for (int i: dizi)( System.out.println(i); )

Bu durumda kapsayıcı, int türünde bir veri dizisidir. Daha sonra int tipinde bir değişken bildirilir.

Aynı şey for'nun normal sürümüyle de yapılabilir:

int dizi = yeni int (1, 2, 3, 4, 5); for (int ben = 0; ben< array.length; i++){ System.out.println(array[i]); }

Aynı zamanda, for döngüsünün bu sürümü for (int i: array) sürümünden daha esnektir. Özellikle, bu sürümde öğeleri değiştirebiliriz:

int dizi = yeni int (1, 2, 3, 4, 5); for (int i=0; ben

Bir döngüde çok boyutlu diziler üzerinde yineleme

int sayılar = yeni int ( (1, 2, 3), (4, 5, 6), (7, 8, 9) ); for (int ben = 0; ben< nums.length; i++){ for(int j=0; j < nums[i].length; j++){ System.out.printf("%d ", nums[i][j]); } System.out.println(); }

İlk olarak, satırlar üzerinde yineleme yapmak için bir döngü oluşturulur ve ardından ilk döngü içinde, belirli bir satırın sütunları üzerinde yineleme yapmak için bir iç döngü oluşturulur. Benzer şekilde, çok sayıda boyuta sahip üç boyutlu diziler ve kümeler üzerinde yineleme yapabilirsiniz.

diziler(diziler) _ aynı türden sıralı eleman kümeleridir. Dizi öğeleri, diğer dizilere yapılan başvurular da dahil olmak üzere, basit ve başvuru türlerinin nesneleri olabilir. Dizilerin kendileri nesnelerdir ve

Object sınıfını devralır. reklam

int ia = yeni int;

Başlangıçta int türündeki üç Öğe kümesine işaret eden ia adlı bir dizi tanımlar.

Bir dizi bildirimi, boyutunu belirtmez. Dizi öğelerinin sayısı, yeni operatör kullanılarak oluşturulduğunda belirtilir. Bir dizinin uzunluğu, oluşturma sırasında sabitlenir ve daha sonra değiştirilemez. Yine de, değişken dizi tipi (bizim örneğimizde - ia) herhangi bir zamanda farklı bir boyuta sahip yeni bir dizi atanabilir.

Dizi elemanlarına indeks numaralarının değerleri ile erişilir.

Bir dizinin ilk elemanının indeksi sıfır (0) ve son elemanın uzunluğu - 1. Bir dizi elemanına, dizi adı ve köşeli parantez [ ve ] içine alınmış indeks değeri belirtilerek erişilir. önceki örnekte, ia dizisinin ilk öğesi ia ve son öğesi ia olacaktır. Bir dizi öğesine dizin tarafından erişildiğinde, Java çalışma zamanı sistemi dizin değerinin sınırlar içinde olup olmadığını kontrol eder ve sonuç yanlışsa bir ArrayIndexOutOfBoundsException atar. 6 Dizin ifadesi int türünde olmalıdır - bu, dizi öğelerinin maksimum sayısı üzerindeki tek sınırdır.

Bir dizinin uzunluğu, bir dizi nesnesinin (örtük olarak genel ve nihai olarak işaretlenen) uzunluk alanı kullanılarak kolayca belirlenir. Aşağıdaki, ia dizisinin her bir öğesinin içeriğinin ekranda görüntülenmesini sağlayan Döngünün yürütülmesini sağlayan önceki örneğin güncellenmiş bir kodudur:

for (int ben = o; ben< ia.length; i++)

system.out.println(i + ": " + ia[i]);

Sıfır uzunlukta bir dizi (yani, içinde hiç öğe olmayan bir dizi) genellikle denir. boş. Boş dizi başvurusu ile boş dizi başvurusunun tamamen farklı şeyler olduğunu unutmayın. Boş bir dizi, hiçbir elemanı olmayan gerçek bir dizidir. Boş bir dizi, bir yöntemden dönerken boş diziye uygun bir alternatiftir. Yöntem null döndürme yeteneğine sahipse, yöntemin çağrıldığı uygulama kodu, geri kalan işlemlere devam etmeden önce döndürülen değeri null ile karşılaştırmalıdır. Yöntem bir dizi döndürürse (muhtemelen boş), ek kontrollere gerek yoktur - elbette, dizinin uzunluğuyla ilgili olanlar dışında ve yine de gerçekleştirilmelidir.

Köşeli parantezlerin türünün adından sonra değil, dizi tanımlayıcısından sonra belirtildiği başka bir dizi bildirimi biçimine de izin verilir:

int ia = yeni int;

Ancak önceki sözdizimi, tür bildirimi daha kompakt olduğu için tercih edilir.

Dizi bildirimlerindeki değiştiriciler

Bildirimlerde belirli dizileri kullanma kuralları değiştiriciler yaygındır ve yalnızca dizinin alanlara mı yoksa Yerel değişkenlere mi ait olduğuna bağlıdır. Hatırlanması gereken önemli bir şey var - değiştiriciler diziye bu şekilde uygulanır, ancak bireysel öğelerine uygulanmaz. Dizi bildirimi son bayrağı içeriyorsa, bu yalnızca diziye yapılan başvurunun oluşturulduktan sonra değiştirilemeyeceği anlamına gelir, ancak dizinin tek tek öğelerinin içeriğinin değiştirilmesi olasılığını hiçbir şekilde yasaklamaz. Dil, dizi öğeleri için herhangi bir değiştirici (örneğin, final veya uolatile) belirtmenize izin vermiyor.

Çok boyutlu diziler

Java, beyan etme yeteneğini destekler çok boyutlu diziler(çok boyutlu diziler) (yani, öğeleri başka diziler olan diziler), iki boyutlu bir matris bildiren ve öğelerinin içeriğini ekranda görüntüleyen kod şöyle görünebilir:

şamandıra matı = yeni şamandıra;

setupMatrix(mat);

for (int y = o; y< mat.length; у++) {

for (int x = o; x< mat[y].length; х++)

system.out.print(mat[y][x] + " ");

system.out.println();

Bir dizi oluştururken, en azından ilk, "en soldaki" boyutu belirtilmelidir. Diğer boyutlar belirtilmemiş olabilir - bu durumda daha sonra belirlenmeleri gerekecektir. Yeni operatörde tüm boyutları bir kerede belirtmek, ek yeni operatörlere gerek kalmadan bir dizi oluşturmanın en kısa yoludur. Yukarıdaki mat dizisi bildirimi ve oluşturma ifadesi, aşağıdaki kod parçacığına eşdeğerdir:

şamandıra matı = yeni şamandıra;

for (int y = o; y< mat.length; у++)

mat[y] = yeni kayan nokta;

Bu bildirim biçimi, belirli veri dizilerini depolamak için gerekli olan farklı boyutlarda dizilerin dizilerini oluşturmak için aynı boyutlara sahip diziler (örneğin 4 x 4) elde etmenin yanı sıra izin verme avantajına sahiptir.

Dizi başlatma

Bir dizi oluşturulduğunda, her öğeye dizi türüne bağlı olarak varsayılan bir değer verilir: sayısal türler için sıfır (0), char için '\u0000' _, boolean için false ve başvuru türleri için null. Referans türünde bir dizi bildirerek, aslında bir dizi tanımlıyoruz. hamile bu türden. Aşağıdaki kod parçacığını göz önünde bulundurun:

Attr attrs = yeni Attr;

for (int ben = o; ben< attrs.length; i++)

attrs[i] = new Attr(isimler[i], değerler[i]);

Yeni operatörü içeren ilk ifade yürütüldükten sonra, attrs değişkeni, null olarak başlatılan 12 değişkenlik bir diziye referansa sahip olacaktır.Bu tür Attr nesneleri yalnızca döngü sırasında oluşturulacaktır.

Bir dizi, öğelerinin ilk Değerlerini listeleyen küme parantezleri içindeki bir yapı aracılığıyla (bildirim ile eşzamanlı olarak) başlatılabilir:

Dize tehlikeleri = ("Aslanlar", "Kaplanlar", "Ayılar");

Aşağıdaki kod parçası aynı sonucu verecektir:

String tehlikeleri = new String; tehlikeler = "Aslanlar";

tehlikeler = "Kaplanlar";

tehlikeler = "Ayılar";

Kıvrımlı parantezler içinde bir başlatıcı listesi belirtmeyi içeren ilk biçim, new operatörünün açık kullanımını gerektirmez - çalışma zamanı sistemi tarafından dolaylı olarak çağrılır. Bu durumda dizinin uzunluğu, Başlatıcı değerlerinin sayısı ile belirlenir. Yeni operatörü açıkça ayarlamak da mümkündür, ancak boyut yine de atlanmalıdır; daha önce olduğu gibi, yürütme sistemi tarafından belirlenir:

String tehlikeleri = new String ("Aslanlar", "Kaplanlar", "Ayılar");

Bu dizi bildirimi ve başlatma biçimi, örneğin bir yöntem çağrısı ifadesinde, kodun herhangi bir yerinde kullanılabilir:

printStringsCnew String("bir", "iki", "üç"));

Bu şekilde oluşturulan isimsiz bir diziye denir. anonim(anonim).

Dizi dizileri, iç içe geçmiş başlangıç ​​değerleri dizileriyle başlatılabilir. Aşağıdaki, sözde dizinin ilk birkaç satırını içeren bir dizi bildirmenin bir örneğidir. Pascal üçgeni burada her satır kendi değer dizisiyle tanımlanır.

int pascalsÜçgen = (

{ 1, 4, 6, 4, 1 },

Çok boyutlu dizi indeksleri dıştan içe doğru sıralanmıştır. Örneğin pascalsTriangle[n];
Harika. Şimdi sizden dizinin öğelerini bir şeyle başlatmanızı istiyoruz. Birimler olsa da, endekslerin toplamı olsa da. Alırız:
for(int ben = 0; ben< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } }
Daha sık yazıyorlar
for(int ben = 0; ben< g.length; i++) { for(int j = 0; j < g[i].length; j++) { g[i][j] = i + j; } }
bu da sohbet için bir fırsat, ama şimdi başka bir şeyden bahsediyoruz. Bir kişinin ne bildiğini ve nasıl düşündüğünü bulmaya çalışıyoruz. Bu nedenle, değerlerin simetrik olarak düzenlendiği gerçeğine dikkat çekiyor ve ondan döngülerin yinelemelerinden tasarruf etmesini istiyoruz. Tabii ki, sadece alt üçgenden geçebilecekken neden tüm indeks değerlerini geçesiniz? Konu genellikle kolayca kabul eder ve ana köşegeni akıllıca vurgulayarak aşağıdaki satırlar boyunca özenle bir şeyler yazar:
for(int ben = 0; ben< n; i++) { g[i][i] = 2* i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } }
g[i][i] = 2* yerine i; genellikle g[i][i] = i + i yazın; veya g[i][i] = ben<< 1; и это тоже повод поговорить. Но мы идем дальше и задаем ключевой вопрос: Program ne kadar hızlı çalışacak?. Genel mantık şu şekildedir: neredeyse 2 kat daha az endeks hesaplaması; değerlerin hesaplanmasından neredeyse 2 kat daha az (toplam); aynı sayıda atama. Yüzde 30 daha hızlı demektir.Bir kişinin arkasında iyi bir matematik okulu varsa, o zaman kaydedilen işlemlerin tam sayısını ve optimizasyon verimliliğinin daha mantıklı bir değerlendirmesini bile görebilirsiniz.
Şimdi ana saldırı zamanı. Kodun her iki sürümünü de yeterince büyük bir değerde çalıştırıyoruz n(birkaç bin mertebesinde), örneğin, bunun gibi.

Zaman kontrollü kod

A sınıfı ( public static void main(String args) ( int n = 8000; int g = yeni int[n][n]; uzun st, en; // bir st = System.nanoTime(); for(int i = 0 ben< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nOne time " + (en - st)/1000000.d + " msc"); // two st = System.nanoTime(); for(int i = 0; i < n; i++) { g[i][i] = i + i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nTwo time " + (en - st)/1000000.d + " msc"); } }

Ne görüyoruz? Optimize edilmiş sürüm 10-100 kat daha yavaş çalışır! Şimdi pozisyon için başvuranın tepkisini gözlemleme zamanı. Alışılmadık (veya geliştiricinin uygulamasında oldukça yaygın) stresli bir duruma tepki ne olacak. Müşterinin yüzünde heyecan belirdiyse ve düğmelere basmaya başladıysa, varlığınızı geçici olarak unutursa, bu iyi bir işarettir. Bir ölçüde. Projenin sonucunu umursamayan bir araştırmacıyı işe almak istemezsiniz, değil mi? O zaman ona "Neden?" Sorusunu sormayın. İkinci seçeneği yeniden oluşturmayı isteyin, böylece ilkinden daha hızlı çalışır.
Artık bir süreliğine güvenle işinize devam edebilirsiniz. Yarım saat içinde, başvuranın temel kişisel ve mesleki niteliklerini değerlendirmek için yeterli materyale sahip olacaksınız.
Bu arada, çalışma sitemde bu sorunu kısaca anlattığımda en popüler yorum "Bu senin Java eğrin." oldu. Özellikle onlar için kodu Great and Free olarak yayınlıyorum. Ve Windows için Free Pascal'ın mutlu sahipleri bakabilir

spoiler altında

program Zamanı; Windows'u kullanır; var start, bitiş, res: int64; n, i, j: Tamsayı; g: Tamsayı Dizisi Dizisi; başlangıç:= 10000; SetLength(g, n, n); QueryPerformanceFrequency(res); QueryPerformanceCounter(başlangıç); i:=1 ila n-1 için j:=1 ila n-1 için do g := i + j; QueryPerformanceCounter(bitiş); writeln("Satırlara göre süre:", (bitiş - başlangıç) / res, "sn"); QueryPerformanceCounter(başlangıç); i:=1 ila n-1 için j:=1 ila n-1 için do g := i + j; QueryPerformanceCounter(bitiş); writeln("Sütunlara göre süre:", (bitiş - başlangıç) / res, "sn"); son.

Pascal'daki yukarıdaki kodda "kafa karıştırıcı" anları kaldırdım ve sadece sorunun özünü bıraktım. Eğer sorun olarak adlandırılabilirse.
Davalıya hangi soruları soracağız?
1. Neden yavaşladı? Ve daha detaylı...
2. Başlatma nasıl daha hızlı yapılır?

Java uygulamasının daha derinine inmeye ihtiyaç varsa, başvuru sahibinden küçük değerler için yürütme süresini gözlemlemesini isteriz. n. Örneğin, ideone.com'da n=117 için "optimize edilmiş" sürüm iki kat daha yavaştır. Ancak bir sonraki değer n=118 için, optimize edilmemiş olandan 100 (yüz) kat daha hızlı olduğu ortaya çıktı! Yerel bir makinede deneme yapmayı önerin. Ayarlarla oynamasına izin verin.
Bu arada, neler olduğunu anlıyor musun?

Birkaç haklı söz

İşe alırken bu görüşme yönteminin gerekçesi olarak birkaç söz söylemek istiyorum. Evet, dilin sözdizimi bilgisini ve veri yapılarının bilgisini test etmiyorum. Belki de medeni bir işgücü piyasasında bunların hepsi işe yarar. Ancak kalifiye eleman sıkıntısının olduğu bizim koşullarımızda, başvuranın karşılaşacağı iş için ileriye dönük yeterliliğini değerlendirmek gerekir. Şunlar. öğrenme, üstesinden gelme, anlama, yapma yeteneği.
Özünde bu, eski Roma'da lejyonerleri işe alırken yapılan "röportaj"a benzer. Geleceğin savaşçısı çok korktu ve kızarıp kızarmadığını izledi. Soluklaşırsa, stresli bir durumda başvuranın kanı başından çekilir ve pasif bir reaksiyona eğilimlidir. Örneğin, bayılma. Başvuran kızarırsa, kan kafasına hücum eder. Şunlar. aktif eylemlere, kavgaya koşmaya eğilimlidir. Bu uygun görüldü.
Sonuncusu. Röportajlarda kullanmaya devam etmek yerine neden herkese bu sorunu anlattım? Basitçe, potansiyel adaylar bu görevi zaten “öğrendiler” ve diğerleri bunu kullanmak zorunda.
Aslında bu etkiye tam olarak görüntü işlemenin gerçek görevi ile bağlantılı olarak dikkat ettim. Durum biraz kafa karıştırıcıydı ve yeniden düzenlemeden sonra fps'min neden bu kadar düştüğünü hemen anlamadım. Genel olarak, herkesin muhtemelen böyle harika anları vardır.

Şimdiye kadar, önde gelen sürüm, işlemci önbelleğinin “suçlu” olmasıdır. Şunlar. İlk varyanttaki sıralı erişim, belirli bir sınırı geçerken güncellenen karma içinde çalışır. Sütunlarla erişirken, hash'in sürekli güncellenmesi gerekir ve bu uzun zaman alır. Bu sürümü en saf haliyle test edelim. Bir dizi başlatalım ve daha hızlı olanı karşılaştıralım - bir satırdaki tüm öğeleri işlemek mi yoksa dizi öğelerini aynı sayıda rastgele bir sayıyla işlemek mi? İşte program - ideone.com/tMaR2S. 100.000 dizi öğesi için rastgele erişim genellikle belirgin şekilde daha hızlıdır. Ne anlama geliyor?
Burada oldukça haklı olarak (Big_Lebowski) döngüleri yeniden düzenlemenin sonuçları sıralı bir seçenek lehine değiştirdiğine dikkat çektim. Deneyin saflığı için ısınma için bir döngü koymak zorunda kaldım. Aynı zamanda leventov'un tavsiye ettiği şekilde ortalama çalışma süresini göstermek için birkaç tekrar yaptım. Bu ideone.com/yN1H4g gibi çıktı. Şunlar. büyük bir dizinin öğelerine rastgele erişim, sıralı erişimden ~%10 daha yavaştır. Belki önbellek aslında bir rol oynayabilir. Ancak, ilk durumda, performans zaman zaman düştü. Yani başka bir şey var.

Yavaş yavaş, dizinin bir satırından diğerine geçerken ek eylemlerle ilgili sürüm lider oluyor. Ve doğru. Orada tam olarak ne olduğunu anlamaya devam ediyor.

Etiketler:

• Programlama
• diziler
• hafıza

Etiket ekle