كيف يمكنني التكرار بكفاءة على كل إدخال في خريطة Java؟
-
09-06-2019 - |
سؤال
إذا كان لدي كائن يقوم بتنفيذ Map
واجهة في Java وأرغب في التكرار على كل زوج موجود بداخلها، ما هي الطريقة الأكثر فعالية لتصفح الخريطة؟
هل سيعتمد ترتيب العناصر على تطبيق الخريطة المحدد الذي أستخدمه للواجهة؟
المحلول
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
نصائح أخرى
لتلخيص الإجابات الأخرى ودمجها مع ما أعرفه، وجدت 10 طرق رئيسية للقيام بذلك (انظر أدناه).كما كتبت بعض اختبارات الأداء (انظر النتائج أدناه).على سبيل المثال، إذا أردنا إيجاد مجموع كل مفاتيح وقيم الخريطة، يمكننا أن نكتب:
استخدام مكرر و خريطة.إدخال
long i = 0; Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry<Integer, Integer> pair = it.next(); i += pair.getKey() + pair.getValue(); }
استخدام com.foreach و خريطة.إدخال
long i = 0; for (Map.Entry<Integer, Integer> pair : map.entrySet()) { i += pair.getKey() + pair.getValue(); }
استخدام لكل من جافا 8
final long[] i = {0}; map.forEach((k, v) -> i[0] += k + v);
استخدام keySet و com.foreach
long i = 0; for (Integer key : map.keySet()) { i += key + map.get(key); }
استخدام keySet و مكرر
long i = 0; Iterator<Integer> itr2 = map.keySet().iterator(); while (itr2.hasNext()) { Integer key = itr2.next(); i += key + map.get(key); }
استخدام ل و خريطة.إدخال
long i = 0; for (Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); entries.hasNext(); ) { Map.Entry<Integer, Integer> entry = entries.next(); i += entry.getKey() + entry.getValue(); }
باستخدام جافا 8 دفق API
final long[] i = {0}; map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
باستخدام جافا 8 دفق API بالتوازي
final long[] i = {0}; map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());
استخدام IterableMap ل
Apache Collections
long i = 0; MapIterator<Integer, Integer> it = iterableMap.mapIterator(); while (it.hasNext()) { i += it.next() + it.getValue(); }
استخدام MutableMap من مجموعات Eclipse (CS).
final long[] i = {0}; mutableMap.forEachKeyValue((key, value) -> { i[0] += key + value; });
اختبارات الأداء (الوضع = AverageTime، النظام = Windows 8.1 64 بت، Intel i7-4790 بسرعة 3.60 جيجاهرتز، 16 جيجابايت)
بالنسبة للخريطة الصغيرة (100 عنصر)، الدرجة 0.308 هي الأفضل
Benchmark Mode Cnt Score Error Units test3_UsingForEachAndJava8 avgt 10 0.308 ± 0.021 µs/op test10_UsingEclipseMap avgt 10 0.309 ± 0.009 µs/op test1_UsingWhileAndMapEntry avgt 10 0.380 ± 0.014 µs/op test6_UsingForAndIterator avgt 10 0.387 ± 0.016 µs/op test2_UsingForEachAndMapEntry avgt 10 0.391 ± 0.023 µs/op test7_UsingJava8StreamApi avgt 10 0.510 ± 0.014 µs/op test9_UsingApacheIterableMap avgt 10 0.524 ± 0.008 µs/op test4_UsingKeySetAndForEach avgt 10 0.816 ± 0.026 µs/op test5_UsingKeySetAndIterator avgt 10 0.863 ± 0.025 µs/op test8_UsingJava8StreamApiParallel avgt 10 5.552 ± 0.185 µs/op
بالنسبة للخريطة التي تحتوي على 10000 عنصر، فإن النتيجة 37.606 هي الأفضل
Benchmark Mode Cnt Score Error Units test10_UsingEclipseMap avgt 10 37.606 ± 0.790 µs/op test3_UsingForEachAndJava8 avgt 10 50.368 ± 0.887 µs/op test6_UsingForAndIterator avgt 10 50.332 ± 0.507 µs/op test2_UsingForEachAndMapEntry avgt 10 51.406 ± 1.032 µs/op test1_UsingWhileAndMapEntry avgt 10 52.538 ± 2.431 µs/op test7_UsingJava8StreamApi avgt 10 54.464 ± 0.712 µs/op test4_UsingKeySetAndForEach avgt 10 79.016 ± 25.345 µs/op test5_UsingKeySetAndIterator avgt 10 91.105 ± 10.220 µs/op test8_UsingJava8StreamApiParallel avgt 10 112.511 ± 0.365 µs/op test9_UsingApacheIterableMap avgt 10 125.714 ± 1.935 µs/op
بالنسبة للخريطة التي تحتوي على 100000 عنصر، فإن النتيجة 1184.767 هي الأفضل
Benchmark Mode Cnt Score Error Units test1_UsingWhileAndMapEntry avgt 10 1184.767 ± 332.968 µs/op test10_UsingEclipseMap avgt 10 1191.735 ± 304.273 µs/op test2_UsingForEachAndMapEntry avgt 10 1205.815 ± 366.043 µs/op test6_UsingForAndIterator avgt 10 1206.873 ± 367.272 µs/op test8_UsingJava8StreamApiParallel avgt 10 1485.895 ± 233.143 µs/op test5_UsingKeySetAndIterator avgt 10 1540.281 ± 357.497 µs/op test4_UsingKeySetAndForEach avgt 10 1593.342 ± 294.417 µs/op test3_UsingForEachAndJava8 avgt 10 1666.296 ± 126.443 µs/op test7_UsingJava8StreamApi avgt 10 1706.676 ± 436.867 µs/op test9_UsingApacheIterableMap avgt 10 3289.866 ± 1445.564 µs/op
الرسوم البيانية (اختبارات الأداء حسب حجم الخريطة)
الجدول (اختبارات الأداء حسب حجم الخريطة)
100 600 1100 1600 2100
test10 0.333 1.631 2.752 5.937 8.024
test3 0.309 1.971 4.147 8.147 10.473
test6 0.372 2.190 4.470 8.322 10.531
test1 0.405 2.237 4.616 8.645 10.707
test2 0.376 2.267 4.809 8.403 10.910
test7 0.473 2.448 5.668 9.790 12.125
test9 0.565 2.830 5.952 13.220 16.965
test4 0.808 5.012 8.813 13.939 17.407
test5 0.810 5.104 8.533 14.064 17.422
test8 5.173 12.499 17.351 24.671 30.403
جميع الاختبارات قيد التشغيل جيثب.
في Java 8، يمكنك القيام بذلك بشكل نظيف وسريع باستخدام ميزات lambdas الجديدة:
Map<String,String> map = new HashMap<>();
map.put("SomeKey", "SomeValue");
map.forEach( (k,v) -> [do something with key and value] );
// such as
map.forEach( (k,v) -> System.out.println("Key: " + k + ": Value: " + v));
نوع من k
و v
سيتم استنتاجه بواسطة المترجم وليس هناك حاجة لاستخدامه Map.Entry
أي أكثر من ذلك.
سهل جدا!
نعم، يعتمد الترتيب على تنفيذ الخريطة المحدد.
يحتوي @ScArcher2 على بناء جملة Java 1.5 الأكثر أناقة.في 1.4، سأفعل شيئًا مثل هذا:
Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Entry thisEntry = (Entry) entries.next();
Object key = thisEntry.getKey();
Object value = thisEntry.getValue();
// ...
}
الكود النموذجي للتكرار على الخريطة هو:
Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
String key = entry.getKey();
Thing thing = entry.getValue();
...
}
HashMap
هو تطبيق الخريطة الأساسي ولا يقدم ضمانات (أو على الرغم من أنه لا ينبغي تغيير الترتيب إذا لم يتم إجراء أي عملية تغيير عليه). SortedMap
سيُرجع الإدخالات بناءً على الترتيب الطبيعي للمفاتيح، أو أ Comparator
, ، إذا قدمت. LinkedHashMap
سيُرجع إما الإدخالات بترتيب الإدراج أو ترتيب الوصول اعتمادًا على كيفية إنشائه. EnumMap
إرجاع الإدخالات بالترتيب الطبيعي للمفاتيح.
(تحديث:أعتقد أن هذا لم يعد صحيحا.) ملحوظة، IdentityHashMap
entrySet
لدى المكرر حاليًا تطبيقًا غريبًا يُرجع نفس الشيء Map.Entry
مثيل لكل عنصر في entrySet
!ومع ذلك، في كل مرة يقوم المكرر بتقديم ملف جديد Map.Entry
يتم تحديث.
مثال على استخدام التكرار والأدوية العامة:
Iterator<Map.Entry<String, String>> entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = entries.next();
String key = entry.getKey();
String value = entry.getValue();
// ...
}
هذا سؤال من قسمين:
كيفية التكرار على إدخالات الخريطة - @ScArcher2 لديه أجاب هذا تماما.
ما هو ترتيب التكرار - إذا كنت تستخدم فقط Map
, ، ثم بالمعنى الدقيق للكلمة، هناك لا ضمانات الطلب.لذلك لا يجب أن تعتمد حقًا على الترتيب الذي يقدمه أي تطبيق.ومع ذلك، SortedMap
تمتد الواجهة Map
ويوفر بالضبط ما تبحث عنه - ستوفر عمليات التنفيذ دائمًا ترتيبًا ثابتًا للفرز.
NavigableMap
هو امتداد مفيد آخر - هذا ال SortedMap
مع طرق إضافية للعثور على الإدخالات حسب موضعها المرتب في مجموعة المفاتيح.لذلك من المحتمل أن يؤدي هذا إلى إزالة الحاجة إلى التكرار في المقام الأول - قد تتمكن من العثور على ما هو محدد entry
أنت بعد استخدام higherEntry
, lowerEntry
, ceilingEntry
, ، أو floorEntry
طُرق.ال descendingMap
حتى أن الطريقة تمنحك طريقة واضحة لـ عكس ترتيب الاجتياز.
هناك عدة طرق للتكرار على الخريطة.
فيما يلي مقارنة لأدائهم لمجموعة بيانات مشتركة مخزنة في الخريطة عن طريق تخزين مليون زوج من القيمة الرئيسية في الخريطة وسيتم تكرارها على الخريطة.
1) باستخدام entrySet()
في لكل حلقة
for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
entry.getKey();
entry.getValue();
}
50 مللي ثانية
2) باستخدام keySet()
في لكل حلقة
for (String key : testMap.keySet()) {
testMap.get(key);
}
76 مللي ثانية
3) الاستخدام entrySet()
والمكرر
Iterator<Map.Entry<String,Integer>> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
Map.Entry<String,Integer> entry = itr1.next();
entry.getKey();
entry.getValue();
}
50 مللي ثانية
4) الاستخدام keySet()
والمكرر
Iterator itr2 = testMap.keySet().iterator();
while(itr2.hasNext()) {
String key = itr2.next();
testMap.get(key);
}
75 مللي ثانية
لقد أشرت this link
.
الطريقة الصحيحة للقيام بذلك هي استخدام الإجابة المقبولة لأنها الأكثر كفاءة.أجد أن الكود التالي يبدو أنظف قليلاً.
for (String key: map.keySet()) {
System.out.println(key + "/" + map.get(key));
}
لمعلوماتك، يمكنك أيضًا استخدام map.keySet()
و map.values()
إذا كنت مهتمًا فقط بمفاتيح/قيم الخريطة وليس غيرها.
مع مجموعات الكسوف (سابقا مجموعات جي إس)، يمكنك استخدام طريقة forEachKeyValue على MapIterable الواجهة الموروثة من واجهات MutableMap وImmutableMap وتطبيقاتها.
final MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue(new Procedure2<Integer, String>()
{
public void value(Integer key, String value)
{
result.add(key + value);
}
});
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
باستخدام بناء جملة Java 8 lambda، يمكنك كتابة التعليمات البرمجية على النحو التالي:
MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue((key, value) -> result.add(key + value));
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
ملحوظة: أنا ملتزم بمجموعات Eclipse.
من الناحية النظرية، تعتمد الطريقة الأكثر فعالية على تنفيذ الخريطة.الطريقة الرسمية للقيام بذلك هي الاتصال map.entrySet()
, ، والتي تقوم بإرجاع مجموعة من Map.Entry
, ، يحتوي كل منها على مفتاح وقيمة (entry.getKey()
و entry.getValue()
).
في التنفيذ الفريد، قد يحدث بعض الاختلاف فيما إذا كنت تستخدمه أم لا map.keySet()
, map.entrySet()
أو أي شيء آخر.لكن لا يمكنني التفكير في سبب يجعل أي شخص يكتبها بهذه الطريقة.على الأرجح أنه لا فرق في أداء ما تفعله.
ونعم، سيعتمد الترتيب على التنفيذ - وكذلك (ربما) ترتيب الإدراج وعوامل أخرى يصعب التحكم فيها.
[عدل] لقد كتبت valueSet()
في الأصل ولكن بالطبع entrySet()
هو في الواقع الجواب.
جافا 8:
يمكنك استخدام تعبيرات لامدا:
myMap.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
});
لمزيد من المعلومات، اتبع هذا.
جرب هذا مع Java 1.4:
for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){
Entry entry = (Entry) entries.next();
System.out.println(entry.getKey() + "/" + entry.getValue());
//...
}
مع جافا 8
map.forEach((k, v) -> System.out.println((k + ":" + v)));
جافا 8
اصبح لدينا forEach
الطريقة التي تقبل أ تعبير لامدا.لقد حصلنا أيضا تدفق واجهات برمجة التطبيقات.النظر في الخريطة:
Map<String,String> sample = new HashMap<>();
sample.put("A","Apple");
sample.put("B", "Ball");
التكرار على المفاتيح:
sample.keySet().forEach((k) -> System.out.println(k));
التكرار على القيم:
sample.values().forEach((v) -> System.out.println(v));
التكرار على الإدخالات (باستخدام forEach والتدفقات):
sample.forEach((k,v) -> System.out.println(k + ":" + v));
sample.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
System.out.println(currentKey + ":" + currentValue);
});
ميزة التدفقات هي أنه يمكن موازنتها بسهولة إذا أردنا ذلك.نحن ببساطة بحاجة إلى استخدام parallelStream()
بدلا من stream()
فوق.
forEachOrdered
ضد forEach
مع تيارات؟ال forEach
لا يتبع ترتيب اللقاء (إذا تم تعريفه) وهو بطبيعته غير حتمية بطبيعته حيث forEachOrdered
يفعل.لذا forEach
لا يضمن الحفاظ على الطلب.تحقق أيضا هذا للمزيد من.
لامدا التعبير جافا 8
في Java 1.8 (Java 8) أصبح هذا أسهل كثيرًا باستخدام لكل طريقة من العمليات الإجمالية (عمليات الدفق) الذي يشبه التكرارات من متوقعة واجهه المستخدم.
ما عليك سوى نسخ العبارة التالية ولصقها في الكود الخاص بك وإعادة تسمية خريطة التجزئة متغير من حسنًا إلى متغير HashMap الخاص بك لطباعة زوج القيمة الرئيسية.
HashMap<Integer,Integer> hm = new HashMap<Integer, Integer>();
/*
* Logic to put the Key,Value pair in your HashMap hm
*/
// Print the key value pair in one line.
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
// Just copy and paste above line to your code.
يوجد أدناه نموذج التعليمات البرمجية الذي حاولت استخدامه تعبير لامدا.هذه الأشياء رائعة جدًا.يجب أن نحاول.
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
Random rand = new Random(47);
int i = 0;
while(i < 5) {
i++;
int key = rand.nextInt(20);
int value = rand.nextInt(50);
System.out.println("Inserting key: " + key + " Value: " + value);
Integer imap = hm.put(key, value);
if( imap == null) {
System.out.println("Inserted");
} else {
System.out.println("Replaced with " + imap);
}
}
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
Output:
Inserting key: 18 Value: 5
Inserted
Inserting key: 13 Value: 11
Inserted
Inserting key: 1 Value: 29
Inserted
Inserting key: 8 Value: 0
Inserted
Inserting key: 2 Value: 7
Inserted
key: 1 value:29
key: 18 value:5
key: 2 value:7
key: 8 value:0
key: 13 value:11
كما يمكن للمرء أن يستخدم الفاصل للشىء نفسه.
Spliterator sit = hm.entrySet().spliterator();
تحديث
بما في ذلك روابط الوثائق إلى Oracle Docs.للمزيد عن لامدا اذهب إلى هذا وصلة ويجب أن تقرأ العمليات المجمعة وللسبليتيراتور اذهب إلى هذا وصلة.
في الخريطة يمكن للمرء أن يكرر أكثر keys
و/أو values
و/أو both (e.g., entrySet)
يعتمد على اهتمام الشخص _ مثل:
1.) كرر من خلال keys -> keySet()
من الخريطة:
Map<String, Object> map = ...;
for (String key : map.keySet()) {
//your Business logic...
}
2.) كرر من خلال values -> values()
من الخريطة:
for (Object value : map.values()) {
//your Business logic...
}
3.) كرر من خلال both -> entrySet()
من الخريطة:
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
//your Business logic...
}
علاوة على ذلك، هناك 3 طرق مختلفة للتكرار من خلال HashMap.وهم على النحو التالي_
//1.
for (Map.Entry entry : hm.entrySet()) {
System.out.print("key,val: ");
System.out.println(entry.getKey() + "," + entry.getValue());
}
//2.
Iterator iter = hm.keySet().iterator();
while(iter.hasNext()) {
Integer key = (Integer)iter.next();
String val = (String)hm.get(key);
System.out.println("key,val: " + key + "," + val);
}
//3.
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Integer key = (Integer)entry.getKey();
String val = (String)entry.getValue();
System.out.println("key,val: " + key + "," + val);
}
الأكثر إحكاما مع Java 8:
map.entrySet().forEach(System.out::println);
public class abcd{
public static void main(String[] args)
{
Map<Integer, String> testMap = new HashMap<Integer, String>();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Integer key:testMap.keySet()) {
String value=testMap.get(key);
System.out.println(value);
}
}
}
أو
public class abcd {
public static void main(String[] args)
{
Map<Integer, String> testMap = new HashMap<Integer, String>();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Entry<Integer, String> entry : testMap.entrySet()) {
Integer key=entry.getKey();
String value=entry.getValue();
}
}
}
إذا كان لديك خريطة عامة غير مكتوبة، فيمكنك استخدام:
Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry element = (Map.Entry)it.next();
LOGGER.debug("Key: " + element.getKey());
LOGGER.debug("value: " + element.getValue());
}
يمكنك القيام بذلك باستخدام الأدوية العامة:
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<Integer, Integer> entry = entries.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
استخدم جافا 8:
map.entrySet().forEach(entry -> System.out.println(entry.getValue()));
//Functional Oprations
Map<String, String> mapString = new HashMap<>();
mapString.entrySet().stream().map((entry) -> {
String mapKey = entry.getKey();
return entry;
}).forEach((entry) -> {
String mapValue = entry.getValue();
});
//Intrator
Map<String, String> mapString = new HashMap<>();
for (Iterator<Map.Entry<String, String>> it = mapString.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, String> entry = it.next();
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
//Simple for loop
Map<String, String> mapString = new HashMap<>();
for (Map.Entry<String, String> entry : mapString.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
سيعتمد الترتيب دائمًا على تنفيذ الخريطة المحددة.باستخدام Java 8، يمكنك استخدام أي مما يلي:
map.forEach((k,v) -> { System.out.println(k + ":" + v); });
أو:
map.entrySet().forEach((e) -> {
System.out.println(e.getKey() + " : " + e.getValue());
});
ستكون النتيجة هي نفسها (نفس الترتيب).مجموعة الإدخال مدعومة بالخريطة حتى تحصل على نفس الترتيب.والثاني مفيد لأنه يسمح لك باستخدام لامدا، على سبيل المثال.إذا كنت تريد فقط طباعة الكائنات ذات الأعداد الصحيحة الأكبر من 5:
map.entrySet()
.stream()
.filter(e-> e.getValue() > 5)
.forEach(System.out::println);
يُظهر الكود أدناه التكرار من خلال LinkedHashMap وHashMap العادي (مثال).سترى الفرق في الترتيب:
public class HMIteration {
public static void main(String[] args) {
Map<Object, Object> linkedHashMap = new LinkedHashMap<>();
Map<Object, Object> hashMap = new HashMap<>();
for (int i=10; i>=0; i--) {
linkedHashMap.put(i, i);
hashMap.put(i, i);
}
System.out.println("LinkedHashMap (1): ");
linkedHashMap.forEach((k,v) -> { System.out.print(k + " (#="+k.hashCode() + "):" + v + ", "); });
System.out.println("\nLinkedHashMap (2): ");
linkedHashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
System.out.println("\n\nHashMap (1): ");
hashMap.forEach((k,v) -> { System.out.print(k + " (#:"+k.hashCode() + "):" + v + ", "); });
System.out.println("\nHashMap (2): ");
hashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
}
}
لينكدهاشماب (1):
10 (#=10):10, 9 (#=9):9, 8 (#=8):8, 7 (#=7):7, 6 (#=6):6, 5 (#=5):5, 4 (#=4):4, 3 (#=3):3, 2 (#=2):2, 1 (#=1):1, 0 (#=0):0,
لينكدهاشماب (2):
10 : 10, 9 : 9, 8 : 8, 7 : 7, 6 : 6, 5 : 5, 4 : 4, 3 : 3, 2 : 2, 1 : 1, 0 : 0,
هاشماب (1):
0 (#:0):0, 1 (#:1):1, 2 (#:2):2, 3 (#:3):3, 4 (#:4):4, 5 (#:5):5, 6 (#:6):6, 7 (#:7):7, 8 (#:8):8, 9 (#:9):9, 10 (#:10):10,
هاشماب (2):
0 : 0, 1 : 1, 2 : 2, 3 : 3, 4 : 4, 5 : 5, 6 : 6, 7 : 7, 8 : 8, 9 : 9, 10 : 10,
الحل التكراري الفعال عبر الخريطة هو حلقة "لكل" من Java 5 إلى Java 7.ها هو:
for (String key : phnMap.keySet()) {
System.out.println("Key: " + key + " Value: " + phnMap.get(key));
}
من Java 8، يمكنك استخدام تعبير lambda للتكرار على الخريطة.إنه "forEach" محسّن
phnMap.forEach((k,v) -> System.out.println("Key: " + k + " Value: " + v));
إذا كنت تريد كتابة شرط لامدا يمكنك كتابته على النحو التالي:
phnMap.forEach((k,v)->{
System.out.println("Key: " + k + " Value: " + v);
if("abc".equals(k)){
System.out.println("Hello abc");
}
});
نعم، كما اتفق العديد من الأشخاص على أن هذه هي أفضل طريقة للتكرار على ملف Map
.
ولكن هناك فرص لرمي nullpointerexception
إذا كانت الخريطة null
.لا تنسى أن تضع null
.تحقق في.
|
|
- - - -
|
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
}
package com.test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Test {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("ram", "ayodhya");
map.put("krishan", "mathura");
map.put("shiv", "kailash");
System.out.println("********* Keys *********");
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key);
}
System.out.println("********* Values *********");
Collection<String> values = map.values();
for (String value : values) {
System.out.println(value);
}
System.out.println("***** Keys and Values (Using for each loop) *****");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out.println("***** Keys and Values (Using while loop) *****");
Iterator<Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<String, String>) entries
.next();
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out
.println("** Keys and Values (Using java 8 using lambdas )***");
map.forEach((k, v) -> System.out
.println("Key: " + k + "\t value: " + v));
}
}
هناك الكثير من الطرق للقيام بذلك.فيما يلي بعض الخطوات البسيطة:
لنفترض أن لديك خريطة واحدة مثل:
Map<String, Integer> m = new HashMap<String, Integer>();
ثم يمكنك القيام بشيء مثل ما يلي للتكرار على عناصر الخريطة.
// ********** Using an iterator ****************
Iterator<Entry<String, Integer>> me = m.entrySet().iterator();
while(me.hasNext()){
Entry<String, Integer> pair = me.next();
System.out.println(pair.getKey() + ":" + pair.getValue());
}
// *********** Using foreach ************************
for(Entry<String, Integer> me : m.entrySet()){
System.out.println(me.getKey() + " : " + me.getValue());
}
// *********** Using keySet *****************************
for(String s : m.keySet()){
System.out.println(s + " : " + m.get(s));
}
// *********** Using keySet and iterator *****************
Iterator<String> me = m.keySet().iterator();
while(me.hasNext()){
String key = me.next();
System.out.println(key + " : " + m.get(key));
}