当前位置: 首页 > news >正文

Scala的集合操作之可变数组和不可变数组,可变List集合与不可变List集合,可变Set与不可变Set操作,可变和不可变Map集合和元组操作

Scala的集合操作之,可变数组和不可变数组,可变List集合与不可变List集合

不可变数组

/*
traversable/ˈtrævəsəbl/adj.能越过的;可否认的*/
object Test01_ImmutableArray {def main(args: Array[String]): Unit = {// 1. 创建数组val arr: Array[Int] = new Array[Int](5)// 另一种创建方式/*Array.apply(12, 37, 42, 58, 97)通过Array伴生对象的apply方法获取一个数组对象,apply方法可以省略。等价于Array(12, 37, 42, 58, 97)*/val arr2 = Array(12, 37, 42, 58, 97)println(arr)// 2. 访问元素println(arr(0))println(arr(1))println(arr(4))
//    println(arr(5))arr(0) = 12arr(4) = 57println(arr(0))println(arr(1))println(arr(4))println("========================")// 3. 数组的遍历// 1) 普通for循环
//    for (i <- 0 to arr.length-1) println(arr(i))for (i <- 0 until arr.length){println(arr(i))}/*源码注释:Produces the range of all indices of this sequence.@return  a `Range` value from `0` to one less than the length of this $coll.indices方法实际上还是返回Range伴生对象的until方法def indices: Range = 0 until length*/for (i <- arr.indices) println(arr(i))println("---------------------")// 2) 直接遍历所有元素,增强for循环for (elem <- arr2) println(elem)println("---------------------")// 3) 迭代器val iter = arr2.iteratorwhile (iter.hasNext)println(iter.next())println("---------------------")// 4) 调用foreach方法arr2.foreach( (elem: Int) => println(elem) )// 下面这个foreach遍历跟上面的等价arr.foreach( println )println(arr2.mkString("--"))println("========================")// 4. 添加元素val newArr = arr2.:+(73)println(arr2.mkString("--"))println(newArr.mkString("--"))val newArr2 = newArr.+:(30)println(newArr2.mkString("--"))val newArr3 = newArr2 :+ 15val newArr4 = 19 +: 29 +: newArr3 :+ 26 :+ 73println(newArr4.mkString(", "))}
}

可变数组ArrayBuffer

/*** with: 和...在一起,具有,支持的含义* 一个类继承一个特质用extends,多个特质用,extends ..with..* class 类名 extends 特质 1 with 特质 2 with 特质 3...*/
object Test02_ArrayBuffer {def main(args: Array[String]): Unit = {// 1. 创建可变数组val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()val arr2 = ArrayBuffer(23, 57, 92)println(arr1)println(arr2)// 2. 访问元素
//    println(arr1(0))     // errorprintln(arr2(1))arr2(1) = 39println(arr2(1))println("======================")// 3. 添加元素,:+操作会返回一个新的数组对象,+=操作返回的是原数组自身对象val newArr1 = arr1 :+ 15println(arr1)println(newArr1)println(arr1 == newArr1)//可变数组推荐使用+=操作val newArr2 = arr1 += 19println(arr1)println(newArr2)println(arr1 == newArr2)newArr2 += 13println(arr1)77 +=: arr1println(arr1)println(newArr2)println("==============================")/*append(元素)向数组末尾添加一个元素prepend(元素)向数组头部添加一个元素insert(元素1,元素2)向数组插入多个元素insertAll(2, newArr)向数组2索引位置开始插入一个新的数组prependAll(newArr)向数组头部插入一个新的数组*/arr1.append(36)arr1.prepend(11, 76)arr1.insert(1, 13, 59)println(arr1)arr1.insertAll(2, newArr1)arr1.prependAll(newArr2)println("************************")println("arr1: ==> " + arr1)/*** 删除操作:* remove(n: Int, count: Int)方法,从数组n索引位置开始删除count个元素* remove(n: Int)删除数组n索引位置的数据*/// 4. 删除元素arr1.remove(3)println(arr1)arr1.remove(0, 10)println(arr1)//调用 -=方法删除某个元素arr1 -= 13println(arr1)// 5. 可变数组转换为不可变数组val arr: ArrayBuffer[Int] = ArrayBuffer(23, 56, 98)val newArr: Array[Int] = arr.toArrayprintln(newArr.mkString(", "))println(arr)// 6. 不可变数组转换为可变数组val buffer: mutable.Buffer[Int] = newArr.toBufferprintln(buffer)println(newArr)}
}

多维数组

object Test03_MulArray {def main(args: Array[String]): Unit = {// 1. 创建二维数组val array: Array[Array[Int]] = Array.ofDim[Int](2, 3)// 2. 访问元素array(0)(2) = 19array(1)(0) = 25println(array.mkString(", "))for (i <- 0 until array.length; j <- 0 until array(i).length){println(array(i)(j))}for (i <- array.indices; j <- array(i).indices){print(array(i)(j) + "\t")if (j == array(i).length - 1) println()}array.foreach(line => line.foreach(println))array.foreach(_.foreach(println))}
}

不可变List集合

/** List底层源码,Scala在List包对象中对List类型进行了重定义:type List[+A] = scala.collection.immutable.List[A]* 我们可以看到,这里的List实际上就是来自不可变集合包下的List.*  List是一个抽象类,sealed abstract class List[+A];无法直接New对象,它继承了AbstractSeq特质,具有LinearSeq[A]等特质*  与List抽象类对应的有一个同名的伴生对象List,我们可以调用伴生对象的apply方法创建List[T] 集合*/
object Test04_List {def main(args: Array[String]): Unit = {// 1. 创建一个List,不可变的List//val list1 = List.apply(23, 65, 87),因为apply方法调用可以简化,直接写成List(元素1,元素2,...)val list1 = List(23, 65, 87)println(list1)// 2. 访问和遍历元素println(list1(1))
//   list没有索引list1.foreach(println)/*3. 添加元素+: 向list集合前面头部添加元素:+ 向list集合尾部添加元素*/val list2 = 10 +: list1val list3 = list1 :+ 23println("list1: "+list1)println("list2: "+list2)println("list3: "+list3)println("==================")/*** 双冒号的功能:*  ::是Lits集合自带的方法,用于为集合添加一个元素,直接添加到集合的头部*  例如:list2.::(51),在list2集合前面添加一个51的元素*  Nil.::(13)也可以为一个空的list集合添加一个元素*/val list4 = list2.::(51)println("list4: "+list4)val list5 = Nil.::(13)println("list5: "+list5)val list6 = 73 :: 32 :: Nil// Nil空list集合对象,可以链式调用双冒号方法从右向左依次去添加元素val list7 = 17 :: 28 :: 59 :: 16 :: Nilprintln("list7: "+ list7)// 4. 合并列表val list8 = list6 :: list7println("list8: "+list8)/*** 三冒号和++ 操作:* ::: 与++ 都能实现将一个list集合所有元素加入另外一个list集合中*/val list9 = list6 ::: list7println("list9: "+ list9)val list10 = list6 ++ list7println("list10: "+ list10)}
}

可变List集合ListBuffer操作

object Test05_ListBuffer {def main(args: Array[String]): Unit = {// 1. 创建可变列表val list1: ListBuffer[Int] = new ListBuffer[Int]()val list2 = ListBuffer(12, 53, 75)println("list1 ==> " + list1)println("list2 ==> " + list2)println("==============")// 2. 添加元素list1.append(15, 62)list2.prepend(20)list1.insert(1, 19, 22)println("list1 ==> " + list1 )println("list2 ==> " + list2)println("==============")/***  +=:带冒号的操作是从右向左,向头部添加元素*  += 不带冒号的操作方法是默认加到list集合后边**/31 +=: 96 +=: list1 += 25 += 11println("list1 ==> " + list1)println("==============")// 3. 合并list,++操作方法是克隆原来的集合,在复制的集合上进行操作。合并后返回一个新的集合val list3 = list1 ++ list2println("list1 ==> " + list1)println("list2 ==> " + list2)println("==============")// ++=会直接覆盖原来的集合list1 ++=: list2println("list1 ==> " + list1)println("list2 ==> " + list2)println("==============")// 4. 修改元素,把索引位置为3的元素修改为30list2(3) = 30 //它底层调用了update方法list2.update(0, 89)println("list2 ==> " + list2)// 5. 删除元素,指定某个索引位置的元素,也可以使用-=操作方法list2.remove(2)list2 -= 25println("list2 ==> " + list2)}
}

不可变Set集合操作

object Test06_ImmutableSet {def main(args: Array[String]): Unit = {// 1. 创建set,使用Set的伴生对象创建Set集合,set集合无序,因此会去重val set1 = Set(13, 23, 53, 12, 13, 23, 78)println(set1)println("==================")// 2. 添加元素//val set2 = set1.+(129)跟下面的等价val set2 = set1 + 129println(set1)println(set2)println("==================")// 3. 合并两个set集合,使用++操作方法,会返回一个新的set的集合val set3 = Set(19, 13, 23, 53, 67, 99)val set4 = set2 ++ set3println(set2)println(set3)println(set4)// 4. 删除元素,使用-val set5 = set3 - 13println(set3)println(set5)}
}

可变Set集合mutable.Set操作

object Test07_MutableSet {def main(args: Array[String]): Unit = {// 1. 创建setval set1: mutable.Set[Int] = mutable.Set(13, 23, 53, 12, 13, 23, 78)println("set1 => " +set1)println("==================")// 2. 添加元素val set2 = set1 + 11println("set1 => " + set1)println("set2 => " + set2)set1 += 11println("set1 => " + set1)val flag1 = set1.add(10)println("flag1 => " + flag1)println("set1 => " + set1)val flag2 = set1.add(10)println("flag2 => " + flag2)println("set1 => " + set1)println("==================")// 3. 删除元素set1 -= 11println(set1)val flag3 = set1.remove(10)println("flag3 => " + flag3)println("set1 => " + set1)val flag4 = set1.remove(10)println("flag4 => " + flag4)println("set1 => " + set1)println("==================")// 4. 合并两个Setval set3 = mutable.Set(11,22,33)println("set1: " + set1 )println("set3 => " + set3 )println("******************")// 合并set1集合与set3集合,返回合并后的新的集合val set4= set1 ++ set3// println("set4: " + set4 )//set3 ++= set1就会把set1集合的元素合并到set3里面set3 ++= set1 //set3调用 ++=方法, 谁调用谁改变println("set1: " + set1)println("set3 => "+ set3)}
}

Scala集合操作之可变Map 集合和不可变Map集合,元组数据操作

不可变Map集合

object Test08_ImmutableMap {def main(args: Array[String]): Unit = {// 1. 创建mapval map1: Map[String, Int] = Map("a" -> 13, "b" -> 25, "hello" -> 3)println(map1)println(map1.getClass)println("==========================")// 2. 遍历元素map1.foreach(println)map1.foreach( (kv: (String, Int)) => println(kv) )println("============================")// 3. 取map中所有的key 或者 value// keys是包含所有key的Iterable[K]集合// 也可以获取所有map集合的所有key的keySet集合,然后遍历keySet集合获取所有key,在根据key获取value值for (key <- map1.keys){println(s"$key ---> ${map1.get(key)}")}// 4. 访问某一个key的valueprintln("a: " + map1.get("a").get)/***  map1.get("a")获取的是一个Option[+A] 类型,但Option是一个密封的抽象类,对应有两个实现:一个为None: 如果根据key获取不到值,返回的就是一个空集合对象,对应的就是 Nonecase object None extends Option[Nothing] {def isEmpty = truedef get = throw new NoSuchElementException("None.get")}另外一个为:Some: 如果根据key获得值了,返回的就是 Somefinal case class Some[+A](@deprecatedName('x, "2.12.0") value: A) extends Option[A] {def isEmpty = falsedef get = value@deprecated("Use .value instead.", "2.12.0") def x: A = value}* map1集合里面没有key为c的键值对,如果去获取value值就会报空指针异常* 为了避免报异常可以调用 getOrElse("c", 0)这个方法,含义是如果对应的键值对存在则返回,不存在默认返回0*/println("c: " + map1.get("c"))println("c: " + map1.getOrElse("c", 0))//map1.put() 不可变Map是不能往里面添加元素的println(map1("a"))}
}

可变Map操作

object Test09_MutableMap {def main(args: Array[String]): Unit = {// 1. 创建mapval map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 25, "hello" -> 3)println(map1)println(map1.getClass)println("==========================")// 2. 添加元素map1.put("c", 5)map1.put("d", 9)println(map1)/** 使用符号添加数据,+=方法,底层调用的是update方法,*  ` def update(key: K, value: V) { this += ((key, value))     } `* += 后面跟了一个k-v键值对的二元组,因此可以使用这种方式添加元素*/map1 += (("e", 7)) //("e", 7)这个一个key-vale的二元组println(map1)println("===========================")// 3. 删除元素println(map1("c"))map1.remove("c")println(map1.getOrElse("c", 0))map1 -= "d"println(map1)println("====================")// 4. 修改元素map1.update("c", 5)map1.update("e", 10)println(map1)println("====================")// 5. 合并两个Mapval map2: Map[String, Int] = Map("aaa" -> 11, "b" -> 29, "hello" -> 5)// 符号操作为 ++=//   把map2中的所有键值对元素,添加到map1中map1 ++= map2println(map1)println(map2)println("---------------------------")val map3: Map[String, Int] = map2 ++ map1println(map1)println(map2)println(map3)}
}

元组操作

object Test10_Tuple {def main(args: Array[String]): Unit = {// 1. 创建元组val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)println(tuple)// 2. 访问数据println(tuple._1)println(tuple._2)println(tuple._3)println(tuple._4)println(tuple.productElement(1))println("=========================")// 3. 遍历元组数据for (elem <- tuple.productIterator)println(elem)// 4. 嵌套元组val mulTuple = (12, 0.3, "hello", (23, "scala"), 29)println(mulTuple._4._2)}
}

for推导式和yield关键字

for推导式的用法

Scala中的for推导式是一种用于对集合进行迭代和转换的强大工具。它提供了一种简洁的语法来处理集合中的元素,并生成新的集合或执行特定的操作。

for推导式的基本语法如下:

for (pattern <- collection) {// 循环体
}

其中,pattern是一个模式,用于解构集合中的元素,collection是要遍历的集合。

以下是几种常见的for推导式的用法:

  1. 遍历集合并执行操作:
val numbers = List(1, 2, 3, 4, 5)
for (num <- numbers) {println(num)
}

上述示例中,for推导式遍历numbers列表中的每个元素,并将其打印出来。

  1. 过滤并转换集合元素:
val numbers = List(1, 2, 3, 4, 5)
val evenSquares = for (num <- numbers if num % 2 == 0) yield num * num
println(evenSquares)

上述示例中,for推导式通过添加if条件来过滤出偶数,然后将符合条件的偶数平方存储在evenSquares列表中。

  1. 多个集合的交叉操作:
val colors = List("red", "green", "blue")
val sizes = List("small", "medium", "large")
val combinations = for {color <- colorssize <- sizes
} yield (color, size)
println(combinations)

上述示例中,for推导式嵌套遍历colorssizes列表,并生成颜色和尺寸的所有可能组合。

除了基本语法之外,for推导式还可以使用模式匹配、嵌套条件、变量绑定等更高级的特性。您可以根据具体的需求来灵活使用和组合这些特性,以实现更复杂的逻辑。

需要注意的是,for推导式在编译时会被转换为其他高阶函数(如mapfilterflatMap等),因此它具有与使用高阶函数相似的性能特性和灵活性。

yield的使用

在Scala中,yield是一个关键字,用于生成集合或其他类型的值。它通常用于for循环中,以遍历集合元素并执行某些操作。以下是yield关键字的主要用法:

  1. 在for循环中生成新的集合
val numbers = List(1, 2, 3, 4, 5)
val squares = for (number <- numbers) yield number * number
println(squares) // 输出: List(1, 4, 9, 16, 25)

上述示例中,yield关键字用于在for循环中生成新的集合squares,这个新的集合的元素是通过对原始集合numbers的每个元素进行平方运算得到的。

  1. 与模式匹配一起使用
case class Person(name: String, age: Int)val people = List(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 35))
val names = for (Person(name, _) <- people) yield name
println(names) // 输出: List(Alice, Bob, Charlie)

上述示例中,yield关键字用于提取people列表中每个Person对象的name属性,并生成一个新的列表names

  1. 用于表达式求值
val result = (for (i <- 1 to 10) yield i * i).sum
println(result) // 输出: 385

在上述示例中,yield关键字用于生成一个包含1到10的数值的集合,并对每个元素求平方。随后,调用sum方法对所有元素进行求和,并返回结果。

需要注意的是,在Scala中,yield关键字只会将新的集合或值返回给程序的其他部分,它不会修改原始的集合或任何其他的状态。此外,yield关键字只能用于带有for循环的语句中,且只有仅包含一个表达式的for循环才能使用yield生成结果。

相关文章:

Scala的集合操作之可变数组和不可变数组,可变List集合与不可变List集合,可变Set与不可变Set操作,可变和不可变Map集合和元组操作

Scala的集合操作之&#xff0c;可变数组和不可变数组&#xff0c;可变List集合与不可变List集合 不可变数组 /* traversable/ˈtrvəsəbl/adj.能越过的&#xff1b;可否认的*/ object Test01_ImmutableArray {def main(args: Array[String]): Unit {// 1. 创建数组val arr:…...

优化Docker权限管理:配置Docker用户组

Docker 利用 Linux 的用户和组权限来管理对 Docker 守护进程的访问权限。一般情况下&#xff0c;只有 root 用户和属于 docker 用户组的用户才被允许访问 Docker 守护进程。在 Linux 系统上使用 Docker 时&#xff0c;如果您尚未配置 docker 用户组&#xff0c;那么作为非 root…...

python+opencv读取rtsp流

前言 在使用yolov5做物体检测中&#xff0c;需要拉取视频流。分解任务第一步则是需要使用opencv读取rtsp流&#xff0c;只要拿到每一帧图片在进行推理显示即可。 代码 import cv2 def read_rtsp():cap cv2.VideoCapture(rtsp://admin:Vrc123456192.168.2.226:554)fourcc c…...

linux入门---动静态库的加载

目录标题 为什么会有动态库和静态库静态库的实现动态库的实现动静态库的加载 为什么会有动态库和静态库 我们来模拟一个场景&#xff0c;首先创建两个头文件 根据文件名便可以得知add.h头文件中存放的是加法函数的声明&#xff0c;sub.h头文件中存放的是减法函数的声明&#…...

计算机竞赛 基于深度学习的人脸专注度检测计算系统 - opencv python cnn

文章目录 1 前言2 相关技术2.1CNN简介2.2 人脸识别算法2.3专注检测原理2.4 OpenCV 3 功能介绍3.1人脸录入功能3.2 人脸识别3.3 人脸专注度检测3.4 识别记录 4 最后 1 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 基于深度学习的人脸专注度…...

【Yolov5+Deepsort】训练自己的数据集(3)| 目标检测追踪 | 轨迹绘制 | 报错分析解决

&#x1f4e2;前言&#xff1a;本篇是关于如何使用YoloV5Deepsort训练自己的数据集&#xff0c;从而实现目标检测与目标追踪&#xff0c;并绘制出物体的运动轨迹。本章讲解的为第三部分内容&#xff1a;数据集的制作、Deepsort模型的训练以及动物运动轨迹的绘制。本文中用到的数…...

docker desktop如何一键进入容器内部

对着对应的容器 点击 view files...

多机单目标跟踪Cross-Drone Transformer Network for Robust Single Object Tracking

1. 摘要 无人机已被广泛用于各种应用&#xff0c;如空中摄影和军事安全&#xff0c;因为与固定摄像机相比&#xff0c;无人机具有高机动性和广阔的视野。多架无人机跟踪系统可以通过收集不同视角的互补视频片段来提供丰富的目标信息&#xff0c;特别是当目标在某些视角下被遮挡…...

手写Mybatis:第7章-SQL执行器的定义和实现

文章目录 一、目标&#xff1a;SQL执行的定义和实现二、设计&#xff1a;SQL执行的定义和实现三、实现&#xff1a;SQL执行的定义和实现3.1 工程结构3.2 SQL执行实现的关系图3.3 执行器的定义和实现3.3.1 Executor 接口3.3.2 BaseExecutor 抽象基类3.3.3 SimpleExecutor 简单执…...

C语言基础知识理论版(很详细)

文章目录 前述一、数据1.1 数据类型1.2 数据第一种数据&#xff1a;常量第二种数据&#xff1a;变量第三种数据&#xff1a;表达式1、算术运算符及算术表达式2、赋值运算符及赋值表达式3、自增、自减运算符4、逗号运算符及其表达式&#xff08;‘顺序求值’表达式&#xff09;5…...

CG MAGIC分享3d Max中的Corona渲染器材质如何成转换VRay材质?

大家无论是使用Corona渲染器还是Vray渲染器时&#xff0c;进行材质问题时&#xff0c;都会遇到转化材质问题。 如何将CR转换成VR或者将VR转换CR材质呢&#xff1f; 对于这两者之间转换最好最好的方法只能是材质转换器。 CG MAGIC小编&#xff0c;梳理了两种方法&#xff0c;大…...

电脑入门:路由器常见问题排错步骤

HiPER系列路由器使用中Ping LAN口不通的诊断步骤 准备工作: 在可以ping通的时候记录下路由器LAN口的MAC地址: 命令hiper% show interface ethernet/1 mac Mac : 0022aa419d1e 以下步骤在ping不通路由器的时候依次操作,并记下结果: 步骤一:观察设备各端口…...

mac电脑识别不出来u盘?mac识别不了u盘怎么办

有些用户反馈说本来想要拷贝文件&#xff0c;但是将U盘插入mac系统后竟然不能识别&#xff0c;这时候我们需要用到NTFS For Mac软件。 其实mac系统只提供了它自身磁盘格式(mac os 扩展)等的读写权限&#xff0c;只提供了读的权限给NTFS、FAT32给硬盘和U盘&#xff0c;我们99%使…...

【系统编程】线程池以及API接口简介

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言&#xff0c;数据结构&#xff0c;Linux基础&#xff0c;ARM开发板&#xff0c;网络编程等领域UP&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff0…...

Verilog零基础入门(边看边练与测试仿真)-笔记

文章目录 第一讲第二讲第三讲第四讲 第一讲 1、testbench 没有端口&#xff0c;所以没括号 2、testbench 输入端 之后要变动 所以定义为reg 3、#10 &#xff1a;过10个时间单位 &#xff1b;’timescale 1ns/10ps 即 1ns 的时间单位 10ps的时间精度 4、reg 型变量赋值的时候 用…...

LLMs之Code:Code Llama的简介、安装、使用方法之详细攻略

LLMs之Code&#xff1a;Code Llama的简介、安装、使用方法之详细攻略 导读&#xff1a;2023年08月25日(北京时间)&#xff0c;Meta发布了Code Llama&#xff0c;一个可以使用文本提示生成代码的大型语言模型(LLM)。Code Llama是最先进的公开可用的LLM代码任务&#xff0c;并有潜…...

[国产MCU]-W801开发实例-MQTT客户端通信

MQTT客户端通信 文章目录 MQTT客户端通信1、MQTT介绍2、W801的MQTT客户端相关API介绍3、代码实现本文将详细介绍如何在W801中使用MQTT协议通信。 1、MQTT介绍 MQTT 被称为消息队列遥测传输协议。它是一种轻量级消息传递协议,可通过简单的通信机制帮助资源受限的网络客户端。 …...

搭建个人hMailServer 邮件服务实现远程发送邮件

文章目录 1. 安装hMailServer2. 设置hMailServer3. 客户端安装添加账号4. 测试发送邮件5. 安装cpolar6. 创建公网地址7. 测试远程发送邮件8. 固定连接公网地址9. 测试固定远程地址发送邮件 hMailServer 是一个邮件服务器,通过它我们可以搭建自己的邮件服务,通过cpolar内网映射工…...

React的 虚拟DOM创建

React是一个流行的JavaScript库&#xff0c;用于构建用户界面。它通过使用虚拟DOM来提高性能和渲染速度。本文将详细介绍React的虚拟DOM的创建方式、用法和案例&#xff0c;以及相关代码和解释。 虚拟DOM是什么&#xff1f; 虚拟DOM是React的一个重要概念&#xff0c;它是一个…...

供热管网安全运行监测,提升供热管网安全性能

城市管网是城市的“生命线”之一&#xff0c;是城市赖以生存和发展的基础&#xff0c;在城市基础设施高质量发展中发挥着重要作用。供热管网作为城市生命线中连接供热管线与热用户的桥梁&#xff0c;担负着向企业和居民用户直接供热的重要职责。随着城市热力需求的急剧增加&…...

centos 7 部署awstats 网站访问检测

一、基础环境准备&#xff08;两种安装方式都要做&#xff09; bash # 安装必要依赖 yum install -y httpd perl mod_perl perl-Time-HiRes perl-DateTime systemctl enable httpd # 设置 Apache 开机自启 systemctl start httpd # 启动 Apache二、安装 AWStats&#xff0…...

Golang dig框架与GraphQL的完美结合

将 Go 的 Dig 依赖注入框架与 GraphQL 结合使用&#xff0c;可以显著提升应用程序的可维护性、可测试性以及灵活性。 Dig 是一个强大的依赖注入容器&#xff0c;能够帮助开发者更好地管理复杂的依赖关系&#xff0c;而 GraphQL 则是一种用于 API 的查询语言&#xff0c;能够提…...

【AI学习】三、AI算法中的向量

在人工智能&#xff08;AI&#xff09;算法中&#xff0c;向量&#xff08;Vector&#xff09;是一种将现实世界中的数据&#xff08;如图像、文本、音频等&#xff09;转化为计算机可处理的数值型特征表示的工具。它是连接人类认知&#xff08;如语义、视觉特征&#xff09;与…...

12.找到字符串中所有字母异位词

&#x1f9e0; 题目解析 题目描述&#xff1a; 给定两个字符串 s 和 p&#xff0c;找出 s 中所有 p 的字母异位词的起始索引。 返回的答案以数组形式表示。 字母异位词定义&#xff1a; 若两个字符串包含的字符种类和出现次数完全相同&#xff0c;顺序无所谓&#xff0c;则互为…...

《基于Apache Flink的流处理》笔记

思维导图 1-3 章 4-7章 8-11 章 参考资料 源码&#xff1a; https://github.com/streaming-with-flink 博客 https://flink.apache.org/bloghttps://www.ververica.com/blog 聚会及会议 https://flink-forward.orghttps://www.meetup.com/topics/apache-flink https://n…...

实现弹窗随键盘上移居中

实现弹窗随键盘上移的核心思路 在Android中&#xff0c;可以通过监听键盘的显示和隐藏事件&#xff0c;动态调整弹窗的位置。关键点在于获取键盘高度&#xff0c;并计算剩余屏幕空间以重新定位弹窗。 // 在Activity或Fragment中设置键盘监听 val rootView findViewById<V…...

OPENCV形态学基础之二腐蚀

一.腐蚀的原理 (图1) 数学表达式&#xff1a;dst(x,y) erode(src(x,y)) min(x,y)src(xx,yy) 腐蚀也是图像形态学的基本功能之一&#xff0c;腐蚀跟膨胀属于反向操作&#xff0c;膨胀是把图像图像变大&#xff0c;而腐蚀就是把图像变小。腐蚀后的图像变小变暗淡。 腐蚀…...

MySQL账号权限管理指南:安全创建账户与精细授权技巧

在MySQL数据库管理中&#xff0c;合理创建用户账号并分配精确权限是保障数据安全的核心环节。直接使用root账号进行所有操作不仅危险且难以审计操作行为。今天我们来全面解析MySQL账号创建与权限分配的专业方法。 一、为何需要创建独立账号&#xff1f; 最小权限原则&#xf…...

AI+无人机如何守护濒危物种?YOLOv8实现95%精准识别

【导读】 野生动物监测在理解和保护生态系统中发挥着至关重要的作用。然而&#xff0c;传统的野生动物观察方法往往耗时耗力、成本高昂且范围有限。无人机的出现为野生动物监测提供了有前景的替代方案&#xff0c;能够实现大范围覆盖并远程采集数据。尽管具备这些优势&#xf…...

C++ 设计模式 《小明的奶茶加料风波》

&#x1f468;‍&#x1f393; 模式名称&#xff1a;装饰器模式&#xff08;Decorator Pattern&#xff09; &#x1f466; 小明最近上线了校园奶茶配送功能&#xff0c;业务火爆&#xff0c;大家都在加料&#xff1a; 有的同学要加波霸 &#x1f7e4;&#xff0c;有的要加椰果…...