scala数据结构之Set和Map

 XML Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

package com.lyzx.day06

/**
 * Set和Map介绍
 * 把Set和Map放在一起是因为Map和Set一样
 * 唯一的区别就是Map存放键值对而Set存放键，正因为Map的键不能重复所以Set的元素(即键)也不能重复(java中也是如此)
 */
class T4 {
  /**
   * Set的创建和遍历
   */
  def f1(): Unit ={
    //创建Set  自动去重
    val set1 = Set(5,4,3,2,2,2,2,1);
    println(set1.size)


    //遍历set的第一种方式iterator
    val itr = set1.iterator;
    while(itr.hasNext){
      println("iterator:"+itr.next())
    }

    for(item <- set1){
      println("foreach:"+item)
    }
    println("======================")
    set1.foreach(println)

    //求最大值
    println("max:"+set1.max)

    //求最小值
    println("min:"+set1.min)
  }


  /**
   * 集合的一些操作
   *
   */
  def f2(): Unit ={
    val s1 = Set(1,2,3,4,5,5,5,5,6,7);
    val s2 = Set(7,6,5,99)
    val _s3 = Set(1)
    //intersect  相交 交叉
    val s3 = s1.intersect(s2)
    println("intersect:"+s3.toString())

    val s4 = s1.&(s2)
    println("&:"+s4)
    //结果是true这说明 scala对集合求交集做了一些优化
    println("is equals:"+(s3 == s4))
    println("===============================")

    //求补集 s1.diff(s2)即s1有但是s2没有的  也就是说s1-s2
    s1.diff(s2).foreach(item=>{
      println("s1.diff(s2):"+item)
    })

    val s12 = s1.diff(s2)
    val _s12 = s1.&~(s2)
    println(s12 == _s12)

    println("==============================")
    //求全集
    s1.++(s2).foreach(item=>{
      println("s1.++(s2):"+item)
    })

    println("===================================")

    //是不是子集   当_s3是s1的子集时返回true
   val x = _s3.subsetOf(s1)
    print(x.toString)
  }

   //连接
   def f3(): Unit ={
      val s = Set("唐僧","孙悟空","7猪八戒","沙和尚","A","B","C")
     //s.mkString(x)  用字符串x连接所有项
     val str = s.mkString("~")
     println(str)

     //集合所有元素作为字符串显示
     println(s.mkString)
   }

  /**
   *Map的创建和遍历
   */
  def f4(): Unit ={
    val m1 = Map((1->"v1"),(2->"v2"),(2->"v22"),(3->"v3"))
    for(item <- m1){
      //这个item是每一项的键值对 即java里面的Map.Entry,通过item._1获取键   item._2获取值
      println("foreach:"+item._1+"  "+item._2)
    }

    println("============================================")
    m1.foreach(item=>{
      println("m1.foreach:"+item._1+"   "+item._2)
    })

    println("============================================")
    val itr = m1.keySet.iterator
    while(itr.hasNext){
      val key = itr.next()
      // Map.get(key) 返回的是Some(value)包装对象,然后通过get获取里面的值
      println("iterator:"+key+"   "+m1.get(key).get)
    }
  }


  //映射数组相加
  def f5(): Unit ={
      val m1 = Map((1->"m1v1"),(2->"m1v2"))
      val m2 = Map((3->"m2v3"),(2->"m2v2"))

    //相当于把m2中的元素加入到m1中，如果有重复的用m2的覆盖m1的
    val newMap = m1.++(m2)
     newMap.foreach(item=>println("m1.++(m2)newMap:"+item._1+"   "+item._2))

    //相当于把m1中的元素加入到m2中，如果有相同的就用m1中的元素覆盖m2中的
    m1.++:(m2).foreach(item=>println("m1.++:(m2) newMap:"+item._1+"   "+item._2))

    m1.foreach(item=>println("m1:"+item._1+"  "+item._2))
    m2.foreach(item=>println("m2:"+item._1+"  "+item._2))
  }


  def f6(): Unit ={
      val m1 = Map((1->"1one"),(2->"1two"),(3->"three"),(4->"four"))
//   val m2 = Map((3->"three"),(4->"four"))
    //过滤方法,函数的参数类似于java中Map的Map.Entry
    m1.filter(item=>item._1>2).foreach(item=>println("filter:"+item._1+"   "+item._2))

    val isContain = m1.contains(2)
    println(isContain)
  }
}

object T4{
  def main(args: Array[String]) {
    val t4 = new T4
//    t4.f1()
//    t4.f3()
//    t4.f4()
   t4.f5()
//    t4.f6()
  }
}

Set方法合集

1def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2 def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3 def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4 def &(that: Set[A]): Set[A]
返回两个集合的交集
5 def &~(that: Set[A]): Set[A]
返回两个集合的差集
6 def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7 def ++(elems: A): Set[A]
合并两个集合
8 def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9 def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10 def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11 def apply(elem: A)
检测集合中是否包含指定元素
12 def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13 def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14 def diff(that: Set[A]): Set[A]
比较两个集合的差集
15 def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16 def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17 def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18 def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19 def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20 def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21 def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22 def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23 def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24 def head: A
获取不可变集合的第一个元素
25 def init: Set[A]
返回所有元素，除了最后一个
26 def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27 def isEmpty: Boolean
判断集合是否为空
28 def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29 def last: A
返回最后一个元素
30 def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31 def max: A
查找最大元素
32 def min: A
查找最小元素
33 def mkString: String
集合所有元素作为字符串显示
34 def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35 def product: A
返回不可变集合中数字元素的积。
36 def size: Int
返回不可变集合元素的数量
37 def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38 def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39 def sum: A
返回不可变集合中所有数字元素之和
40 def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41 def take(n: Int): Set[A]
返回前 n 个元素
42 def takeRight(n: Int):Set[A]
返回后 n 个元素
43 def toArray: Array[A]
将集合转换为数组
44 def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45 def toList: List[A]
返回 List，包含了不可变集合的所有元素
46 def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47 def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48 def toString(): String
返回一个字符串，以对象来表示

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, 移除 key 为 elem1, elem2 或其他 elems。
3 def --(xs: GTO[A]): Map[A, B]
返回一个新的 Map, 移除 xs 对象中对应的 key
4 def get(key: A): Option[B]
返回指定 key 的值
5 def iterator: Iterator[(A, B)]
创建新的迭代器，并输出 key/value 对
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 的默认方法
10 def clone(): Map[A, B]
从一个 Map 复制到另一个 Map
11 def contains(key: A): Boolean
如果 Map 中存在指定 key，返回 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 的默认值，在 key 不存在时返回。
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]
返回所有的key/p>
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]
移除指定 key
34 def retain(p: (A, B) => Boolean): Map.this.type
如果符合满足条件的返回 true
35 def size: Int
返回 Map 元素的个数
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]
返回缓冲区，包含了 Map 的所有元素
43 def toList: List[A]
返回 List，包含了 Map 的所有元素
44 def toSeq: Seq[A]
返回 Seq，包含了 Map 的所有元素
45 def toSet: Set[A]
返回 Set，包含了 Map 的所有元素
46 def toString(): String
返回字符串对象