Diziler sınıfı, bölüm 2

"Rishi, Arrays sınıfının geri kalan yöntemlerini öğrenmeyi gerçekten dört gözle bekliyorum.

"Böyle bir öğrenme hevesi, eski öğretmeninizi memnun etmekten başka bir şey yapamaz! Ancak, gerçekten her şeyi öğrenmek istiyorsanız, Google adlı nazik bir sihirbaz size gece gündüz yardımcı olacaktır."

"Şey..."

Arrays.fill"Şaka yapıyorum. Biraz. Tabii ki, her şeyi daha iyi açıklayacağım, ama aklına bir şey gelirse - iyi büyücüyü hatırla. Bugünün dersine yöntemle başlayacağım.

"Dizilerle çalışırken, Java programcılarının genellikle diziyi aynı değerle doldurması gerekir. Elbette bir döngü yazabilir ve döngüdeki dizinin her hücresine bir miktar değer atayabilirsiniz:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"Ya da tüm bunların yerine, tam olarak aynı şeyi yapan yöntemi çağırabilirsiniz Arrays.fill(): iletilen diziyi iletilen değerle doldurur. İşte nasıl göründüğü:

Arrays.fill(name, value)

Ve yukarıdaki örnekteki kod biraz daha derli toplu ve anlaşılır hale getirilebilir:

int[] x = new int[100];
Arrays.fill(x, 999);

"Güzel!"

Arrays.fill()" Metodu, dizinin tamamını değil, bir kısmını bir değerle doldurmak için de kullanabilirsiniz :

Arrays.fill(name, first, last, value)

" İlk ve son, doldurulacak ilk ve son hücrelerin dizinleridir.

" Java'nın iyi (veya kötü) eski geleneğine uygun olarak, son öğenin aralığa dahil olmadığını unutmayın.

Örnek:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

" Arrays.fill()Yöntem yalnızca tek boyutlu dizilerle çalışır. Yönteme iki boyutlu bir dizi iletirseniz, sonraki tüm sonuçlarla birlikte tek boyutlu olarak ele alınacaktır.

Arrays.copyOf()

"Amigo, lütfen bana bir dizinin boyutunu oluşturduktan sonra nasıl değiştireceğimi söyle?"

"Hımm... Bu hileli bir soru, değil mi? Artık o kadar deneyimsiz değilim. Doğru cevap, yapamazsınız! Bir diziyi oluşturulduktan sonra yeniden boyutlandıramazsınız."

"Ama ya gerçekten istersen?"

"Hala imkansız!

"Aslında, gerçekten istiyorsan, yapabilirsin! Bir programlama numarası yardımıyla:

1. İlk olarak, istediğiniz uzunlukta yeni bir dizi oluşturursunuz.
2. Ardından, ilk dizideki tüm öğeleri ona kopyalarsınız.

"Metodun yaptığı iki şey bunlar Arrays.copyOf(). Onu çağırmak şöyle görünüyor:

Type[] name2 = Arrays.copyOf(name, length);

"Bu yöntem mevcut diziyi değiştirmez , bunun yerine yeni bir dizi oluşturur ve eski dizinin öğelerini buna kopyalar."

"Ya yeni dizinin uzunluğu mevcut olanın uzunluğundan azsa ?

"Harika soru, Amigo! Öğeler uymuyorsa, ekstra değerler basitçe göz ardı edilir."

"Aksine, fazladan hücreler varsa, bunların başlangıç ​​değerleri nedir?

"Yeni dizinin uzunluğu eskisinin uzunluğundan büyükse, hücreler sıfırlarla doldurulur.

Örnek:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

"Peki ya 10 uzunluğundaki bir diziden 5 uzunluğunda bir dizi elde etmek istiyorsanız, ancak bunun ilk 5 yerine son 5 öğeyi içermesine ihtiyacınız varsa? Bu durumda, sınıfın başka bir yöntemine ihtiyacınız var Arrays. Arrays.copyOfRange(). Arama şöyle görünür:

Type[] name2 = Arrays.copyOfRange(name, first, last);

"Bu yöntem ayrıca yeni bir dizi oluşturur, ancak onu orijinal dizideki rasgele bir yerden öğelerle doldurur. İlk ve son , yeni diziye yerleştirilmesi gereken ilk ve son öğelerin dizinleridir. Bana söyleyebilir misiniz? son eleman bu aralığa dahil mi?"

"Ha! Büyük hocamın dediği gibi ' Java'nın iyi (ya da kötü) eski geleneğine göre, son öğenin aralığa dahil olmadığını unutmayın '."

"Amigo, gözümüzün önünde büyüyorsun.

Örnek:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

"Ve son olarak, en... mmm... hoş yöntemi sona bıraktım: sıralama . Diziler programlamada oldukça sık sıralanır. İşte dizilerle çalışırken en popüler 3 eylem:

• Bir diziyi sıralama
• Bir dizinin minimum (veya maksimum) öğesini bulma
• Bir dizideki bir öğenin indeksini belirleme (bir dizideki bir öğeyi bulma)

"İyi performans gösteren sıralama algoritmalarını yazmanın o kadar kolay olmadığını söylemeliyim. Daha doğrusu, bu standart bir görevdir ve bir öğrenci olarak, bazen sıralama algoritmaları yazma pratiği yapmanız size zarar vermez. Ama işte, Tekerleği yeniden icat ederek zamanınızı boşa harcamamak daha iyidir. Java'nın yaratıcıları yöntemi sort()sınıfa dahil ettiler Arrays. Onu çağırmak şöyle görünüyor:

Arrays.sort(name);

Bu yöntem, geçirilen diziyi artan düzende sıralar.

Örnek:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

"Mükemmel! Yalnızca bir yöntem çağırdım ve dizi sıralandı. Harika bir şey!"

"Bu arada, sadece tüm diziyi değil, sadece bir kısmını da sıralayabilirsiniz. Onu çağırmak şöyle görünür:

Arrays.sort(name, first, last);

" İlk ve son, sıralamanın dokunması gereken ilk ve son hücrelerin dizinleridir. VE...

"Ne söyleyeceğinizi zaten biliyorum! 'Java'nın iyi (ya da kötü) eski geleneğine uygun olarak, son öğenin aralığa dahil olmadığını unutmayın' .

Örnek:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"Java dizileri sıralamak için en hızlı sıralama algoritmasını kullanır - QuickSort . Hesaplama karmaşıklığı dizinin boyutuna bağlıdır ve N log(N) formülü kullanılarak hesaplanır.

"1000 öğelik bir diziyi sıralamak, dizi öğelerinin yaklaşık 10.000 karşılaştırmasını içerecektir. Bir milyon öğelik bir diziyi sıralamak, yaklaşık 20 milyon karşılaştırmayı içerecektir."

" Öğe sayısını düşündüğünüzde çok fazla karşılaştırma yok!"

"Ben de tam olarak bunu söylüyorum. QuickSort algoritması çok verimli.

Arrays.binarySearch()

"Pekala, sınıfın en ilginç yöntemlerinden sonuncusu, Arraysbir dizide belirli bir değeri arayabiliyor. Bu sıradan bir arama değil - bu, sevilen ikili arama . Özetle şu:

• İlk olarak, dizi sıralanır.
• Ardından dizinin ortadaki elemanı aradığımız elemanla karşılaştırılır.
• Eleman ortadaki elemandan büyükse, arama dizinin sağ yarısında devam eder.
• Aradığımız eleman ortadaki elemandan küçükse aramaya dizinin sol yarısında devam edilir.

"Dizi sıralandığı için, tek bir karşılaştırmada yarısını elemek mümkün. Sonra bir sonraki adımda diğer yarısını atıyoruz ve bu böyle devam ediyor."

"Harika! Çok hızlı bir şekilde doğrudan hedefe gidiyoruz!"

"Kesinlikle. Bir milyon (!) öğelik bir dizide, ikili arama algoritması, istenen öğenin dizinini yalnızca 20 karşılaştırmada bulabilir. Algoritmanın eksikliği, önce dizinin sıralanması gerektiği ve sıralamanın da zaman almasıdır.

Çağrı şu şekilde görünüyor:

int index = Arrays.binarySearch(name, value);

" nameÖnceden sıralanmış olarak iletilmesi gereken dizinin adı nerede (örneğin, yöntem kullanılarak Arrays.sort()). Ve valuedizide aradığımız öğedir. Yöntem tarafından döndürülen sonuç, istenen dizi öğesinin indeksidir. .

Örnekler:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

"İstenen öğe dizide birden çok kez görünürse ne olur ?"

"Bu geçerli bir soru, Amigo. Bu durumda, algoritma bunlardan birinin dizinini döndürür (bu yinelenen öğelerin ilkinin veya tam tersinin - en sonuncusu olacağının garantisi yoktur) ."

"Ya dizi istenen öğeyi hiç içermiyorsa?"

"Bu durumda, algoritma negatif bir dizin döndürür .

Belgeler

"Her şey açık Rishi! Bu çok ilginçti."

"Bunu gerçekten çok ilginç bulduysanız, boş zamanlarınızda Oracle web sitesindeArrays sınıfın resmi belgelerine ve yöntemlerine göz atın .

Arrays.mismatch()"Örneğin, ve yöntemlerine daha yakından bakabilirsiniz Arrays.compare(). Büyük olasılıkla onları iyi bir şekilde kullanabileceksiniz.

"Yöntemlerin sayısı sizi yanıltmasın. Her yöntemin yalnızca parametre türlerinde farklılık gösteren 5-10 değişkeni vardır."