1.列表
不可变List
(1)List默认为不可变集合
(2)创建一个List(数据有顺序,可重复)
(3)遍历List
(4)List增加数据
(5)集合间合并:将一个整体拆成一个一个的个体,称为扁平化
(6)取指定数据
(7)空集合Nil
部分常用操作
package com.bigdata.scala
object DemoList {
def main(args: Array[String]): Unit = {
//列表:列表中元素可以重复,不需要唯一,有序
//创建列表
val list01: List[Int] = List[Int](1, 2, 3, 4, 5, 6, 2, 3, 1)
println(list01.head)
println(list01.tail)
println(list01.take(2))
println(list01.min)
println(list01.sum)
println(list01.distinct) //去重
println(list01.sorted)
println(list01.contains(3))
//list常用操作:map,flatMap,filter,groupby,sort相关,foreach
//map:对List的每一条数据进行处理,传入一条,返回一条
println(list01.map(i => i * i))
//filter:过滤得到偶数
println(list01.filter(int => int % 2 == 0))
//flatMap:对数据进行扁平化处理,传入一条数据,返回一个集合
val list02: List[String] = List("python,mysql,java", "hadoop,redis,clickhouse", "hbase,hive,flink")
list02.flatMap(line=>line.split(",").toList).foreach(println)
//groupby,分完组后返回map类型
val list03: List[List[String]] = List(
List("01", "zs1", "20", "文科一班")
, List("02", "zs2", "20", "文科一班")
, List("03", "zs3", "22", "理科一班")
, List("04", "zs4", "22", "理科一班")
)
list03.groupBy(list => list(3)).map(kv=>{
val clazz=kv._1
val num=kv._2.length
println(clazz,num)
})
// sort相关的
/**
* sorted:对List中所有的元素按照从小到大的顺序进行排列
* sortBy:按照指定的字段进行排序
* sortWith:按照指定的规则进行排序
*
*/
case class SortStu(id:String,name:String,age:Int)
val stuList: List[SortStu] = List[SortStu](
SortStu("001", "zs", 20)
, SortStu("003", "ls", 22)
, SortStu("002", "ww", 21)
, SortStu("004", "ww", 20)
, SortStu("005", "ww", 20)
)
// 按照age进行排序
stuList.sortBy(s => s.age).foreach(println) // 从小到大
stuList.sortBy(s => -s.age).foreach(println) // 从大到小
println("=" * 50)
// 先按照age从小到大进行排序,如果age相同 再按照id从大到小进行排序
stuList.sortWith((stu01,stu02)=>{
if(stu01.age==stu02.age){
if(stu01.id>stu02.id){
true
}else{
false
}
}else{
stu01.age<stu02.age
}
}).foreach(println)
}
}
可变list
val lb: ListBuffer[Int] = ListBuffer[Int](1, 2, 4, 3, 4, 3)
println(lb)
lb.append(7)
lb.append(8)
lb+=9 //将9添加进去
lb.insert(2,3) //在第二个位置加3
lb-=3 //删除第一个出现的3
lb.remove(4) //删除第几个位置
lb(4)=100//修改
lb.update(4,1000) //修改
println(lb)
2.Tuple元组
不可变,有序,元素不唯一可以重复 最大长度22
package com.bigdata.scala
object DemoTuple {
def main(args: Array[String]): Unit = {
/**
* Tuple:元组
* 不可变,有序,元素不唯一可以重复
* 最大长度22
* */
//创建元组
val tuple: (Int, Int, Int, Int, Int) = Tuple5(1, 2, 3, 4, 5)
println(tuple._3)
val tuple1: (Int, Int, Int) = (1, 2, 3)
//一元组的创建,只能用Tuple1
val tuple2: Tuple1[Int] = Tuple1(1)
}
}
3.Set集合
元素是唯一的不会重复,会自动进行去重
不可变,无序的
import scala.collection.mutable
object Demo16Set {
def main(args: Array[String]): Unit = {
/**
* Set:集合
* 元素是唯一的不会重复,会自动进行去重
* 不可变,无序的
*/
// 定义一个Set
val s1: Set[Int] = Set[Int](1, 2, 2, 2, 2, 4, 4, 4, 3, 5, 4, 0)
println(s1)
// 集合的运算
val set01: Set[Int] = Set[Int](1, 2, 3, 4, 5, 6)
val set02: Set[Int] = Set[Int](4, 5, 6, 7, 8, 9)
// 交集、并集、差集等等
println(set01 & set02)
println(set01 | set02)
println(set01.diff(set02))
println(set02.diff(set01))
// 可变的Set:
val mSet01: mutable.Set[Int] = mutable.Set[Int](1, 2, 2, 2, 2, 4, 4, 4, 3, 5, 4, 0)
println(mSet01)
// 增加
mSet01.add(5)
mSet01.add(6)
mSet01.add(-1)
mSet01 += 7
println(mSet01)
// 删除
mSet01.remove(-1)
mSet01.remove(2)
mSet01 -= 1
println(mSet01)
// 修改:无直接修改的方法,可以先remove再add来实现修改
mSet01.remove(7)
mSet01.add(8)
println(mSet01)
}
}
4.map字典
1、不可变
2、Map中的每个元素都是KV形式
3、Map中的Key是不会重复的
4、无序的
适用于需要查询的场景
package com.bigdata.scala
import scala.collection.mutable
object DemoMap {
def main(args: Array[String]): Unit = {
//key值唯一
val map: Map[String, Int] = Map[String, Int](("k1", 1), ("k2", 2), ("k3", 3), "k4" -> 4)
//过滤
map.filter(kv => {
val value: Int = kv._2
value > 2
}).foreach(println)
//通过key获取Value,获取不到返回-1
println(map.getOrElse("k1", -1))
println(map.getOrElse("kk1", -1))
/**
* get方法会返回一个Option类型的对象
*
* Option类型就两个子类:Some、None
* 有值的情况下就将值包装成Some对象进行返回
* 无值的情况就返回None
*
* 一般用于处理模棱两可的情况,有可能有值,也有可能没值
* 所以就返回一个Option类型引起开发者注意
* 否则就容易引起空指针异常的问题
*/
println(map.get("k1"))
println(map.get("kk1"))
val maybeInt: Option[Int] = map.get("kk1")
// 结合Scala中模式匹配match进行后续处理
maybeInt match {
case Some(v) =>
println(v)
case None =>
println("Key不存在")
}
//可变的map
val mMap01: mutable.Map[String, Int] = mutable.Map[String, Int](("k1", 1), ("k2", 2), ("k3", 3), "k4" -> 4)
//增
mMap01.put("k5", 5)
mMap01.put("k2", 22) //存在即覆盖,相当于修改
mMap01 += Tuple2("k6", 6)
println(mMap01)
//删
mMap01-="k2"
mMap01.remove("k1")
println(mMap01)
//改
mMap01("k3")=33
println(mMap01)
}
}