scala之map，List，:: , +:, :+, :::, +++操作

scala之map，List操作

• 1.Map操作
• 2.List操作
• 2.1Demo1
• 2.2Demo2
• 3.:: , +:, :+, :::, +++

1.Map操作

Map(映射)是一种可迭代的键值对（key/value）结构。

所有的值都可以通过键来获取。

Map 中的键都是唯一的。

Map也叫哈希表（Hash tables）。 Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。 默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类。

package test
/**
  * map的操作;
  */
object MapDemo {
  def main(args: Array[String]): Unit = {
    var map = Map[String,String]("name" -> "jason","age" -> "500","test_100" -> "test_100","test_101" -> "test_101") //引用可变,支持读写操作;
    map += ("city" -> "北京")  //新增
    println(map)  //打印结果为:Map(city -> 北京, name -> jason, test_100 -> test_100, test_101 -> test_101, age -> 500);
    val map2 = Map[String,String]("sex" -> "男","brand" -> "apple") //引用不可变,只能第一次写入值,之后只能读取;
    //map2 += ("test" -> "报错吗")  //此时不能加,直接报错;
    val map3 = scala.collection.mutable.Map[String,String]()   //引用不可变,支持读写操作;
    map3 += ("test" -> "能添加吗")  //添加单个元素;
    map3 += ("test" -> "改变了") //更新;
    map3 += ("success" -> "添加成功了吗","anthor" -> "另外一个")  //添加多个元素;
    println(map3)  //打印结果为:Map(success -> 添加成功了吗, anthor -> 另外一个, test -> 能添加吗);
    println(map3.keys)  //返回所有的key;
    println(map3.values)//返回所有的value;
    println(map3.isEmpty) //当map为空时,返回true;
    var combine_map = map ++ map2  //合并两个map;
    println(combine_map) //打印结果为:Map(city -> 北京, name -> jason, test_100 -> test_100, test_101 -> test_101, age -> 500, brand -> apple, sex -> 男);
    combine_map -= ("city","name") //删除指定的key;
    println(combine_map)  //打印结果为:Map(test_100 -> test_100, test_101 -> test_101, age -> 500, brand -> apple, sex -> 男)
    println(combine_map.get("age").get)  //返回指定key的值;
    println(combine_map.init) //返回所有元素，除了最后一个;
    println(combine_map.last) //返回最后一个元素;
    println(combine_map.max)  //查找最大元素;
    println(combine_map.min)  //查找最小元素;
    println(combine_map.mkString("")) //集合所有元素作为字符串显示;
    //println(combine_map.product) //返回集合中数字元素的积;注意得是num型;
    println(combine_map.size)  //返回map的大小;
    println(combine_map.toArray) //集合转数组;
    println(combine_map.toBuffer) //返回缓冲区,包含了Map的所有元素;
    println(combine_map.toList) //返回List,包含了Map的所有元素;
    combine_map.get("test_101").getOrElse("不存在") //根据key取value值,如果不存在返回后面的值;
    val keySet = combine_map.keys
    val key_iter = keySet.iterator  //遍历,迭代map;
    while (key_iter.hasNext){
      val key = key_iter.next
      println(key + ":" + combine_map.get(key).get)
    }
    println(combine_map.apply("brand")) //返回指定键的值，如果不存在返回 Map 的默认方法;
    println(combine_map.contains("test_key")) //如果map中存在指定 key,返回 true，否则返回 false;
    val age_count = combine_map.count(x=>{  //计算满足指定条件的集合元素数量;
      x._1.equals("age")
    })
    println(age_count) //打印结果为1;
    val drop_map = combine_map.drop(1) //返回丢弃最后n个元素新集合;
    println(drop_map) //打印结果为:Map(brand -> apple, sex -> 男);
    println(combine_map.empty) //返回相同类型的空map;
    println(map.equals(map2)) //如果两个 Map 相等(key/value 均相等)，返回true，否则返回false;
    println(combine_map.exists(x => { //判断集合中指定条件的元素是否存在;
      x._2.equals("男")
    }))
    println(combine_map.filter(x=>{  //返回满足指定条件的所有集合; 结果为:Map(brand -> apple);
      x._1.length > 4
    }))
    println(combine_map.filterKeys(x=>{ //返回符合指定条件的不可变 Map;
      x.equals("test_100")
    }))
    println(combine_map.find(x=>{  //查找集合中满足指定条件的第一个元素;
      x._1.equals(x._2)
    }))
    combine_map.foreach(x=>{   //循环map里的所有元素;
      println(x +"------------")
    })
  }
}

2.List操作

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。

2.1Demo1

object Scala_List {
  def main(args:Array[String]):Unit={
    val list=List[String]("hello bjsxt","hello bjsxt","hello shsxt","hello gzsxt")
    val result = list.count(s=>{
     s.equals("hello sdhsxt")
    })
    println(result)
    val result1=list.filter(s=>{
      s.equals("hello bjsxt")
    })
    result1.foreach(println)
     println("以下是循环遍历")
    val result3=list.map(s=>{
      s.split(" ")
    })
    result3.foreach(arr=>{
      arr.foreach(println)
      println("*********************")
    })
    println("????????????????????????????/")
    val result4=list.flatMap(s=>{
      s.split(" ")
    })
    result4.foreach(println)
    println("................................")
    val list1=List[Int](1,2,3,4,4)
    list1.foreach(println)
    println(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;")
    for(elem<-list1){
      println(elem)
    }
  }
}

2.2Demo2

package test
object listDemo {
  def main(args: Array[String]): Unit = {
    val list: List[String] = List("a", "b" ,"a")
    //为列表预添加元素
    println("A" +: list)
    //在列表开头添加元素
    println("c" :: list)
    //在列表开头添加指定列表的元素
    println(List("d","e") ::: list)
    //复制添加元素后列表
    println(list :+ "1")
    //将列表的所有元素添加到 StringBuilder
    val sb = new StringBuilder("f")
    println(list.addString(sb))
    //指定分隔符
    println(list.addString(sb,","))
    //通过列表索引获取元素
    println(list.apply(0))
    //检测列表中是否包含指定的元素
    println(list.contains("a"))
    //将列表的元素复制到数组中,在给定的数组xs中填充该列表的最多为长度(len)元素,从start位置开始。
    val a = Array('a', 'b', 'c')
    val b : Array[Char] = new Array(5)
    a.copyToArray(b,0,1)
    b.foreach(println)
    //去除列表的重复元素,并返回新列表
    println(list.distinct)
    //丢弃前n个元素，并返回新列表
    println(list.drop(1))
    //丢弃最后n个元素，并返回新列表
    println(list.dropRight(1))
    //从左向右丢弃元素，直到条件p不成立
    println(list.dropWhile(_.equals("a")))
    //检测列表是否以指定序列结尾
    println(list.endsWith(Seq("a")))
    //判断是否相等
    println(list.head.equals("a"))
    //判断列表中指定条件的元素是否存在,判断l是否存在某个元素
    println(list.exists(x=> x == "a"))
    //输出符号指定条件的所有元素
    println(list.filter(x=> x.equals("a")))
    //检测所有元素
    println(list.forall(x=> x.startsWith("b")))
    //将函数应用到列表的所有元素
    list.foreach(println)
    //获取列表的第一个元素
    println(list.head)
    //从指定位置 from 开始查找元素第一次出现的位置
    println(list.indexOf("b",0))
    //返回所有元素，除了最后一个
    println(list.init)
    //计算多个集合的交集
    println(list.intersect(Seq("a","b")))
    //检测列表是否为空
    println(list.isEmpty)
    //创建一个新的迭代器来迭代元素
    val it = list.iterator
    while (it.hasNext){
      println(it.next())
    }
    //返回最后一个元素
    println(list.last)
    //在指定的位置 end 开始查找元素最后出现的位置
    println(list.lastIndexOf("b",1))
    //返回列表长度
    println(list.length)
    //通过给定的方法将所有元素重新计算
    list.map(x=> x+"jason").foreach(println)
    //查找最大元素
    println(list.max)
    //查找最小元素
    println(list.min)
    //列表所有元素作为字符串显示
    println(list.mkString)
    //使用分隔符将列表所有元素作为字符串显示
    println(list.mkString(","))
    //列表反转
    println(list.reverse)
    //列表排序
    println(list.sorted)
    //检测列表在指定位置是否包含指定序列
    println(list.startsWith(Seq("a"),1))
    //计算集合元素之和,这个地方必须是int类型,如果是string直接报错
    //println(list.sum)
    //返回所有元素，除了第一个
    println(list.tail)
    //提取列表的前n个元素
    println(list.take(2))
    //提取列表的后n个元素
    println(list.takeRight(1))
    //列表转换为数组
    println(list.toArray)
    //返回缓冲区，包含了列表的所有元素
    println(list.toBuffer)
    //List 转换为 Map
    val arr = Array(("jason", 24), ("jim", 25))
    arr.toMap.foreach(println)
    //List 转换为 Seq
    println(list.toSeq)
    //List 转换为 Set
    println(list.toSet)
    //列表转换为字符串
    println(list.toString())
  }
}

运行结果如下:

List(A, a, b, a)
List(c, a, b, a)
List(d, e, a, b, a)
List(a, b, a, 1)
faba
fabaa,b,a
a
true
a
List(a, b)
List(b, a)
List(a, b)
List(b, a)
true
true
true
List(a, a)
false
a
b
a
a
1
List(a, b)
List(a, b)
false
a
b
a
a
1
3
ajason
bjason
ajason
b
a
aba
a,b,a
List(a, b, a)
List(a, a, b)
false
List(b, a)
List(a, b)
List(a)
[Ljava.lang.String;@51cdd8a
ArrayBuffer(a, b, a)
(jason,24)
(jim,25)
List(a, b, a)
Set(a, b)
List(a, b, a)

3.:: , +:, :+, :::, +++

package test
/**
  * scala中的:: , +:, :+, :::, +++, 等操作;
  */
object listTest {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3)
    // :: 用于的是向队列的头部追加数据,产生新的列表, x::list,x就会添加到list的头部
    println(4 :: list)  //输出: List(4, 1, 2, 3)
    // .:: 这个是list的一个方法;作用和上面的一样,把元素添加到头部位置; list.::(x);
    println( list.:: (5)) //输出: List(5, 1, 2, 3)
    // :+ 用于在list尾部追加元素; list :+ x;
    println(list :+ 6)  //输出: List(1, 2, 3, 6)
    // +: 用于在list的头部添加元素;
    val list2 = "A"+:"B"+:Nil //Nil Nil是一个空的List,定义为List[Nothing]
    println(list2)  //输出: List(A, B)
    // ::: 用于连接两个List类型的集合 list ::: list2
    println(list ::: list2) //输出: List(1, 2, 3, A, B)
    // ++ 用于连接两个集合，list ++ list2
    println(list ++ list2) //输出: List(1, 2, 3, A, B)
  }
}

原文作者：JasonLee’blog