Scala之Array / List 数组和 Set 集合的定义,方法,,遍历(4)
一 集合
scala 中的集合分两种 ,可变集合和不可变集合 ,不可变集合可以安全的并发访问 .
集合的类主要这以下两个包中 :
1) 可变集合包 : scala.collection.mutable
2) 不可变集合包 : scala.collection.immutable
scala 默认使用的是不可变集合 , 因此使用可变的集合需要导入可变集合的包
scala 的集合主要分为三大类
- Seq 序列
- Set 不重复集
- Map 键值映射集
注 : 所有的集合都继承自 Iterator 迭代器这个特质
1 序列
许多数据结构是序列型的 ,元素可以按照特定的顺序访问 ,如元素的插入顺序或其他特定顺序 .
collection Seq 是所有可变或不可变序列类型的抽象 ,其collection.mutable.Seq及collection.immutable.Seq分别对应可变和不
可变序列。Array ,String ,List 都属于序列 .
1.1 Array
1.1.1 不可变数组 Array 的定义
def main(args: Array[String]): Unit = {
定义一个通用数组 没有执行数据类型 , 可以存储任意类型
val arr1 = Array("JIM", 12, 12.22, true)
指定泛型 约束数组中的数据类型 只能写泛型的子类
val arr2 = Array[Any]("JIM", 12, 12.22, true)
定义数组 定义数据类型 只能存储Int类型
val arr3 = Array[Int](1, 2, 3, 4)
}1.1.2 不可变数组 Array 方法的使用
val arr = Array(1,3,5,7,9,2,6,4)
将数组的每个元素都取出来 ,并且按照指定的 ":" 符合拼接起来
println(arr.mkString(":")) //1:2:3:4:5
数组中的最大和最小值
val min: Int = arr.min
val max: Int = arr.max
首个元素
val head: Int = arr.head
最后一个元素
val last: Int = arr.last
将数组转换成List集合
val list: List[Int] = arr.toList
获取和后面数组中不同的元素
val diff: Array[Int] = arr.diff(Array(1,111,222))
求数组元素的和
val sum: Int = arr.sum
修改角标index=1位置的元素,将其改为100
arr.update(1,100)
取出数组中的前n个元素
val arr3: Array[Int] = arr.take(3)
后面添加一个元素 生成 新的数组
val arr2: Array[Int] = arr.:+(11)
后面添加一个数组
val res = arr:++arr3
统计符合条件的个数
val i: Int = arr.count(_>2)
将到如的包改为 : import scala.collection._
将不可变数组转换成可变数组
val buffer: mutable.Buffer[Int] = arr.toBuffer
定义一个数组(不指定数据类型 ,编译器可以自动推导)
var arr = Array(1,2,3,4)
----------------------数组的方法的调用--------------------
println(arr.length) // 4 数组的长度
println("-----------更新指定角标的元素,对数组中指定元素重新赋值-------------")
arr.update(0, 110)
arr.foreach(println) // 110 2 3 4 将指定角标的元素更新为新的元素
println("------------数组的排序 sorted ,默认是升序--------------")
val sortedArr = arr.sorted
sorted.foreach(println(_)) // 2 3 4 110
println("--------------数组反转 reverse-------------------------")
val reverseArr = sortedArr.reverse
reverseArr.foreach(println(_)) // 110 4 3 21.1.3 不可变数组 Array 的4种遍历方法
定义一个数组
var arr = Array(1,2,3,4)
---------------------遍历数组的 4 种方法---------------
第一种方法----for
for (elem <- arr) {
println(elem) // 1 2 3 4
}
第二种方法----根据角标---until-->前包后不包
for(index <- 0 until arr.length){
println(arr(index)) // 1 2 3 4 打印的是arr的角标对应的元素
}
for(index <- 0 to arr.length-1){ --to-->前包后也包
println(arr(index)) // 1 2 3 4
}
第三种方法-----foreach----仅仅用于打印--------------
arr.foreach(e=>println(e)) // 1 2 3 4 e:代表每一个元素
arr.foreach(println) // 1 2 3 4 指向的是每一个元素 ,e可以省略
arr.foreach(println(_)) // 1 2 3 4 _ :代表 e=>e 每一个元素----常用
第四种方法-----map--可以对元素进行改变----会取出每个元素进行操作
arr.map(e=>println(e)) // 1 2 3 4
arr.map(println(_)) // 1 2 3 4 _ :代表每一个元素
arr.map(e=>println(e*10)) // 10 20 30 40 1.1.4 可变数组 Array 的定义和方法的使用
导包 : import scala.collection.mutable.ArrayBuffer
def main(args: Array[String]): Unit = {
可变数组的定义 长度可变的
val arr: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)
数组长度
println(arr.length) // 5
在数组后面追加元素----可变的数组才有这个方法
arr.append(6, 8)
arr.foreach(println(_)) //1 2 3 4 5 6 8
在 index为0 前面插入新的值
arr.insert(0,111)
arr.map((println(_))) // 111 1 2 3 4 5 6 8
移除指定角标的元素
arr.remove(0)
移除从指定角标0开始的2个元素
arr.remove(0,2)
arr.foreach(println)
删除从左边开始的3个元素
arr.drop(3).foreach(println)
清空数组
arr.clear()
判断是否为空
println(arr.isEmpty) // true
重新定义一个数组
val arr2 = Array(11, 22, 33)
在 index为0 的元素前插入一个数组
arr.insertAll(0, arr2)
arr.foreach(println(_)) //11 22 33 1 2 3 4 5
在 arr数组后面加上一个新的数组
arr.++=(Array(1,1,1,1))
arr.foreach(println) // 1 2 3 4 5 1 1 1 1
将数组的每个元素取出并用":"拼接起来
println(arr.mkString(":")) //1:2:3:4:5
}1.2 List
1.2.1 不可变的 List
导包 : import scala.collection.immutable
---------------------------------list的定义---------------------
不可变的List集合 数据不允许被修改
val ls1 = List("SCALA", "HDP", "SPARK" , 12 , 34)
向Nil空队列中添加元素组成新的队列
val ls2 = "HIVE" :: "MYSQL" :: "HBASE" :: Nil
获取指定位置元素
ls1(0)
获取集合的长度
ls1.length
ls1.size
过滤出符合条件的元素并打印出来------将开头是"S"的元素找出来并打印----
ls1.filter(_.startWith("S")).foreach(println)
添加一个元素生成新的List
val ls3 = ls1 :+ "PYTHON"
合并两个集合, 生成新的集合------两个集合的合并 : ++
val ls4 = ls1 ++ ls2
将ls1集合中与ls2相同的元素去掉,生成一个新的集合
ls1.diff(ls2)
旧的集合是没有改变的
ls1.foreach(println)
获取前两个元素,组成新的List
ls1.take(2)
将一个集合切割分为两个集合
ls4.split(2)
-------------------------------集合的排序-------------------------
val list = List(3,4,2,5,8,7)
集合的排序,默认是升序 ,用于数组元素是 Int 类型
list.sorted
集合的排序,根据ASCLL码排序,元素是 Int String..类型都可以
list.sortWith(x1,x2)=>x1 > x2 ----降序
list.sortWith(x1,x2)=>x1 < x2 ----升序 将list集合的元素取出来并且转为大写
list.map(_.toUpperCase).foreach(println)
定义一个list 集合---------------------1-----另外创建一个 Userbean------
val user1 = new User(21, "zss");
val user2 = new User(23, "lss");
val user3 = new User(19, "lss");
val usersList = List(user1, user2, user3)
根据指定的某个元素进行排序
users.sortBy(user=> -user.getAge).foreach(println)
根据指定的某个元素进行去重
users.distinctBy(user=>user.getName).foreach(println)
根据指定的某个元素 ,获取到这个元素的最小值
users.minBy(user=>user.getAge)
定义一个list 集合---------------------2
val lista = List("emen","shls","wud","mingj","gaib")
val listb = List("mjst","swk","zsf","zwj")
让lista 和 listb 两个数组组成对偶元组,map集合-----------------zip 拉链操作-----
val values: List[(String, String)] = lista.zip(listb)
遍历打印
values.foreach(println(_)) ----(emen,mjst) (shls,swk) (wud,zsf) (mingj,zwj)
取出所有的key值
values.foreach(tp=>println(tp._1)) --- emen shls wud mingj
取出所有的value值
values.foreach(tp=>println(tp._2)) --- mjst swk zsf zwj 1.2.2 可变的 list
导包 : import scala.collection.mutable.ListBuffer
-------------定义两个可变的 list 集合-----------
val list1 = ListBuffer(1,2,3)
val list2 = ListBuffer(4,5,6)
在可变 list 集合后面添加一个元素
list1 += 9
list1.foreach(println(_)) // 1 2 3 9
在可变 list 集合中减去一个指定的元素
list1 -= 9
list1.foreach(println(_)) // 1 2 3
在 list1 中并入一个集合
list1 ++= list2
list1.foreach(println(_)) // 1 2 3 4 5 6
在 list1 中去掉一个集合
list1 --= list2
list1.foreach(println(_)) // 1 2 3
合并两个集合
val list3 = list1 ++ list2
list1.size
list1.length
-----------------转换成不可变的 list 集合------------
val list = list1.toList1.3 set
set 和 list 的最大的区别在于 set 中不可以存储重复数据 ,通常使用 set 来实现元素的去重
set 集合也分为可变 set 和不可变的 set ,使用包名来区分可变和不可变
不可变 set 集合
val s = Set(1, 2, 3, 4, 4, 5)
s.exists(x=>x>1)
可变 set 集合----------------方法体内导包----------------
import scala.collection._
val set = new mutable.HashSet[Int]()
set.add(12)
set += 21
set.remove(12)
set.foreach(println)