كيف يمكنني التكرار بكفاءة على كل إدخال في خريطة Java؟

Question

إذا كان لدي كائن يقوم بتنفيذ Map واجهة في Java وأرغب في التكرار على كل زوج موجود بداخلها، ما هي الطريقة الأكثر فعالية لتصفح الخريطة؟

هل سيعتمد ترتيب العناصر على تطبيق الخريطة المحدد الذي أستخدمه للواجهة؟

Answer 1

Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

Answer 2

لتلخيص الإجابات الأخرى ودمجها مع ما أعرفه، وجدت 10 طرق رئيسية للقيام بذلك (انظر أدناه).كما كتبت بعض اختبارات الأداء (انظر النتائج أدناه).على سبيل المثال، إذا أردنا إيجاد مجموع كل مفاتيح وقيم الخريطة، يمكننا أن نكتب:

1. استخدام مكرر و خريطة.إدخال

   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();
   }
   

2. استخدام com.foreach و خريطة.إدخال

   long i = 0;
   for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
       i += pair.getKey() + pair.getValue();
   }
   

3. استخدام لكل من جافا 8

   final long[] i = {0};
   map.forEach((k, v) -> i[0] += k + v);
   

4. استخدام keySet و com.foreach

   long i = 0;
   for (Integer key : map.keySet()) {
       i += key + map.get(key);
   }
   

5. استخدام keySet و مكرر

   long i = 0;
   Iterator<Integer> itr2 = map.keySet().iterator();
   while (itr2.hasNext()) {
       Integer key = itr2.next();
       i += key + map.get(key);
   }
   

6. استخدام ل و خريطة.إدخال

   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();
   }
   

7. باستخدام جافا 8 دفق API

   final long[] i = {0};
   map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
   

8. باستخدام جافا 8 دفق API بالتوازي

   final long[] i = {0};
   map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());
   

9. استخدام IterableMap ل Apache Collections

   long i = 0;
   MapIterator<Integer, Integer> it = iterableMap.mapIterator();
   while (it.hasNext()) {
       i += it.next() + it.getValue();
   }
   

10. استخدام 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 جيجابايت)

1. بالنسبة للخريطة الصغيرة (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
   

2. بالنسبة للخريطة التي تحتوي على 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
   

3. بالنسبة للخريطة التي تحتوي على 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

جميع الاختبارات قيد التشغيل جيثب.

Answer 3

في 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 أي أكثر من ذلك.

سهل جدا!

Answer 4

نعم، يعتمد الترتيب على تنفيذ الخريطة المحدد.

يحتوي @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();
  // ...
}

Answer 5

الكود النموذجي للتكرار على الخريطة هو:

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 يتم تحديث.

Answer 6

مثال على استخدام التكرار والأدوية العامة:

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();
  // ...
}

Answer 7

هذا سؤال من قسمين:

كيفية التكرار على إدخالات الخريطة - @ScArcher2 لديه أجاب هذا تماما.

ما هو ترتيب التكرار - إذا كنت تستخدم فقط Map, ، ثم بالمعنى الدقيق للكلمة، هناك لا ضمانات الطلب.لذلك لا يجب أن تعتمد حقًا على الترتيب الذي يقدمه أي تطبيق.ومع ذلك، SortedMap تمتد الواجهة Map ويوفر بالضبط ما تبحث عنه - ستوفر عمليات التنفيذ دائمًا ترتيبًا ثابتًا للفرز.

NavigableMap هو امتداد مفيد آخر - هذا ال SortedMap مع طرق إضافية للعثور على الإدخالات حسب موضعها المرتب في مجموعة المفاتيح.لذلك من المحتمل أن يؤدي هذا إلى إزالة الحاجة إلى التكرار في المقام الأول - قد تتمكن من العثور على ما هو محدد entry أنت بعد استخدام higherEntry, lowerEntry, ceilingEntry, ، أو floorEntry طُرق.ال descendingMap حتى أن الطريقة تمنحك طريقة واضحة لـ عكس ترتيب الاجتياز.

Answer 8

هناك عدة طرق للتكرار على الخريطة.

فيما يلي مقارنة لأدائهم لمجموعة بيانات مشتركة مخزنة في الخريطة عن طريق تخزين مليون زوج من القيمة الرئيسية في الخريطة وسيتم تكرارها على الخريطة.

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.

Answer 9

الطريقة الصحيحة للقيام بذلك هي استخدام الإجابة المقبولة لأنها الأكثر كفاءة.أجد أن الكود التالي يبدو أنظف قليلاً.

for (String key: map.keySet()) {
   System.out.println(key + "/" + map.get(key));
}

Answer 10

لمعلوماتك، يمكنك أيضًا استخدام map.keySet() و map.values() إذا كنت مهتمًا فقط بمفاتيح/قيم الخريطة وليس غيرها.

Answer 11

مع مجموعات الكسوف (سابقا مجموعات جي إس)، يمكنك استخدام طريقة 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.

Answer 12

من الناحية النظرية، تعتمد الطريقة الأكثر فعالية على تنفيذ الخريطة.الطريقة الرسمية للقيام بذلك هي الاتصال map.entrySet(), ، والتي تقوم بإرجاع مجموعة من Map.Entry, ، يحتوي كل منها على مفتاح وقيمة (entry.getKey() و entry.getValue()).

في التنفيذ الفريد، قد يحدث بعض الاختلاف فيما إذا كنت تستخدمه أم لا map.keySet(), map.entrySet() أو أي شيء آخر.لكن لا يمكنني التفكير في سبب يجعل أي شخص يكتبها بهذه الطريقة.على الأرجح أنه لا فرق في أداء ما تفعله.

ونعم، سيعتمد الترتيب على التنفيذ - وكذلك (ربما) ترتيب الإدراج وعوامل أخرى يصعب التحكم فيها.

[عدل] لقد كتبت valueSet() في الأصل ولكن بالطبع entrySet() هو في الواقع الجواب.

Answer 13

جافا 8:

يمكنك استخدام تعبيرات لامدا:

myMap.entrySet().stream().forEach((entry) -> {
    Object currentKey = entry.getKey();
    Object currentValue = entry.getValue();
});

لمزيد من المعلومات، اتبع هذا.

Answer 14

جرب هذا مع Java 1.4:

for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){

  Entry entry = (Entry) entries.next();

  System.out.println(entry.getKey() + "/" + entry.getValue());

  //...
}

Answer 15

مع جافا 8

map.forEach((k, v) -> System.out.println((k + ":" + v)));

Answer 16

جافا 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 لا يضمن الحفاظ على الطلب.تحقق أيضا هذا للمزيد من.

Answer 17

لامدا التعبير جافا 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.للمزيد عن لامدا اذهب إلى هذا وصلة ويجب أن تقرأ العمليات المجمعة وللسبليتيراتور اذهب إلى هذا وصلة.

Answer 18

في الخريطة يمكن للمرء أن يكرر أكثر 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);
}

Answer 19

الأكثر إحكاما مع Java 8:

map.entrySet().forEach(System.out::println);

Answer 20

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();
        }
    }
}

Answer 21

إذا كان لديك خريطة عامة غير مكتوبة، فيمكنك استخدام:

Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

Answer 22

    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());    
    }

Answer 23

يمكنك القيام بذلك باستخدام الأدوية العامة:

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());
}

Answer 24

استخدم جافا 8:

map.entrySet().forEach(entry -> System.out.println(entry.getValue()));

Answer 25

           //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();

            }

Answer 26

سيعتمد الترتيب دائمًا على تنفيذ الخريطة المحددة.باستخدام 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,

Answer 27

الحل التكراري الفعال عبر الخريطة هو حلقة "لكل" من 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");
    }
});

Answer 28

نعم، كما اتفق العديد من الأشخاص على أن هذه هي أفضل طريقة للتكرار على ملف Map.

ولكن هناك فرص لرمي nullpointerexception إذا كانت الخريطة null.لا تنسى أن تضع null .تحقق في.

                                                 |
                                                 |
                                         - - - -
                                       |
                                       |
for (Map.Entry<String, Object> entry : map.entrySet()) {
    String key = entry.getKey();
    Object value = entry.getValue();
}

Answer 29

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));
    }
}

Answer 30

هناك الكثير من الطرق للقيام بذلك.فيما يلي بعض الخطوات البسيطة:

لنفترض أن لديك خريطة واحدة مثل:

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));
}