English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Scala Map (الترجمة)

جمعيات Scala

Map (الترجمة) هي بنية قابلة للتكرار من زوجات المفتاح/القيمة (key/value).

يمكن الحصول على جميع القيم من خلال المفتاح.

كل المفاتيح في Map فريدة.

يُدعى Map أيضًا جدول هش (Hash tables).

يوجد نوعان من Map، قابل للتغيير وغير قابل للتغيير، والفرق بينهما هو أن العنصر القابل للتغيير يمكن تعديله، بينما العنصر غير القابل للتغيير لا يمكن تعديله.

بافتراض افتراضي Scala يستخدم Map غير القابل للتغيير. إذا كنت بحاجة إلى استخدام مجموعة قابلة للتغيير، يجب عليك إدخالها بشكل واضح import scala.collection.mutable.Map النوع

في Scala يمكنك استخدام Map القابلة للتغيير واللاقابلة للتغيير في نفس الوقت، يمكنك استخدام Map مباشرة للاستخدام غير القابل للتغيير، واستخدام mutable.Map للاستخدام القابل للتغيير. يوضح هذا المثال تطبيق Map غير القابل للتغيير:

// جدول هش فارغ، المفتاح هو سلسلة، القيمة هي عدد
var A:Map[Char,Int] = Map()
// عرض زوجات مفتاح-قيمة Map
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

عند تعريف Map يجب تعريف نوع المفتاح والمقابل. إذا كنت بحاجة إلى إضافة زوج مفتاح-قيمة، يمكنك استخدام الرمز +، كما هو موضح أدناه:

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

عمليات Map الأساسية

يحتوي Scala Map على ثلاث عمليات أساسية:

الطريقةالوصف
keysيعود بجميع المفاتيح (key) لـ Map
valuesيعود بجميع القيم (value) لـ Map
isEmptyيعود Map عند عدم وجوده إلى true

النماذج التوضيحية على الإنترنت

النماذج التوضيحية التالية توضح تطبيق هذه الطرق الثلاث الأساسية:

object Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "الأزرق" -> "#F0FFFF",
                       "البيرو" -> "#CD853F")
      val nums: Map[Int, Int] = Map()
      println("المفاتيح في colors : " + colors.keys())
      println("القيم في colors : " + colors.values())
      println("تحقق من whether colors فارغ : " + colors.isEmpty())
      println("تحقق من whether nums فارغ : " + nums.isEmpty())
   }
}

تنفيذ الكود أعلاه، النتيجة ستكون:

$ scalac Test.scala 
$ scala Test
المفاتيح في colors : Set(الأحمر, الأزرق, البيرو)
القيم في colors : MapLike(#FF0000, #F0FFFF, #CD853F)
تحقق من whether colors فارغ : false
تحقق من whether nums فارغ : true

جمع Maps

يمكنك استخدام ++ عملاق أو Map.++() استخدام دالة لجمع اثنين من Maps، عند جمع Maps يتم إزالة المفاتيح المكررة. يظهر هنا مثال على جمع Maps:

object Test {
   def main(args: Array[String]) {
      val colors1 = Map("الأحمر" -> "#FF0000",
                        "الأزرق" -> "#F0FFFF",
                        "البيرو" -> "#CD853F")
      val colors2 = Map("اللون الأزرق" -> "#0033FF",
                        "الأصفر" -> "#FFFF00",
                        "الأحمر" -> "#FF0000")
      // ++ كعملاق
      var colors = colors1 ++ colors2
      println("colors1 ++ colors2 : " + colors)
      // ++ كدالة
      colors = colors1.++(colors2)
      println("colors1.++(colors2) : " + colors)
   }
}

تنفيذ الكود أعلاه، النتيجة ستكون:

$ scalac Test.scala 
$ scala Test
colors1 ++ colors2 : Map(اللون الأزرق -> #0033FF, الأزرق -> #F0FFFF, البيرو -> #CD853F, الأصفر -> #FFFF00, الأحمر -> #FF0000)
colors1.++(colors2) : Map(اللون الأزرق -> #0033FF, الأزرق -> #F0FFFF, البيرو -> #CD853F, الأصفر -> #FFFF00, الأحمر -> #FF0000)

عرض keys و values من Map

فيما يلي، يتم عرض keys و values من Map باستخدام حلقة foreach:

object Test {
   def main(args: Array[String]) {
      val sites = Map("w3codebox" -> "http://ar.oldtoolbag.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com"
      sites.keys.foreach{i =>  
                           print(" مفتاح = " + i)
                           println(" القيمة = " + sites(i))
   }
}

تنفيذ الكود أعلاه، النتيجة ستكون:

$ scalac Test.scala 
$ scala Test
مفتاح = w3codebox القيمة = http://ar.oldtoolbag.com
مفتاح = baidu القيمة = http://www.baidu.com
مفتاح = taobao القيمة = http://www.taobao.com

للتحقق من وجود مفتاح معين في Map

يمكنك استخدام Map.contains طريقة لعرض ما إذا كان مفتاح معين موجودًا في Map. مثال أدناه:

object Test {
   def main(args: Array[String]) {
      val sites = Map("w3codebox" -> "http://ar.oldtoolbag.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com"
      if (sites.contains("w3codebox")) {
           println("مفتاح w3codebox موجود، القيمة الم对应ه هي : " + sites("w3codebox"))
      } else {
           println("مفتاح w3codebox غير موجود")
      }
      if (sites.contains("baidu")) {
           println("مفتاح baidu موجود، القيمة الم对应ه هي : " + sites("baidu"))
      } else {
           println("مفتاح baidu غير موجود")
      }
      if (sites.contains("google")) {
           println("مفتاح google موجود، القيمة الم对应ه هي : " + sites("google"))
      } else {
           println("مفتاح google غير موجود")
      }
   }
}

تنفيذ الكود أعلاه، النتيجة ستكون:

$ scalac Test.scala 
$ scala Test
مفتاح w3codebox موجود، والقيمة المحددة هي :http://ar.oldtoolbag.com
مفتاح baidu موجود، والقيمة المحددة هي :http://www.baidu.com
مفتاح google غير موجود

طرق Scala Map

في الجدول أدناه، تمت عرض الطرق الشائعة لـ Scala Map:

الترتيبالطريقة والوصف
1

def ++(xs: Map[(A, B)]): Map[A, B]

يعود إلى Map جديد، يتكون من Map xs الجديدة

2

def -(elem1: A, elem2: A, elems: A*): Map[A, B]

يعود إلى Map جديد، يزيل المفتاح elem1، elem2 أو أي elems آخرين

3

def --(xs: GTO[A]): Map[A, B]

يعود إلى Map جديد، يزيل العنصر xs الذي يحتوي على المفتاح المحدد

4

def get(key: A): Option[B]

يعود إلى قيمة المفتاح المحدد

5

def iterator: Iterator[(A, B)]

إنشاء م迭代ر جديد، وإخراج زوج المفتاح/القيمة

6

def addString(b: StringBuilder): StringBuilder

إضافة جميع العناصر في Map إلى StringBuilder، يمكن إضافة حرف تقسيم

7

def addString(b: StringBuilder, sep: String): StringBuilder

إضافة جميع العناصر في Map إلى StringBuilder، يمكن إضافة حرف تقسيم

8

def apply(key: A): B

يعود إلى قيمة المفتاح المحدد، وإذا لم يكن موجودًا يعود إلى طريقة Map الافتراضية

9

def clear(): Unit

تفريغ Map

10

def clone(): Map[A, B]

نسخ من Map إلى آخر Map

11

def contains(key: A): Boolean

إذا كان موجودًا مفتاح معين في Map، فإنه يعود إلى true، وإلا يعود إلى false.

12

def copyToArray(xs: Array[(A, B)]): Unit

نسخ المجموعة إلى مصفوفة

13

def count(p: ((A, B)) => Boolean): Int

حساب عدد العناصر في المجموعة التي تفي بشرط معين

14

def default(key: A): B

تحديد القيمة الافتراضية لـ Map، يعود عند عدم وجود مفتاح

15

def drop(n: Int): Map[A, B]

يعود مجموعة جديدة بعد إزالة n عناصر من البداية

16

def dropRight(n: Int): Map[A, B]

يعود مجموعة جديدة بعد إزالة آخر n عناصر

17

def dropWhile(p: ((A, B)) => Boolean): Map[A, B]

إزالة العناصر من اليسار إلى اليمين حتى يصبح شرط p غير صحيح

18

def empty: Map[A, B]

يعود Map فارغ من نفس النوع

19

def equals(that: Any): Boolean

إذا كانت Mapين متطابقتين (key/value متطابقان)، يعود true، وإلا يعود false

20

def exists(p: ((A, B)) => Boolean): Boolean

التحقق من وجود عنصر يتوافق مع الشروط المحددة في المجموعة

21

def filter(p: ((A, B))=> Boolean): Map[A, B]

يعود جميع المجموعات التي تتوافق مع الشروط المحددة

22

def filterKeys(p: (A) => Boolean): Map[A, B]

يعود Map غير المتغير الذي يتوافق مع الشروط المحددة

23

def find(p: ((A, B)) => Boolean): Option[(A, B)]

البحث عن العنصر الأول الذي يتوافق مع الشروط المحددة في المجموعة

24

def foreach(f: ((A, B)) => Unit): Unit

تطبيق الدالة على جميع عناصر المجموعة

25

def init: Map[A, B]

يعود جميع العناصر باستثناء الأخيرة

26

def isEmpty: Boolean

التحقق من أن Map فارغ

27

def keys: Iterable[A]

يعود جميع المفاتيح

28

def last: (A, B)

يعود العنصر الأخير

29

def max: (A, B)

البحث عن العنصر الأكبر

30

def min: (A, B)

البحث عن العنصر الأصغر

31

def mkString: String

عرض جميع عناصر المجموعة ك

32

def product: (A, B)

يعود مجموع العناصر الرقمية في المجموعة.

33

def remove(key: A): Option[B]

إزالة مفتاح معين

34

def retain(p: (A, B) => Boolean): Map.this.type

إذا كانت تتوافق مع الشروط المحددة، يتم العودة إلى true

35

def size: Int

العودة إلى عدد عناصر الخريطة

36

def sum: (A, B)

العودة إلى مجموع جميع العناصر الرقمية في الجمعية

37

def tail: Map[A, B]

العودة إلى مجموعة تحتوي على جميع العناصر باستثناء العنصر الأول

38

def take(n: Int): Map[A, B]

العودة إلى n العناصر الأولى

39

def takeRight(n: Int): Map[A, B]

العودة إلى n العناصر الأخيرة

40

def takeWhile(p: ((A, B)) => Boolean): Map[A, B]

العودة إلى العناصر التي تتوافق مع الشروط المحددة

41

def toArray: Array[(A, B)]

تحويل الجمعية إلى مصفوفة

42

def toBuffer[B >: A]: Buffer[B]

العودة إلى منطقية تحتوي على جميع عناصر الخريطة

43

def toList: List[A]

العودة إلى قائمة تحتوي على جميع عناصر الخريطة

44

def toSeq: Seq[A]

العودة إلى Seq تحتوي على جميع عناصر الخريطة

45

def toSet: Set[A]

العودة إلى مجموعة تحتوي على جميع عناصر الخريطة

46

def toString(): String

العودة إلى عنصر السلسلة

يمكنك الرجوع إلى المزيد من الطرق مستندات API

جمعيات Scala