Java Haritası arabirimi, Java Collection çerçevesinin bir parçasıdır, ancak Collection arabiriminin bir alt türü değildir. Bu nedenle, örneğin Listelere veya diğer koleksiyon Nesnelerine kıyasla farklı bir şekilde davranır. Map<Key, Value> öğesinin her öğesi bir anahtar/değer çiftini temsil eder. Hem Anahtar hem de değer bazı nesnelerdir. Belirli bir haritadaki tüm anahtarlar benzersizdir, ancak değerler değildir, dolayısıyla kopyalanabilirler. Java'da Harita'yı, benzersiz dizinini kullanarak herhangi bir öğeyi bulabileceğiniz bir tür sözlük veya çevrimiçi mağaza kataloğu gibi düşünebilirsiniz. Anahtar, bir Haritadaki değerin benzersiz tanımlayıcısıdır. Örneğin, Map<String'de Item> String, çevrimiçi mağazadaki bazı Öğelerin kimliğidir. Belgelere göre Harita aşağıdaki Alt Arayüzlere sahiptir:
bağlamalar ;
ConcurrentMap<K,V> ;
ConcurrentNavigableMap<K,V> ;
LogicalMessageContext ;
Mesaj Bağlamı ;
NavigableMap<K,V> ;
SOAPMessageContext ;
SortedMap<K,V> .
Ve Sınıfları Uygular:
SoyutHarita
Öznitellikler
Yetki Sağlayıcı
EşzamanlıHashMap
EşzamanlıAtlama Listesi Haritası
EnumMap
HashMap
hash tablosu
KimlikKarma Haritası
LinkedHashMap
YazıcıDurumuNedenleri
Özellikler
Sağlayıcı
İşleme İpuçları
Basit Bağlamalar
TabularVeri Desteği
Ağaç Haritası
UIDefaults
ZayıfHash Haritası
Java AbstractMap, Harita arayüzünün çoğunu uygulayan soyut bir sınıftır.
Java HashMap, bir karma tablo kullanarak anahtar-değer çiftlerini depolamak için bir veri yapısıdır.
Java TreeMap, ağaç kullanmak, yani sıralanmış tuşlarla görüntülemek için kullanılan bir veri yapısıdır.
Zayıf anahtarlara sahip bir karma tablo kullanmak için WeakHashMap , artık kullanılmadıkları takdirde çöp toplayıcı tarafından silinebilecek değerlerle görüntüleyin.
LinkedHashMap , öğe ekleme sırasına sahip bir haritadır, ekleme sırasında yinelemeye izin verir.
EnumMap, AbstractMap sınıfını numaralandırma anahtarlarıyla kullanım için genişletir .
IdentityHashMap , belgeleri karşılaştırırken, equals() yöntemi yerine
== işlemi kullanılarak karşılaştırılan anahtarlarla eşleme yaparken referans eşdeğerlik denetimini kullanır
Burada, Harita Arayüzünün en popüler uygulamalarıyla ilgileniyoruz: HashMap, TreeMap ve LinkedHashMap. Bu arada, harita öğelerinin sırası belirli uygulamalara bağlıdır. Diyelim ki, TreeMap ve LinkedHashMap, öğelerin öngörülebilir sırasına sahipken HashMap'de yok.
Harita yöntemleri
Herhangi bir Haritanın ana işlemleri, öğelerin eklenmesi, kaldırılması ve aranmasıdır.
public Object put(Object key, Object value) haritaya bir öğe ekler.
public void putAll(Harita haritası), belirtilen haritayı haritanın içine ekler.
public Object remove(Object key) belirtilen anahtara göre bir girişi siler.
public Object get(Object key), belirtilen anahtarın değerini döndürür.
public boolean includeKey(Object key) belirtilen anahtarı bu haritadan arar
public Set keySet(), tüm anahtarları içeren bir Set görünümü döndürür
public Set entrySet(), tüm anahtarları ve değerleri içeren bir Set görünümü döndürür.
HashMap nedir?
HashMap nedir? Map<Key,Value> arayüzünün en popüler uygulamasıdır. Bu veri yapısı, karma ilkesine dayanmaktadır.
HashMap çalışmasının ana prensibi: karma
Hashmap nedir ve nasıl çalışır anlamak için önce hashing ve hash fonksiyonlarından bahsedelim. Bir hash işlevi, matematiksel anlamda yalnızca bir işlevdir. Yani bir girdi değeri vardır (bir nesne, bir veri parçası) ve işlev bunu uygun bir kural kullanarak çıktı değerine - bir hash'e dönüştürür. Genellikle hash, uygun uzunlukta onaltılık bir sayıdır. Dönüştürme işlemlerinin kuralları farklı olabilir, ancak bunlar aşağıdaki ilkelere tabidir:
Belirli bir girdi (nesne) belirli bir hash koduna sahiptir.
İki nesne eşitse, hash kodları da eşittir. Tersi doğru değil.
Hash kodları farklı ise, nesneler kesinlikle eşit değildir.
Bazen farklı nesneler aynı hash koduna sahip olabilir. Bu, "çarpışma" olarak adlandırılan çok olası olmayan bir olaydır ve kaliteli bir hash işlevi, çarpışma olasılığını en aza indirmelidir.
Java'da her nesnenin bir karma kodu vardır. Tüm Java Nesnelerinin ana sınıfı olan Object sınıfının hashCode yöntemiyle hesaplanır. Genellikle, geliştiriciler bu yöntemi kendi sınıfları ve bununla ilişkili eşittir yöntemleri için geçersiz kılar.
HashMap: nasıl çalışır?
Bu nedenle, her Harita uygulaması anahtarlardan ve değerlerden oluştuğu için HashMap<K,V> sınıfı. Karma ilkelerini kullanarak anahtarları saklar. HashMap Anahtar-değer çiftleri "paketlerde" saklanır, bu kovalar birlikte bir "tablo", bağlantılı listelerden oluşan dahili bir dizi oluşturur ve başlangıç boyutu 16'dır .. Java'daki HashMap, anahtar/değer çiftinin eşlenmesi gereken yeri belirlemek için anahtarın hash kodunu kullanır: HashMap'in aldatıcı özelliği, [] tablosundaki her hücrenin (kova) yalnızca bir çifti değil birkaç çifti tutmasıdır. Açık bir nesne (LinkedList gibi) olarak değil, örtük bir zincir olarak depolanırlar. Zincir, her çiftin bir sonraki çifte bir bağlantı depolaması nedeniyle oluşturulur. Yani, tüm HashMap çiftleri 16 zincire dağılmıştır. Tabloya yeni bir çift eklediğinizde, anahtarın hash'i dikkate alınır. Bu karma, anahtar nesneye yerleşik bir karma kodu işlevi değildir. 0-15 aralığında olduğu kabul edilir. Çift, hash indeksi ile kovada depolanan çiftler zincirine eklenir. Bu yaklaşım bize arama ivmesini verir. Anahtara göre bir çift ararken, tüm tabloyu gözden geçirmeye gerek yoktur. Anahtarın hash değeri dikkate alınır ve sadece hash indeksi ile hücrede depolanan zincir kontrol edilir. HashMap'te çok fazla çift varsa, zincirler çok uzar. Ardından dizinin boyutu artar, saklanan tüm nesnelerin hash'i yeniden hesaplanır ve bunlar yeni zincirler boyunca dağılır.
HashMap Bildirimi
HashMap kodu sınıfına giderseniz, bir sonraki bildirimi bulacaksınız:
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
K, bu harita tarafından sağlanan anahtarların türü ve V - eşlenen değerlerin türü . Bu, kodunuzdaki Tamsayı anahtarı ve Dize değeri ile HashMap bildiriminin bir örneğidir:
HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();
boolean isEmpty(), harita boşsa doğru, boş değilse yanlış döndürür;
Set keySet(), haritadan getirilen anahtarların Setini döndürür;
int size(), anahtar/değer eşleme miktarını döndürür;
Koleksiyon değerleri(), haritanın değerlerinin bir koleksiyonunu döndürür;
Object remove(Object key), belirtilen anahtar için anahtar-değer çiftini kaldırır;
void putAll(Map m), haritanın tüm öğelerini diğer haritaya kopyalar.
Java HashMap Örneği
Nasıl çalıştığını göstermek için Java HashMap Örneği ile bir program oluşturalım:
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
public class HashMap {
public static void main(String[] args) {
{
// HashMap declaration
HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();
//Adding elements into HashMap
myHashMap.put(7, "Johnny");
myHashMap.put(8, "Ivy");
myHashMap.put(1, "Rick");
myHashMap.put(4, "Stan");
myHashMap.put(3, "Kyle");
//print out the map content using Iterator
Set set = myHashMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry mapEntry = (Map.Entry) iterator.next();
System.out.print("key: " + mapEntry.getKey() + " value: ");
System.out.println(mapEntry.getValue());
}
System.out.println("get an element from myHashMap via key and print the value out:");
System.out.println(myHashMap.get(8));
//print out hashMap on standard way:
System.out.println(myHashMap);
// Get values based on key
String var = myHashMap.get(2);
//here we'll get null, we don't have such a key
System.out.println("Value with key 2: " + var);
var = myHashMap.get(7);
System.out.println("Value with key 7: " + var);
// Remove values based on key
myHashMap.remove(4);
System.out.println("myHashMap after removing element:");
System.out.println(myHashMap);
myHashMap.clear();
System.out.println("myHashMap after total clearing:");
System.out.println(myHashMap);
}
}
}
Programı çalıştırmanın sonucu:
key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}
Ağaç Haritası
Java'daki TreeMap ayrıca Map<Key,Value> arayüzünü uygular, ancak Red-Black ağaç veri yapısını temel alır. Bir Ağaç "düğümler" ve düğümleri - dalları birbirine bağlayan çizgilerden oluşur. "Kök" düğümü ağacın tepesindedir. Kökten dallar ve düğümler olabilir. Hiyerarşik bir yapıdır, aklınıza gelebilir. bu düğümler kökün "çocukları" olarak bulunur. Alt düğümün kendi çocukları olabilir - alt düğümler. Çocuksuz düğümler "son düğümler" veya "yapraklar" olarak adlandırılır. İkili ağaç, her düğümün sıfır, bir olduğu bir ağaçtır. İkili arama ağacı, her dahili düğümün bir anahtarı ve bazen ilişkili bir değeri depoladığı ve iki ayırt edici alt ağacın ("sol" ve "sağ") bulunduğu bir yapıdır. Kendi kendini dengeleyen bir ikili arama ağacı, gelişigüzel öğe ekleme ve silme işlemleri karşısında yüksekliğini (kökün altındaki maksimum düzey sayısı) otomatik olarak küçük tutan, düğüm tabanlı bir ikili arama ağacıdır. Kırmızı-siyah ağaç, aşağıdaki özelliklere sahip dengeli bir ikili ağaçtır:
Her düğüm ya kırmızıdır ya da siyahtır
Kök her zaman siyahtır
Her yaprak bir NIL (bir tür boş, boş) düğümdür ve siyahtır
Bir düğüm kırmızıysa, çocukları kesinlikle siyahtır.
Bir düğümden alt yaprağa giden her basit yol, aynı sayıda siyah düğüm içerir.
Bir TreeMap özellikleri
Bir TreeMap, anahtarları düğümler olarak depolamak için bir ağaç veri yapısı kullanır ve Kırmızı-Siyah Ağaç algoritmasını kullanarak anahtarları sıralar. Böylece, TreeMap girişlerini anahtarlarının doğal sıralamasına göre sıralar. Doğal sayılar için artan sıra, dizeler için - alfabetik sıra. Sıralama mantığını değiştirmeniz gerekirse bir karşılaştırıcı kullanabilirsiniz. Nesneleri doğal bir şekilde sıralamak, bazı nesneleri farklı filtreler ve koşullar kullanarak bulmak kadar TreeMap'in büyük bir avantajıdır.
Ağaç Haritası yöntemleri
Object get(Object key) karşılık gelen anahtarın değerini döndürür;
Object put(Object key, Object value) bir haritaya bir eşleme ekler;
Object remove(Object key), TreeMap içeriyorsa, bu anahtarın eşlemesini kaldırır;
boolean includeKey(Object key), bu harita belirtilen anahtar için bir eşleme içeriyorsa true değerini döndürür;
boolean includeValue(Object value), TreeMap bir veya daha fazla anahtarı belirtilen değere eşlerse true değerini döndürür;
Object firstKey(), şu anda sıralanmış haritada bulunan ilk anahtarı döndürür;
Object lastKey(), şu anda sıralanan haritadaki son anahtarı döndürür;
void putAll(Harita haritası), belirtilen haritadaki tüm eşlemeleri haritaya kopyalar;
Set entrySet(), eşlemelerin ayarlanmış bir görünümünü döndürür
int size(), anahtar/değer eşlemelerinin miktarını döndürür
Koleksiyon değerleri (), değerlerin bir koleksiyon görünümünü döndürür
Object clone(), TreeMap'in sığ bir kopyasını döndürür
void clear(), TreeMap'ten tüm eşlemeleri kaldırır
SortedMap headMap(Object key_value), haritanın key_value parametresinden daha az olan bölümünün bir görünümünü döndürür
Set keySet(), ağaç haritasında bulunan anahtarların Set görünümünü döndürür
SortedMap subMap(K fromKey, K toKey), anahtarları fromKey (dahil) ile toKey (exclusive) arasında değişen bu haritanın bölümünün bir görünümünü döndürür
Object firstKey(), TreeMap'ten ilk anahtarı döndürür.
Ağaç Haritası örneği
import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class TreeMapExample {
public static void main(String args[]) {
//TreeMap declaration
TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();
//put elements to TreeMap
myTreeMap.put(1, "Stuart");
myTreeMap.put(23, "Michael");
myTreeMap.put(7, "Johnny");
myTreeMap.put(5, "Ivy");
myTreeMap.put(2, "Alex");
//Display and print out myTreeMap using Iterator
Set set = myTreeMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry myEntry = (Map.Entry) iterator.next();
System.out.print("key: " + myEntry.getKey() + " value: ");
System.out.println(myEntry.getValue());
}
//TreeMap printed in classical way
System.out.println(myTreeMap);
//removing an element with the key =2
myTreeMap.remove(2);
//myTreeMap after removing:
System.out.println(myTreeMap);
}
}
Programı çalıştırmanın sonucu:
key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}
LinkedHashMap
LinkedHashMap, bağlantılı listeleri ve karma haritaları birleştiren bir veri yapısıdır. Aslında LinkedHashMap, HashMap sınıfını genişletir ve Harita arayüzünü uygular, ancak bağlantılı listelerle ilgili ne var? LinkedHashMap bildirimi:
Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();
Bu yeni linkedHashMap, HashMap'ten özellikleri (tablo, loadFactor, eşik, boyut, entrySet gibi) devralır ve ayrıca iki özel özellik alır:
başlık, çift bağlantılı bir listenin başıdır. Başlatma sırasında kendini gösterir
accessOrder, yineleyici kullanılarak öğelere nasıl erişileceğini belirtir. Doğruysa, son erişim sırasına göre. false ise, erişim öğelerin eklendiği sırada olacaktır.
Bu bağlantılı liste yineleme sıralamasını tanımlar. Genellikle, haritaya anahtar yerleştirme sırasıdır.
LinkedHashMap Yöntemleri
Object get(Object key), belirtilen anahtarın eşlendiği değeri veya bu eşleme anahtar için eşleme içermiyorsa null değerini döndürür
void clear(), haritadaki tüm eşlemeleri kaldırır.
boolean includeKey(Object key), belirtilen öğe bir veya daha fazla anahtarla eşleniyorsa true değerini döndürür
boolean removeEldestEntry(Map.Entry eldest), harita en eski girişini haritadan kaldırırsa true değerini döndürür
Set<Map.Entry<K,V>> entrySet(), bu haritada yer alan eşlemelerin Set görünümünü döndürür
void forEach(BiConsumer<? super K,? super V> action), tüm girişler işlenene veya eylem bir istisna oluşturana kadar bu haritadaki her giriş için verilen eylemi gerçekleştirir.
Object getOrDefault(Object key, V defaultValue), belirtilen anahtarın eşlendiği değeri döndürür. Harita, anahtar için bir eşleme içermiyorsa, defaultValue değerini döndürür.
Set<K> keySet(), haritada bulunan anahtarların Set görünümünü döndürür
boolean removeEldestEntry(Map.Entry<K,V> eldest), bu haritanın en eski girişini kaldırması gerekiyorsa true değerini döndürür
void replaceAll(BiFunction<? super K,? super V,? extensions V> function), her giriş değerini, tüm girişler işlenene veya işlev bir istisna oluşturana kadar o girişte verilen işlevi çağırmanın sonucuyla değiştirir.
Collection<v>values(), haritada bulunan değerlerin Koleksiyon görünümünü döndürür
LinkedHashMap örneği
import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class HashLinkedListExample {
public static void main(String args[]) {
// LinkedHashMap Declaration
LinkedHashMap<Integer, String> myLinkedHashMap =
new LinkedHashMap<Integer, String>();
//Adding elements into LinkedHashMap
myLinkedHashMap.put(7, "Johnny");
myLinkedHashMap.put(12, "Rick");
myLinkedHashMap.put(1, "Kyle");
myLinkedHashMap.put(5, "Percy");
myLinkedHashMap.put(85, "Sebastian");
// Generate a Set of entries
Set set = myLinkedHashMap.entrySet();
// Display and print out the nodes of LinkedHashMap
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry me = (Map.Entry)iterator.next();
System.out.print("key: "+ me.getKey() +
" value: "+me.getValue()+"\n");
}
//print out HashLinkedMap on standard way:
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(21, "Ivy");
System.out.println(myLinkedHashMap);
myLinkedHashMap.remove(12);
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(12, "Ronny");
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(1, "Stan");
System.out.println(myLinkedHashMap);
}
}
Burada beş öğe ekleyerek yeni bir LinkedHashMap oluşturuyoruz, ardından yineleyici kullanarak ve klasik bir şekilde yazdırıyoruz. Gördüğünüz gibi, LinkedHashMap ekleme sırasını koruyor. Bundan sonra, Haritamızdan bir öğeyi sileriz, ardından yenisini ekleriz ve daha sonra - zaten haritada bulunan anahtarla bir öğe daha. Bu anahtara eşlenen eski değerin yerine geçer. Çalışan programın sonucu:
HashMap, TreeMap ve LinkedHashMap, Harita arayüzlerinin uygulamalarıdır. HashMap ve LinkedHashMap, anahtarları özetleyen veri yapılarıdır. TreeMap, bir arama ağacı düzenlemek için anahtarlarının doğal sırasını kullanır. Emir:
HashMap herhangi bir düzen sağlamaz.
TreeMap, girişleri artan anahtar sırasına göre sıralar.
LinkedHashMap ekleme sırasını korur.
Boş tuşlar:
HashMap ve LinkedHashMap, bir boş anahtara sahip olmanızı sağlar.
LinkedHashMap, anahtarların doğal sıralama kullanması durumunda boş anahtarlara izin vermez veya Karşılaştırıcı boş ley'lerde karşılaştırmayı desteklemez.
Bu makalede incelenen üç uygulamayı da içeren bir Java haritası örneğine sahip olalım:
Gördüğümüz gibi, HashMap'te öğelerin sırası açık değildir, treeMap'te anahtarlara bağlıdır, LinkedHashMap'te ise ekleme sırası ile ilgilidir. LinkedHashMap'e boş anahtar koymaya çalışırsak, NullPointerException elde ederiz, ancak anahtarların String olduğu linksedHashMap1'de bunu yapabiliriz. Karma harita, en iyi genel amaçlı harita uygulamasıdır. Maksimum arama hızı, hızlı depolama ve alma işlemleri sağlar, ancak kaotik sıralamasını hatırlamanız gerekir. Bağlantılı bir karma harita, HashMap avantajlarını devralır ve anahtarlar için bir sipariş alır. Ancak, bellek açısından nispeten maliyetli olan linkedList'i içerir. aramada HashMap'ten daha yavaştır ve bağlantılı listeyi koruduğu için ekleme/kaldırma için biraz daha yavaştır. Bir ağaç haritası, anahtarları artan sırada saklar. Fakat, Öğrendiklerinizi pekiştirmek için Java Kursumuzdan bir video dersi izlemenizi öneririz.
GO TO FULL VERSION