Scala的简单学习二

一集合

1.1 Java集合

1.在scala创建Java集合需要导入java.util包

2.不能使用scala中遍历迭代器的方法遍历Java集合

3.使用下标索引遍历Java集合

4.list集合中，add是添加元素(可以指定下表索引插入)，get是通过下标索引获取元素，size是获取集合长度

 //使用Java中的集合val list = new util.ArrayList[Int]()//添加元素list.add(11)list.add(12)list.add(13)list.add(14)list.add(15)list.add(16)println(list)println("="*100)//遍历集合var i: Int = 0while (i<list.size()){println(list.get(i))i+=1}

1.2 List

1.2.1 取元素

1.直接通过下标索引获取

集合名(索引)

2.特殊位置特殊取法

开头：集合名.head

结尾：集合名.head

    //创建Scala中的List集合val list: List[Int] = List(88, 66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)println(list)println("="*100)//取元素val i: Int = list(1)println(i)println("="*100)//66//取第一个元素val head: Int = list.headprintln(head)//88println("="*100)//取最后一个元素val last: Int = list.lastprintln(last)//33println("="*100)

1.2.2 tail 去掉开头返回集合

1.去除第一个元素，返回一个集合

 val tail: List[Int] = list.tailprintln(tail)//List(66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)println(list)//List(88, 66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)

1.2.3 mkString 分隔符连接

 //使用分隔符连接集合中的元素val str: String = list.mkString("-")println(str)//88-66-22-99-11-33-110-11-22-44-22-55-11-33println("="*100)

1.2.4 reverse反转集合

//反转集合val reverseList: List[Int] = list.reverseprintln(reverseList)//List(33, 11, 55, 22, 44, 22, 11, 110, 33, 11, 99, 22, 66, 88)

1.2.5   取元素组成新集合

take，takeRight

 //从左向右取n个元素，组成新集合val takeList: List[Int] = list.take(4)println(takeList)//List(88, 66, 22, 99)println("="*100)//从右向左取n个元素，组成新集合val takeRightList: List[Int] = list.takeRight(4)println(takeRightList)//List(22, 55, 11, 33)println("="*100)

1.2.6 takeWhile

1.从第一个元素开始取，直到函数的返回值是false的时候

//从第一个元素开始取，直到函数的返回值是false的时候,组成新集合//p: A => Booleanval takeWhileList: List[Int] = list.takeWhile((p: Int) => p % 2 == 0)println(takeWhileList)//List(88, 66, 22)println("="*100)

1.2.7 distinct去重返回集合

val distinctList: List[Int] = list.distinctprintln(distinctList)//List(88, 66, 22, 99, 11, 33, 110, 44, 55)println("="*100)

1.2.8 sum求和

1.针对Int的List集合

//求和，针对Int的集合val sum: Int = list.sumprintln(sum)//627println("="*100)

1.2.9 最大小值

 //求最大小值val max: Int = list.maxval min: Int = list.minprintln(max)//110println(min)//11println("="*100)

1.2.10 遍历集合

1.使用foreach遍历比较好

  //遍历集合list.foreach(println)println("="*100)for (elem <- list) {println(elem)}println("="*100)

2.foreach里面可以加匿名函数

  //求集合中偶数和var sum1:Int=0list.foreach((i:Int)=>{if (i%2==0){sum1+=i}})println(sum1)

1.2.11 map

1.处理集合中每个元素，返回一个列表

//map:处理集合中每个元素，返回一个列表//集合中每个元素+100val mapList: List[Int] = list.map((i: Int) => {i + 100})println(mapList)println("="*100)//需求，集合中的元素偶数+100 奇数-100val mapList1: List[Int] = list.map((i: Int) => {if (i % 2 == 0) {i + 100} else {i - 100}})println(mapList1)

1.2.12 filter 筛选

 //filter:筛选集合中的元素，组成新集合，true的部分成为新集合的元素//筛选偶数val filterList: List[Int] = list.filter((i: Int) => {i % 2 == 0})println(filterList)println("=" * 100)

1.2.13 flatMap 扁平化

    //flatMap：扁平化val strList: List[String] = List("python|java|linux", "mysql|redis|clickhouse", "hadoop|hive|zookeeper")val flapMapList: List[String] = strList.flatMap((str: String) => {str.split("\\|")})println(flapMapList)//List(python, java, linux, mysql, redis, clickhouse, hadoop, hive, zookeeper)println("=" * 100)//使用迭代器，扁平化strList.foreach((str: String) => {val splitList: Array[String] = str.split("\\|")splitList.foreach(println)})println("=" * 100)

1.2.14 排序 sort,sortWith

1.默认是升序

  //排序:sortBy,默认从小到大，前面加一个-就是从大到小//    sortWith：指定两个元素之间的大小关系进行排序val sortByList: List[Int] = list.sortBy((i: Int) => {i})println(sortByList)println("=" * 100)val sortByList1: List[Int] = list.sortBy((i: Int) => {-i})println(sortByList1)println("=" * 100)val sortWithList: List[Int] = list.sortWith((x: Int, y: Int) => x < y)//从小到大println(sortWithList)println("=" * 100)val sortWithList1: List[Int] = list.sortWith((x: Int, y: Int) => x > y)//从大到小println(sortWithList1)println("=" * 100)

1.2.15 groupBy 分组

1.得到的是一个字典

.group((变量:要分组的数据类型)=>{

        变量的操作

})

    //分组 groupByval stringList1: List[String] = List("hello", "world", "java", "world", "java", "world", "java", "hello", "hello", "spark", "flink", "hello", "spark", "flink")val map: Map[String, List[String]] = stringList1.groupBy((str: String) => {str})println(map)/*** Map(world -> List(world, world, world), * java -> List(java, java, java), * flink -> List(flink, flink), * spark -> List(spark, spark), * hello -> List(hello, hello, hello, hello))*/map.foreach(println)/*** (world,List(world, world, world))* (java,List(java, java, java))* (flink,List(flink, flink))* (spark,List(spark, spark))* (hello,List(hello, hello, hello, hello))*/

1.3 Set

1.List里面有的Set也有，但是Set是无序且唯一的

1.3.1 交、并、差

1.交：集合1名.&(集合2名)

集合1名 & 集合2名 

2.并

集合1名.|(集合2名)

集合1名 | 集合2名

3.差

集合1名.&~(集合2名)

集合1名 &~ 集合2名

 //交集，并集，差集val set2: Set[Int] = Set(1, 2, 3, 4, 5)val set3: Set[Int] = Set(3, 4, 5, 6, 7)//交集println(set2.&(set3))println(set2 & set3)println(set2.intersect(set3))//并集println(set2.|(set3))println(set2 | set3)//差集println(set2.&~(set3))println(set2 &~ set3)

1.3.2 Set与List的转化

1.List搭配Set自动去重相同的

 //转化val list1: List[Int] = List(88, 66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)val set1: Set[Int] = list1.toSetprintln(set1)println(set1.toList)

1.4 mutable 可变集合

1.通过观察源码发现，不可变集合属于scala.collection.immutable中

2.如果我们想要使用可变的集合，就要去scala.collection.mutable下找对应的集合进行使用

1.4.1 ListBuffer

1.创建ListBuffer   new ListBuffer[Int]

2.添加元素

集合名.append(元素)

集合名.+=(元素)

3.指定位置添加

集合名.insert(索引,元素)

4.添加列表

集合名.++=(另一个集合名)

   //创建ListBuffer集合val listBuffer: ListBuffer[Int] = new ListBuffer[Int]//添加元素有两种方法listBuffer.append(1)listBuffer.append(2)listBuffer.append(3)listBuffer.+=(4)listBuffer.+=(4)println(listBuffer)println("="*100)//指定位置添加元素listBuffer.insert(2,9)println(listBuffer)println("="*100)//批量添加(添加另一个集合)val list: List[Int] = List(5, 6, 7, 8)listBuffer.++=(list)println(listBuffer)println("="*100)

5.更新元素

集合名.updata(索引,元素)

这个没有返回值

 //更新元素listBuffer.update(1,10)println(listBuffer)println("="*100)

6.指定下标删除元素

列表名.remove(索引)

7.从左向右删除第一个

列表名.-=(元素)

 //删除元素//指定下标删除元素val i: Int = listBuffer.remove(1)println(i)println(listBuffer)println("="*100)//删除元素 从左向右，只会删除第一次出现的对应字符串println(listBuffer.-=(4))println("="*100)

1.4.2 HashSet

1.添加元素使用 add或者+=

2.移除元素使用-=

1.5 Tuple

1.5.1 概念

1.固定长度的集合，元素不是固定的，可以是任意值

2.创建元组

Tuple长度(元素的个数等于长度)

或者直接   (元素)

val tuple: (Int, Int, Int, Int, Int, Int) = Tuple6(1, 2, 3, 4, 5, 6)println(tuple)val tuple1: (Int, Int, Int, Int) = (11, 12, 13, 14)println(tuple1)

1.5.2 获取元素

println(tuple1._2)

1.6 Map

1.6.1 不可变Map

1.创建Map

//创建Mapval map: Map[String, Int] = Map("1001" -> 18, "1002" -> 19, "1003" -> 20)

2.通过键找值，getOrElse

    //通过键获取值println(map.get("1001"))//Some(18)//通过键获取值，如果没找到返回默认值println(map.getOrElse("1004", "没有这个元素"))//没有这个元素

3.map方法：将Map的键值对变成一个二元元组，操作里面的键与值最后返回的还是Map

注意最后匿名函数里面要返回一个二元元组

val map2: Map[String, Int] = Map(("1001", 18), ("1002", 19), ("1003", 10), "1004" -> 15)//将每个年龄+1val map1: Map[String,Int] = map2.map((kv: (String,Int)) => {val key: String = kv._1val value: Int = kv._2(key,value+1)})println(map1)//Map(1001 -> 19, 1002 -> 20, 1003 -> 11, 1004 -> 16)

4.获取所有的keys与values

//获取所有的keyval keys: Iterable[String] = map2.keysprintln(keys)val values: Iterable[Int] = map2.valuesprintln(values)

1.6.2 可变Map

1.添加元素

.+=(())

.put()

//添加元素hashMap.+=(("xia",19))hashMap.put("mi",18)println(hashMap)

2.删除元素

只需要写一个键

hashMap -= "xia"println(hashMap)

1.7 Java与scala集合的转化

1.7.1 Java->scala

1.导入的包是  scala.collection.JavaConverters._

  //创建一个java中的集合val list1: util.ArrayList[String] = new util.ArrayList[String]()list1.add("java")list1.add("world")list1.add("hello")list1.add("spark")list1.add("java")
//    println(list1)/*** java集合->scala* 借助隐式转换，调用原本没有的功能*/val scalaList: List[String] = list1.asScala.toListprintln(scalaList)

1.7.2 Scala->java

/*** scala中集合->java集合*/val list2: List[Int] = List(1,2,3,4,5,6,7)val javaList: util.List[Int] = list2.asJavaprintln(javaList)

二 JCBC

1.模板直接套

package com.shujia.day02import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}object Demo19JCBC {def main(args: Array[String]): Unit = {/***  scala中连接数据库*///加载驱动Class.forName("com.mysql.jdbc.Driver")//创建与数据库连接对象val conn: Connection = DriverManager.getConnection("jdbc:mysql://192.168.73.100/bigdata29?useUnicode=true&characterEncoding=utf8&useSSL=false", "root", "123456")//为了防止sql注入val state: PreparedStatement = conn.prepareStatement("select id,job_name,company_name," +"salary,addr,experience,education,company_type from job_listing where education=?")state.setString(1,"本科")//执行sql语句val resultSet: ResultSet = state.executeQuery()while (resultSet.next()){val id: Int = resultSet.getInt("id")val job_name: String = resultSet.getString("job_name")val company_name: String = resultSet.getString("company_name")val salary: String = resultSet.getString("salary")val addr: String = resultSet.getString("addr")val experience: String = resultSet.getString("experience")val education: String = resultSet.getString("education")val company_type: String = resultSet.getString("company_type")println(id+job_name+company_name+salary+addr+experience+education+company_type)}//释放资源state.close()conn.close()}}

  三匹配模式

3.1 基本数据类型

1.自上而下匹配

 var i: Int = 100i match {case 10 => println("i的值是10")case 100 => println("i的值是100")case _ => println("i的值是其他")}

3.2 匹配字符串

  //匹配字符串var str:String="java"str match {case "java"=>println("hello")case "spark"=>println("hh")case _=>println("ll")}

3.3匹配元组

1.元组不可变，只能case一个

2.匹配的是数据类型

 //匹配元组//匹配的是数据类型val tuple: (Int, Int, Int) = (11, 12, 13)tuple match {case (x:Int,y:Int,z:Int)=>println(x+y+z)//36}

3.4 匹配数组

1.匹配的是数据类型

2.可以匹配多个

 //匹配数组val array: Array[String] = Array("1001", "张三")array match {case Array(id:String,name:String)=>println(id+name)case Array(id:String,name:String,adr:String)=>println(id+name+adr)case _=>println("hello")}

3.5 匹配匹配值的类型

 //匹配匹配值的类型val obj:Any=100obj match {case a:Int=>println("obj是Int类型")case b:String=>println("obj是String类型")case _=>println("obj是其他类型")}

3.6 Map中的get方法

val map: Map[String, String] = Map("1001" -> "张三", "1002" -> "李四")val str1: String = map.get("1007") match {case Some(x) => xcase None => "默认值"}println(str1)//等同于val str2: String = map.getOrElse("1007", "默认值")println(str2)

3.7 与函数一起用

1.map函数中将小括号变成大括号

val list: List[Array[String]] = Source.fromFile("scala/data/score.txt").getLines().toList.map((line: String) => {line.split(",")})list.map {case Array(id: String, _, score: String) => (id, score)}.foreach(println)//下面写法一样//    val list: List[String] = Source.fromFile("scala/data/score.txt").getLines().toList//    val list1: List[Array[String]] = list.map((line: String) => {//      line.split(",")//    })//    val tuples: List[(String, String)] = list1.map {//      case Array(id: String, _, score: String) => (id, score)//    }//    tuples.foreach(println)

四 隐式转化

4.1 隐式转化函数

1.只针对参数类型和返回值类型，和隐式函数叫什么无关

2.同一种参数和返回值类型组合的隐式转换函数，同一作用域下只能出现一种

3.scala编译器，在编译代码的时候，会识别到需要将A类型转B类型，然后就去找参数是A类型，返回值是B类型的隐式转换函数，自动调用，否则找不到报错

//定义一个fun函数def fun(i: Int): Unit = {println(i + 100)}//定义一个将参数类型变成跟返回值类型一样的隐式转化函数implicit def strToInt(s:String): Int = {Integer.parseInt(s)}//    implicit def strToInt2(s:String): Int = {
//      Integer.parseInt(s)
//    }//出现报错因为同一种参数和返回值类型组合的隐式转换函数，同一作用域下只能出现一种fun("100")//200

4.应用

    //应用import com.shujia.day02.Text1._val list: List[String] = "scala/data/students.csv".getLines().toListlist.foreach(println)}//相当于val list1: List[String] = read("scala/data/students.csv").getLines().toListlist1.foreach(println)}object Text1 {implicit def read(path: String): BufferedSource = {Source.fromFile(path)}
}

4.2 隐式转化类

1.隐式转换类可以隐式的将类的构造函数参数类型转换成当前类的类型，自动调用构造方法创建对象

package com.shujia.day02import scala.io.Sourceobject Demo23Implicit {def main(args: Array[String]): Unit = {//普通方法val read = new Read("scala/data/students.csv")val list: List[String] = read.read()list.foreach(println)//隐式转化类方法val list1: List[String] = "scala/data/students.csv".read()list1.foreach(println)println("scala/data/students.csv".p("j"))}implicit class Read(path:String){def read(): List[String] = {Source.fromFile(path).getLines().toList}def p(str: String): String = {str + path}}
}

4.3 隐式转化变量

package com.shujia.day02object Demo24Implicit {def main(args: Array[String]): Unit = {def add(x:Int)(implicit y:Int):Int={x+y}implicit val i:Int=100//正常传值println(add(2)(100))//使用隐式转化变量println(add(2))}}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/17257.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【Python】 如何在Python中设置环境变量？

【Python】 如何在Python中设置环境变量？

基本原理 在Python中&#xff0c;环境变量是一种存储系统或应用程序配置信息的方式&#xff0c;它们可以被操作系统或应用程序访问。环境变量通常用于配置应用程序的行为&#xff0c;例如指定数据库的连接字符串、API密钥、文件路径等。 Python提供了几种方法来设置和访问环境…
阅读更多...
心电信号降噪方法（滤波器/移动平均/小波等，MATLAB环境）

心电信号降噪方法（滤波器/移动平均/小波等，MATLAB环境）

对于一个正常的、完整的心动周期&#xff0c;对应的心电图波形如下图所示&#xff0c;各个波形都对应着心脏兴奋活动的生理过程&#xff0c;包含P波&#xff0c;PR段&#xff0c;QRS波群&#xff0c;ST段&#xff0c;T波&#xff0c;U波。 &#xff08;1&#xff09;P波心电图中…
阅读更多...
OpenBMC相关的网站

OpenBMC相关的网站

openbmc官方网站 https://github.com/openbmchttps://github.com/openbmc Dashboard [Jenkins]https://jenkins.openbmc.org/ https://gerrit.openbmc.org/Gerrit Code Reviewhttps://gerrit.openbmc.org/ Searchhttps://grok.openbmc.org/ openbmc参考网站 https://www.c…
阅读更多...
R实验 正交试验设计与一元线性回归分析

R实验 正交试验设计与一元线性回归分析

实验目的&#xff1a; 掌握正交试验设计记号的意义&#xff1b;掌握正交试验设计的直观分析和方差分析&#xff1b;掌握一元线性回归模型的相关概念&#xff1b;掌握最小二乘法的思想&#xff1b;掌握一元线性回归方程的显著性检验和预测。 实验内容&#xff1a; &#xff11;…
阅读更多...
C++ day1 作业练习

C++ day1 作业练习

整理思维导图 定义自己的命名空间my_sapce&#xff0c;在my_sapce中定义string类型的变量s1&#xff0c;再定义一个函数完成对字符串的逆置。 #include <iostream> #include <cstring>using namespace std; namespace my_space {string s1; }void show() {cout<…
阅读更多...
NASA数据集——严格校准的臭氧（O3）、甲醛（HCHO）、二氧化碳（CO2）和甲烷（CH4）混合比，以及包括三维风在内的气象数据

NASA数据集——严格校准的臭氧（O3）、甲醛（HCHO）、二氧化碳（CO2）和甲烷（CH4）混合比，以及包括三维风在内的气象数据

Alpha Jet Atmopsheric eXperiment Meteorological Measurement System (MMS) Data 阿尔法喷气式大气实验气象测量系统&#xff08;MMS&#xff09;数据 简介 Alpha Jet Atmospheric eXperiment (AJAX) 是美国国家航空航天局艾姆斯研究中心与 H211, L.L.C. 公司的合作项目&a…
阅读更多...
C#面：当一个线程进入一个对象的方法后，其它线程是否可以进入该对象的方法?

C#面：当一个线程进入一个对象的方法后，其它线程是否可以进入该对象的方法?

一个线程在访问一个对象的一个synchronized方法时&#xff1a; 另一个线程可以同时访问这个对象的非同步方法。另一个线程不可以同时访问这个对象的普通同步方法。另一个线程可以同时访问这个对象的静态同步方法 &#xff0c;即static synchronized修饰的方法 。另一个线程不可…
阅读更多...
win10 cmake vs2019 qt opencv contrib 下载 编译 提供编译好的全套文件下载

win10 cmake vs2019 qt opencv contrib 下载 编译 提供编译好的全套文件下载

本文意在提供 win10系统下 使用 cmake-gui 配置 opencv源码 再使用vs2019编译的全套过程 为什么是win10系统? 主要提供给使用pc端的人使用,例如工厂员工 或 上课教学 还可以是什么系统? 当然这一切也可以在arm上操作 例如一块stm32及其配套的硬件 装在无人机上 图像中就…
阅读更多...
【Python】 去除空白字符的艺术：Python中的字符串修剪技巧

【Python】 去除空白字符的艺术：Python中的字符串修剪技巧

基本原理 在Python编程中&#xff0c;经常会遇到需要去除字符串两端空白字符&#xff08;也称为“修剪”&#xff09;的情况。空白字符包括空格、制表符、换行符等。Python提供了多种方法来处理字符串中的空白字符&#xff0c;其中最常见的是使用字符串的strip()方法。 strip…
阅读更多...
SpringSecurity6从入门到实战之引言和基本概念

SpringSecurity6从入门到实战之引言和基本概念

SpringSecurity6从入门到实战之引言和基本概念 前言 在当今数字化时代&#xff0c;随着网络应用的日益普及&#xff0c;保护用户数据和系统安全变得至关重要。作为Java开发社区的中坚力量&#xff0c;Spring框架提供了一整套解决方案来构建企业级应用程序。然而&#xff0c;随…
阅读更多...
APM2.8飞控

APM2.8飞控

ArduPilotMega 主控可应用于 固定翼、直升机、多旋翼、地面车辆 APM2.8飞控供电有两种 1.电流计供电&#xff0c; 2.带BEC&#xff08;稳压功能&#xff09;的电调供电 ArduPilotMega 内部的硬件结构图&#xff1a; 调试时&#xff0c;不要使用向导&#xff0c;由于向导功能不…
阅读更多...
Linux中的SCP：有你，一切都不遥远

Linux中的SCP：有你，一切都不遥远

引言 在Linux系统中&#xff0c;文件传输是一个常见的任务。SCP&#xff08;Secure Copy Protocol&#xff09;命令提供了一种安全的方式来在本地和远程计算机之间复制文件。本文将详细介绍SCP命令的使用方法&#xff0c;并提供一些实用的示例以及故障排除指南。 SCP命令简介…
阅读更多...
vue组件通讯$parent和$children获取单签组件的⽗组件和当前组件的⼦组件的例子

vue组件通讯$parent和$children获取单签组件的⽗组件和当前组件的⼦组件的例子

在 Vue 中&#xff0c;$parent 和 $children 是实例属性&#xff0c;允许你访问组件的父组件和子组件。但是&#xff0c;请注意&#xff0c;这些属性主要用于在开发过程中进行调试和临时访问&#xff0c;并不推荐在正常的组件通信中使用&#xff0c;因为它们破坏了组件的封装性…
阅读更多...
React Native 之 Linking（链接）（十五）

React Native 之 Linking（链接）（十五）

URL Scheme是什么 URL Scheme是一种机制&#xff0c;主要用于在移动应用程序中打开另一个应用程序或执行特定操作。 定义与原理&#xff1a; URL Scheme允许应用程序通过特定的URL格式与其他应用程序进行交互。 它通过在应用程序中注册一个自定义的URL Scheme&#xff0c;并在…
阅读更多...
[GDB] GDB调试

[GDB] GDB调试

目录 一 简介 二 功能: 三 命令: 四 调试准备: 五 开始调试: 5.1 添加断点&#xff1a; 5.2 条件编译 5.3 断点查看 5.4 断点删除: 5.5 查看源码 5.6 单步调试(逐过程)&#xff1a; 5.7 断点调试: 5.8 单步跟踪(逐语句): 5.9 调试过程&#xff1a; 5.9.1 开始调…
阅读更多...
在CentOS 8上卸载与安装MySQL 8的详细步骤

在CentOS 8上卸载与安装MySQL 8的详细步骤

关键词&#xff1a;MySQL 8安装、CentOS 8、YUM源配置、卸载MySQL、MySQL残留文件删除、首次登录MySQL临时密码、服务状态检查、MySQL社区服务器 阅读建议&#xff1a;本文适合需要在CentOS 8操作系统上部署最新MySQL 8数据库的系统管理员或开发者阅读。文中步骤简洁清晰&#…
阅读更多...
Spring （23）如何在Spring中配置数据源

Spring （23）如何在Spring中配置数据源

在Spring中配置数据源是一个基本且重要的任务&#xff0c;特别是在构建依赖于数据库操作的应用程序时。数据源&#xff08;DataSource&#xff09;是数据库连接的工厂&#xff0c;Spring通过数据源抽象简化了数据库连接的管理。配置数据源通常涉及定义一个或多个DataSourcebean…
阅读更多...
ssm145基于java的电脑硬件库存管理系统+jsp

ssm145基于java的电脑硬件库存管理系统+jsp

电脑硬件库存管理系统的设计与实现 摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对电脑硬件库存信息管理混乱&…
阅读更多...
【设计模式】创建型-抽象工厂模式

【设计模式】创建型-抽象工厂模式

前言 在软件开发领域&#xff0c;设计模式是一种被广泛接受的解决方案&#xff0c;用于解决特定问题并提供可维护和可扩展的代码结构。抽象工厂模式&#xff08;Abstract Factory Pattern&#xff09;是其中之一&#xff0c;它提供了一种方法来创建一系列相关或相互依赖的对象…
阅读更多...
Prime算法构造最小生成树（加点法）

Prime算法构造最小生成树（加点法）

一、算法逻辑 想要轻松形象理解Prime的算法逻辑&#xff0c;视频肯定比图文好。 小编看过很多求相关的教学视频&#xff0c;这里选出一个我认为最好理解的这一款安利给大家。 因为他不仅讲解细致&#xff0c;而且还配合了动画演示&#xff0c;可以说把一个抽象的东西讲的非常…
阅读更多...
最新文章

Copyright @ 2022~2023