直接使用java集合
//你是一个javacoder
val listJava = new util.LinkedList[String]()
listJava.add("hello")
数组
//Java中泛型是<> scala中是[]，所以数组用（n）//val 约等于 final 不可变描述的是val指定的引用的值（值：字面值，地址）
val arr01 = Array[Int](1,2,3,4) // 数组初始化
arr01(1)=99// 修改数据元素值
println(arr01(0)) // 打印数组数据for (elem <- arr01) { // for循环输出数组元素
println(elem)
}
arr01.foreach(println) //更简单的遍历元素
集合List//scala中collections中有个2个包：immutable、mutable，默认的是不可变的immutable
val list01 = List(1,2,3,4,5,4,3,2,1) // 不可变的集合for (elem <- list01) {
println(elem)
}
list01.foreach(println)
val list02 = new ListBuffer[Int]() // 可变的集合
list02.+=(33)
list02.+=(34)
list02.+=(35)
list02.foreach(println) // 遍历打印集合元素
集合set
val set01: Set[Int] = Set(1,2,3,4,2,1) // 不可变的集合for (elem <- set01) {
println(elem)
}
set01.foreach(println)
import scala.collection.mutable.Set// 指出包名时，在下面的Set都是引用的这个包下面的
val set02: mutable.Set[Int] = Set(11,22,33,44,11)
set02.add(88)
set02.foreach(println)
val set03: Predef.Set[Int] = scala.collection.immutable.Set(33,44,22,11) // 直接在集合上加包名来指定引用的对象
Tuple集合
val t2 = new Tuple2(11,"sdfsdf") //2元素的Tuple2 在scala描绘的是K,V
val t2 = (11,"sdfsdf") //2元素的Tuple2 在scala描绘的是K,V
val t3 = Tuple3(22,"sdfsdf",'s')
val t4: (Int, Int, Int, Int) = (1,2,3,4)
val t22: ((Int, Int) => Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int) = ( (a:Int,b:Int)=>a+b+8 ,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,4)
println(t2._1) //取元素
println(t4._3)
//val i: Int = t22._1(8)//println(i)
println(t22._1)
val tIter: Iterator[Any] = t22.productIterator //迭代器遍历元素while(tIter.hasNext){
println(tIter.next())
}
集合Map
val map01: Map[String, Int] = Map( ("a",33) , "b"->22 ,("c",3434),("a",3333) )
val keys: Iterable[String] = map01.keys
//option: none some
println(map01.get("a").get) 输出33//println(map01.get("w").get) null指针异常
println(map01.get("a").getOrElse("hello world")) // 获取值
println(map01.get("w").getOrElse("hello world")) // 获取值for (elem <- keys) {
println(s"key: $elem value: ${map01.get(elem).get}")
}
val map02: mutable.Map[String, Int] = scala.collection.mutable.Map(("a",11),("b",22)) //创建可变的集合
map02.put("c",22)
艺术
val list = List(1,2,3,4,5,6)
list.foreach(println)
val listMap: List[Int] = list.map( (x:Int) => x+10 ) //集合每个元素都加10
listMap.foreach(println)
val listMap02: List[Int] = list.map( _*10 ) //集合每个元素都乘10
list.foreach(println)
listMap02.foreach(println)
艺术-升华
val listStr = List(
"hello world",
"hello msb",
"good idea"
)
val flatMap= listStr.flatMap( (x:String)=> x.split(" ") ) //把集合的数据再分割生成新的集合
flatMap.foreach(println)
val mapList = flatMap.map( (_,1) ) // 生成map集合，键为key值为1
mapList.foreach(println)
//以上代码有什么问题吗？ 内存扩大了N倍，每一步计算内存都留有对象数据；有没有什么现成的技术解决数据计算中间状态占用内存这一问题~？//迭代器模式！！！！！
艺术-再-升华
//基于迭代器的原码分析
val iter: Iterator[String] = listStr.iterator //什么是迭代器，为什么会有迭代器模式？ 迭代器里不存数据！
val iterFlatMap= iter.flatMap( (x:String)=> x.split(" ") )
//iterFlatMap.foreach(println)
val iterMapList = iterFlatMap.map( (_,1) )
while(iterMapList.hasNext){
val tuple: (String, Int) = iterMapList.next()
println(tuple)
}
类的多继承
objecttest{
traitA{
defa(): Unit ={
println("a method")
}
}
traitB{
defb(): Unit ={
println("b method")
}
defc();
}
classPersion(name:String) extendsAwithB{
defd(): Unit ={
print(s"d method:$name")
}
overridedefc(): Unit = {
println("c method")
}
}
defmain(args: Array[String]): Unit = {
val p = newPersion("张三")
p.a()
p.b()
p.c()
p.d()
}
}
对象的便捷比较关键字case
caseclassDog(name:String,age:Int){
}
object Test {
def main(args: Array[String]): Unit = {
val dog1 = Dog("hsq",18)
val dog2 = Dog("hsq",18)
println(dog1.equals(dog2))
println(dog1 == dog2)
}
}
输出
truetrue
match的使用，类似swtich
object Test {
def main(args: Array[String]): Unit = {
val tup: (Double, Int, String, Boolean, Int) = (1.0,88,"abc",false,55)
val iter: Iterator[Any] = tup.productIterator
val res: Iterator[Unit] = iter.map(
(x) => {
x match {
// 在匹配到一个case后自动返回// 迭代器不调用时不会执行此方法case1 => println(s"$x...is 1")
case88 => println(s"$x ...is 88")
casefalse => println(s"$x...is false")
case w: Int if w > 50 => println(s"$w...is > 50")
case _ => println("wo ye bu zhi dao sha lei xing ")
}
}
)
while(res.hasNext) println(res.next())
}
}
输出
1.0...is1
()
88 ...is88
()
wo ye bu zhi dao sha lei xing
()
false...isfalse
()
55...is > 50
()
偏函数的使用
object Test {
def main(args: Array[String]): Unit = {
// 偏函数入参任意类型，出参字符串
def ff:PartialFunction[Any,String] ={
case"hello" => "val is hello"case x:Int => s"$x...is int"case _ => "none"
}
println(ff(44))
println(ff("hello"))
println(ff("hi"))
}
}
输出
44...isint
val is hello
none
隐式转换scala的编译器处理流程
// 1,scala编译器发现 list.foreach(println) 有bug// 2,去寻找有没有implicit 定义的方法，且方法的参数正好是list的类型！！！// 3,编译期：完成你曾经人类：// val xx = new XXX(list)// xx.foreach(println)// 编译器帮把代码改写了
隐式方法转换
import java.util
object Test {
defmain(args: Array[String]): Unit = {
val listLinked = new util.LinkedList[Int]()
listLinked.add(1)
listLinked.add(2)
//隐式转换方法，在java List集合上添加foreach方法
implicit defabcd[T](list:util.LinkedList[T]) ={
val iter: util.Iterator[T] = list.iterator()
new XXX(iter)
}
listLinked.foreach(println)
}
}
classXXX[T](list:util.Iterator[T]){
defforeach( f:(T)=>Unit): Unit ={
while(list.hasNext) f(list.next())
}
}
输出
12
隐式类转换
import java.util
object Test {
defmain(args: Array[String]): Unit = {
val list = new util.LinkedList[Int]()
list.add(1)
list.add(2)
//隐式转换类
implicit classKKK[T](list: util.LinkedList[T]) {
defforeach(f: (T) => Unit): Unit = {
val iter: util.Iterator[T] = list.iterator()
while (iter.hasNext) f(iter.next())
}
}
list.foreach(println)
}
}
输出
12
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本