Scala中常见集合的使用---代码详解

1.List集合的使用及创建

object ListDemo1 {
  def main(args: Array[String]): Unit = {
    //创建一个List
    val list: List[Int] = List(1,2,3,4,5)
    //list的组成：head、tail
    //list=head（element）+tail（element）、除了头部以外的元素都是尾
    println(s"head:${list.head}")
    println(s"tail:${list.tail}")

    //todo:如果list中只有一个元素，有头，tail是空的集合list
    val list1 = List(1)
    println(s"head:${list1.head}")
    println(s"tail:${list1.tail}")

    /**
      * list创建的第二种方式
      * ::，从右往左运算
      */
    val list2 = 1::Nil //Nil.::(1)
    println("list创建的第二种方式")
    //将list转换成字符串

    println(list2.mkString(","))

    //头插法
    val list3 = 1::2::3::4::5::6::Nil
    println("list3:"+list3.mkString(","))
    //list3:1,2,3,4,5
   // -----------可变的集合-----------
    var listBuffer =ListBuffer[Int]()
    //添加元素
    listBuffer +=1
    listBuffer ++= List(111,222)
    println("listBuffer:"+listBuffer.mkString(","))

    //将可变list转化成不可变list
    val list5 = listBuffer.toList

    //判定 列表是否为空
    println(list5.isEmpty)

    //判定 列表是否存在某个元素
    println(list5.contains(222))
  }
}

2.List中map与reduce的使用与介绍

object ListFunDemo2 {
  def main(args: Array[String]): Unit = {
    //创建list集合
    val list: List[Int] =(1 to 10).toList

    /**
      * final def map[B]( f: (A) ⇒ B): List[B]
      * map() :f:(A)=>B
      * 将集合中的每个元素取出 传递给 函数f 进行调用，返回结果
      * 将每个元素 交给 一个 函数处理，返回结果
      */
    val maplist = list.map((item)=>{
      item*2
    })
    //上述简写
    val maplist1 = list.map(_ * 2)
    println(maplist1.mkString(","))
    //list.map(_*2).foreach(println)
    /**
      * 案例：分割单词
      */
    val lineList = List("hadoop hive spark scala","spark hive habase",
      "hive spark java")
val lineListResult: List[Array[String]] =lineList.map(line=>line.split(" "))
println("---------lineListResult---------")
    lineListResult.foreach(line=>{
      println("--------")
      line.foreach(println)
    })

    /**
      * 压平、
      * final def
      * flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): List[B]
      */
val lineListResult2: List[String] = lineList.flatMap(line=>line.split(" "))
    lineListResult2.foreach(print)
    println()

    /**
      * def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
      * filter（）：p:(A)=>Boolean
      * 针对集合中的每一个元素，调用p函数，如果返回true保留
      * 返回false，过滤掉该元素
      */
    println("------filterList--------")
   val filterList: List[Int] = list.filter((item)=>{
     if(item%2==0) true else false
   })
    val filterList1: List[Int] =list.filter((item)=>{
      item%2==0
    })

    val filterList2=list.filter(_%2==0)
    println(filterList2.mkString(","))

    /**
      * def groupBy[K](f: (A) ⇒ K): Map[K, List[A]
      * groupBy() : f: (A) ⇒ K
      * K表示：分组的类别，比如数字分组，奇数和偶数，奇数：1 偶数：0
      *key       value
      * 1          list（1,3,5）
      * 2           list（2,4,6）
      */
  val listgroup=List(1,1,3,4,6,3)
    val groupMap = listgroup.groupBy(item=>item)
    groupMap.foreach(println)

    /**
      * 排序函数
      * sorted
      * 默认情况下，依据集合list中的元素，自然排序规则进行 升序排序
      * sortBy:指定元素排序规则
      * sortWith ：主要针对集合中元素，如果复杂的数据类型，指定排序规则
      *
      */
val list2 = List(12,99,33,89,10,45,67)
    //sorted,默认安装 元素的自然 升序排序
    val sortedList = list2.sorted
    println(sortedList.mkString(","))

    //def sortBy[B](f: A => B)
    println(list2.sortBy(item => -item).mkString(","))
 //上面的简写
    println(list2.sortBy(-_).mkString(","))

//def sortWith(lt: (A, A) => Boolean):
    println(list2.sortWith((x1,x2)=> x1>x2).mkString(","))//降序
    println(list2.sortWith((x1,x2)=> x1<x2).mkString(","))//升序
//简写
    println(list2.sortWith(_>_).mkString(","))//降序
    println(list2.sortWith(_<_).mkString(","))//升序
    /**
      *def reduce( op: (A1, A1) => A1 ): A1 = reduceLeft(op)
      * op:(A1, A1)=>A1
      * reduce函数中
      * op函数要求
      * 第一点、参数和返回值类型要一致
      * 第二点、2个参数
      * reduce
      * Hadoop MapReduce 框架中，reduce代表的是聚合
      * 解释参数含义
      * 第一个参数X1:
      * 可以理解为 聚合时的 临时变量 ，初始值为 head
      * 第二个参数X2  tail集合中的每一个元素，对于list来讲，是从第二个元素开始
      */
    //List(12,99,33,89,10,45,67)
    val reduceResult: Int = list2.reduce((x1, x2)=>{
      println(s"x1:$x1    x2:$x2")
      x1+x2
    })
println(reduceResult)
val reduceResult1 = list2.reduceRight((x1,x2)=>{
  println(s"x1:$x1   x2:$x2")
  x1+x2
})
println(reduceResult1)

  }

}

3.Tuple（元组）的创建与使用

object Tuple0Demo3 {
  def main(args: Array[String]): Unit = {

    //数组中存储不同类型的值
    val arr: Array[Any] =Array(10,20.00,"spark")

    val first: Any =arr(0)
    //数据类型转换：父类可以转换为子类强制转换
    val intValue: Int = first.asInstanceOf[Int]
    println(intValue)

    //元组
    val tuple3: (Int, Double, String) = (10,20.00,"spark") //有三个元素，称为三元组

    println(s"first:${tuple3._1},second:${tuple3._2},third:${tuple3._3}")

    //二元组->(key,value) 对
    val tuple2: (Int, Double) =(3,1.5)
    println(s"key:${tuple2._1},value:${tuple2._2}")

    //元组可以嵌套
    val xx: (Int, (String, Int)) = (15,("xx",18))
    println(xx)
    //swap:交互key和value的值
    val t2 = tuple2.swap
    println(t2)

    //创建二元组的第二种方式
    val tup: (String, String) ="name"->"zhangsan" //隐式转换
    println(s"key=${tup._1} value =${tup._2}")
  }

}

4.scala中map的基本使用

/**
  * scala中map的基本使用
  * map集合中的数据类型其实就是  二元组 （key value）对
  */
object MapDemo4 {
  def main(args: Array[String]): Unit = {
    //创建不可变的map
    val map: Map[String, Int] = Map("huadian"-> 10,"spark"-> 2)
    println(map.mkString(","))
//创建map的第二种方式
    val map2: Map[String, Int] = Map(("huadian",1),("spark",1),("hive",1))

    //将Map集合转成列表List
    val list: List[(String, Int)] = map2.toList
    println(list.mkString("|||"))

    //如何获取map集合中元素
    //方式一：map（key）
    println(s"huadian->${map2("huadian")}")
    //方式二：map.get(key)
    println(s"huadian->${map2.get("huadian").get}")
    //方式三：def getOrElse[B1 >: B](key: A, default: => B1): B1
    println(s"huadian111->${map2.getOrElse("huadian111",10)}")

    /**
      * 遍历map中的数据
      */
    for((key,value)<-map2){
      println(s"key:$key  value:$value")
    }
    println("map2.foreach")
    map2.foreach(item=>{
      println(s"key:${item._1} value:${item._2}")
    })
 map2.foreach(item=>println(s"key:${item._1} value:${item._2}"))

    for((key,_)<- map2) println("keyS:"+key)
    for((_,value)<- map2) println("values:"+value)

    /**
      * 可变map
      */
import scala.collection.mutable
    val map3 = mutable.Map[String,Int]()
    map3 +="A"->1
    val t2 =("B"->2)
    map3 +=t2
    map3 ++= Map("C"->3,"D"->4)
    println("------------map3----------")
map3.foreach(item=>println(s"key:${item._1}  value:${item._2}"))

    //转成不可变Map
    val map4 = map3.toMap
    map4.foreach(println)
    //def exists(p: A => Boolean): Boolean
    //集合中是否有元素 满足 函数 p的要求
    //判定集合中是否存在  值是偶数

    val result =map4.exists(tuple=>tuple._2%2==0)
    println(result)

  }
}

5.set集合的使用

object SetDemo5 {
  def main(args: Array[String]): Unit = {

    /**
      * 对于set和Map来讲，可变和不可变的，类名名称相同，只是在不同的包下面
      * 使用场景：去重，使用set存储数据
      */

    //不可变的集合，无序不重复
    val set=Set(1,2,3,4,5,1,2,3,4,5,-10)
    println(set.mkString(","))

   //max和min获取集合中最大最小值，里面存储的元素需要，具有可比性（比较器）
    println(s"max=${set.max}")
    println(s"min=${set.min}")

    //def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A
    //maxBy类似sortBy，指定排序规则
    val xx = set.maxBy(x=>Math.abs(x))
    println(xx)

    //对于不可变的集合来说，也可以像其中，添加、删除元素，但是得到的是一个新的集合
    val newSet = set+10
    println(set.mkString(","))
    println(newSet.mkString(","))

    /**
      * 可变set
      * 我们需要手动导包
      */

    import scala.collection.mutable
    var set2 = mutable.Set[Int]()

    //添加元素
    set2 +=1
    set2 ++=Set(2,3,4)
    set2 ++=List(5,6,7)

    println("----set2----")
    //将可变set转换成不可变
    set2.toSet[Int].foreach(print)

  //将set转换成List
    println(set2.toList.mkString(","))
  }

}

6.scala中将JAVA集合实例对象转换成Scala类中的实例对象，convert的使用

/**
  * scala中如何将JAVA集合实例对象转换成Scala类中的实例对象
  * JavaConverters
  */
object ConvertToScalaDemo6 {
  def main(args: Array[String]): Unit = {
    //定义JAVA中的map实例对象
    val hashMap: util.HashMap[String, Int] = new util.HashMap[String,Int]()
 hashMap.put("spark",2)
 hashMap.put("hive",5)
 hashMap.put("hadoop",6)
    import scala.collection.JavaConverters._
    val map: mutable.Map[String, Int] = hashMap.asScala
    map.foreach(tuple=>println(s"key:${tuple._1} value:${tuple._2}"))

  }
}

以上是作为初学Scala的小白的我写的一些demo，希望可以帮助像我一样是初学的人。