Scala集合

Scala集合

目录

• Scala集合
  • 一、List集合
    • 1、不可变List
      • List集合的基础方法
      • List集合的高级方法：foreach、map、sort、flatMap
    • 2、可变List----ListBuffer
  • 二、Set集合
    • 1、不可变set
    • 2、可变set----HashSet

list: 有序不唯一(有序：指的是插入顺序)

set ： 无序唯一

map： kv结构

tuple： 固定长度的集合

一、List集合

scala中的list 相对于Java，提供了很多实用的方法

list set map array 都有以下方法
      * map
      * flatMap
      * filter
      * foreach
      * groupBy

set 集合不能排序, set map 不能反转

1、不可变List

不可变List：不能够对原集合增删元素

List集合的基础方法

package com.shujia.scala

object Demo19List {
  def main(args: Array[String]): Unit = {
    //定义一个list集合
    val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //获取第一个元素
    println(list.head) //1
    //获取不包含第一个元素的所有元素
    println(list.tail) //List(2, 3, 4, 5, 6, 7, 8, 9)
    //获取最后一个元素
    println(list.last) //9
    //获取前三个元素(从左边取topn)
    println(list.take(3)) // List(1, 2, 3)
    //获取后三个元素(从右边取topn)
    println(list.takeRight(3)) //List(7, 8, 9)
    //通过下标获取元素
    println(list(2)) //3

    //通过一个分隔符将集合拼接成一个字符串(与split功能相反)
    println(list.mkString(\"|\")) // 1|2|3|4|5|6|7|8|9
    println(list.sum) //求和
    println(list.max) //获取最大值
    println(list.min) //获取最小值
    //获取平均值(要转换为double类型)
    println(list.sum / list.length.toDouble) //5.0

    val list2 = List(1, 2, 3, 4, 5, 3, 2, 1)
    //去重，返回一个新的集合
    println(list2.distinct) //List(1, 2, 3, 4, 5)
      
    //反转集合
    println(list.reverse) //List(9, 8, 7, 6, 5, 4, 3, 2, 1)
    //删除一个元素，不改变原集合
    println(list.drop(1)) //List(2, 3, 4, 5, 6, 7, 8, 9)
  }
}

List集合的高级方法：foreach、map、sort、flatMap

• foreach

package com.shujia.scala

object Demo19List {
  def main(args: Array[String]): Unit = {
    //定义一个list集合
    val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
      
    /**
     * foreach: 循环集合中元素，一个一个传递给后面的函数
     */
    var sum = 0
    list.foreach(i => {
      sum += i
    })
    println(sum)  //45
  }
}

• map

	/**
     * map ：循环集合中的元素一个一个传递给后面的函数，
     *       最后将函数的返回值构建成一个新的集合返回
     */
    val list2: List[Int] = list.map((i: Int) => i + 2)
    println(list2) //List(3, 4, 5, 6, 7, 8, 9, 10, 11)
    //改变集合中所有元素的类型
    //将集合中元素的类型转换为String类型(有返回值)
    val strs: List[String] = list.map((i: Int) => i.toString + \"a\")
    println(strs) //List(1a, 2a, 3a, 4a, 5a, 6a, 7a, 8a, 9a)

• sort

    /**
     * sort排序(默认是升序)
     * (1)sortBy: 通过一个字段进行排序（参数是个函数）
     * (2)sortWith: 指定一个排序规则（参数是指定规则），返回一个集合
     */

    val list3 = List(2, 5, 1, 6, 2, 1, 3, 4)
    //将集合元素排序
    val sortList: List[Int] = list3.sortBy((i: Int) => i)
    println(sortList) //List(1, 1, 2, 2, 3, 4, 5, 6)
      
    //sortWith: 指定一个排序规则（参数是指定规则），返回一个集合
    //升序
    val sortList2: List[Int] = list.sortWith((i: Int, j: Int) => i < j)
    println(sortList2)  //List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //降序
    val sortList3: List[Int] = list.sortWith((i: Int, j: Int) => i > j)
    println(sortList3)  //List(9, 8, 7, 6, 5, 4, 3, 2, 1) 

sortBy应用举例

     /**
      * 读取学生数据，按照年龄排序
      */

    //读取文件.获取行数据.转成集合
    val students: List[String] = Source.fromFile(\"data/students.txt\").getLines().toList
	println(students) 
	//List(1500100001,施笑槐,22,女,文科六班, 1500100002,吕金鹏,24,男,文科六班...)

    //按年龄排序(默认是升序)
	//stu.split(\",\")(2).toInt:按照逗号切分，获取年龄并转换为Int类型
    val studentSort: List[String] = students.sortBy((stu: String) => stu.split(\",\")(2).toInt)
    studentSort.foreach(println)

//执行结果:
        ...
        1500100985,申飞珍,21,女,文科一班
        1500100993,衡从蕾,21,女,理科二班
        1500100997,陶敬曦,21,男,理科六班
        1500100001,施笑槐,22,女,文科六班
        1500100003,单乐蕊,22,女,理科六班
        1500100005,宣谷芹,22,女,理科五班
        1500100008,符半双,22,女,理科六班
        1500100021,连鸿晖,22,男,理科六班
        1500100024,湛慕卉,22,女,文科二班
        ...
//如果想要排序为降序，-stu.split(\",\")(2).toInt，前面加个负号即可

• flatMap

  map：进来一行，返回一行

  flatMap：进来一行，返回多行（炸开后返回）

 //定义一个集合
val lines = List(\"java,spark\", \"java,hadoop\", \"java,scala,hive\", \"bhase,hadoop,scala\")

println(lines)  
//List(java,spark, java,hadoop, java,scala,hive, bhase,hadoop,scala)
lines.foreach(println)
//结果
    java,spark
    java,hadoop
    java,scala,hive
    bhase,hadoop,scala

获取集合中的每一个单词，一个单词一行(Java的方式)

	//Java的方式
    for (line <- lines) {
      val arr: Array[String] = line.split(\",\")  //逗号分隔，返回一个数组
      //遍历数组
      for (word <- arr) {
        println(word)
      }
    }
//执行结果：
        java
        spark
        java
        hadoop
        java
        scala
        hive
        bhase
        hadoop
        scala

获取集合中的每一个单词，一个单词一行(数组形式)

//定义一个集合
val lines = List(\"java,spark\", \"java,hadoop\", \"java,scala,hive\", \"bhase,hadoop,scala\")
	//创建一个数组
	val words = new util.ArrayList[String]()
    for (line <- lines) {
      val split: Array[String] = line.split(\",\")
      for (word <- split) {
        words.add(word)	//将遍历出来的单词添加到数组
      }
    }
println(words) 
//[java, spark, java, hadoop, java, scala, hive, bhase, hadoop, scala]

获取集合中的每一个单词，一个单词一行(Scala形式)

 flatMap: 将集合中的元素一个一个传递给后面的函数，传入一行返回多行
 flatMap 分两步
     1、先进行一次map操作
     2、将函数返回的数组拆分出来，构建成一个新的集合

//定义一个集合
val lines = List(\"java,spark\", \"java,hadoop\", \"java,scala,hive\", \"bhase,hadoop,scala\")

 val words2: List[String] = lines.flatMap((line: String) => line.split(\",\"))
    println(words2)
    //List(java, spark, java, hadoop, java, scala, hive, bhase, hadoop, scala)

2、可变List----ListBuffer

object Demo19List {
  def main(args: Array[String]): Unit = {
      //创建一个可变的List集合（ListBuffer）
       val listBuffer = new ListBuffer[String]()
      
    //增加元素
    listBuffer += \"java\"
    println(listBuffer) //ListBuffer(java)

    //增加多个元素
    listBuffer ++= List(\"scala\", \"hadoop\", \"java\")
    println(listBuffer)//ListBuffer(java, scala, hadoop, java)

    //删除一个元素
    listBuffer -= \"java\"
    println(listBuffer)//ListBuffer(scala, hadoop, java)

    //删除多个元素
    listBuffer --= List(\"hadoop\", \"scala\")
    println(listBuffer)//ListBuffer(java)

    //通过下标修改元素
    listBuffer.update(0, \"hadoop\")
    println(listBuffer)//ListBuffer(hadoop)

    //通过下标删除元素
    listBuffer.remove(0)
    println(listBuffer)//ListBuffer()
  }
}

二、Set集合

1、不可变set

package com.shujia.scala

object Demo20 {
  def main(args: Array[String]): Unit = {
    //定义一个set集合
    val set = Set(1, 2, 3, 4, 5, 6, 7, 8, 1, 2)
    println(set) //Set(5, 1, 6, 2, 7, 3, 8, 4),自动去重，排列无序

    //常用方法(Set集合没有元素反转方法，List集合有)
    println(set.head) //5
    println(set.tail) //Set(1, 6, 2, 7, 3, 8, 4)
    println(set.last) //4
    println(set.sum)  //36
    println(set.max)  //8
    println(set.min)  //1

    /**
     * filter: 过滤
     *         将集合中的元素一个一个传递给后面的函数，
     *         函数返回true保留数据，函数返回false过滤数据。
     *         （这个方法List集合也有）
     */
      //取出集合中的奇数
    val filterSet: Set[Int] = set.filter((i: Int) => i % 2 == 1)
    println(filterSet)  //Set(5, 1, 7, 3)

    /**
     * 交集 &
     * 并集 |
     * 差集 &~
     * List集合无该方法
     */
    val s1 = Set(1, 2, 3, 4, 5, 6)
    val s2 = Set(3, 4, 5, 6, 7, 8, 9)
    println(s1 & s2) //Set(5, 6, 3, 4)
    println(s1 | s2) //Set(5, 1, 6, 9, 2, 7, 3, 8, 4)
    println(s1 &~ s2) //Set(1, 2)
  }
}

2、可变set----HashSet

可变set：可以对原集合里的元素进行增删改

object Demo20 {
  def main(args: Array[String]): Unit = {
      //创建一个可变的set集合(HashSet)
    val hashSet = new mutable.HashSet[String]()
    //增加元素的两种方式
    hashSet.add(\"java\")
    hashSet += \"scala\"
    println(hashSet) //Set(java, scala)

    //移除元素的两种方式
    hashSet.remove(\"java\")
    hashSet -= \"scala\"
    println(hashSet) //Set()

    //可变集合转换成不可变集合
    val set2: Set[String] = hashSet.toSet
  }
}

来源：https://www.cnblogs.com/saowei/p/15972238.html
本站部分图文来源于网络，如有侵权请联系删除。