（数据科学学习手札45）Scala基础知识

一、简介

　　由于Spark主要是由Scala编写的，虽然Python和R也各自有对Spark的支撑包，但支持程度远不及Scala，所以要想更好的学习Spark，就必须熟练掌握Scala编程语言，Scala与Java较为相似，且在Scala中可以调用很多Java中的包，本文就将针对Scala中的基础数据结构、循环体以及错误处理机制进行基础的介绍；

 

二、基础数据类型与数据结构

2.1基础数据类型

　　Scala包括了8种基础数据类型，基本信息如下表：

基本类型取值范围或示例
Byte-128~127
CharU+0000~U+FFFF
Short-32768~32767
Int-2147483648~2147483647
Long-9223372036854775808~9223372036854775807
Float单精度浮点数，如0.1f
Double双精度浮点数，如0.11
Booleantrue或false


　　String也属于Scala基本数据类型，归属于java.lang包，其余的数据类型都是Scala自带基础类型包的成员，且在Scala中基本类型包与java.lang包是默认导入的。

2.2 Scala变量声明

　　和java类似，Scala中的变量需要在创建时进行声明，有var和val两种声明方式，其中val类型变量定义后不可以重新赋值，而var类型变量声明之后可以自由赋新值，下面在Scala控制台中演示:

//利用val进行变量的声明
scala> val x = 0
x: Int = 0scala> x = 5
<console>:11: error: reassignment to valx = 5^
//利用var进行变量的声明
scala> var x = 0
x: Int = 0scala> x = 8
x: Int = 8

可以看到，val声明后的变量不可重新赋值，而var则可以。

　　Scala中的变量声明有两种形式，一种是在声明变量时指出变量的具体类型：

scala> val x:Int=10
x: Int = 10scala> val y:Double=1.00
y: Double = 1.0scala> val z:String="scala"
z: String = scala

　　而事实上，即使你在Scala中声明变量时不进行类型的指定，Scala内部也会根据你输入数据的具体类型进行判断，来自动分配数据类型，这是第二种变量声明的方式：

scala> val x=10
x: Int = 10scala> val y=1.0f
y: Float = 1.0scala> val z="spark"
z: String = spark

 

2.3 算数操作符、关系运算符与逻辑运算符

　　Scala像很多其他成熟的编程语言一样，具有丰富的内置运算符，且在Scala中操作符也被视为函数，即可以通过对象.操作符()的方式使用，Scala中的常用运算符如下：

运算符描述
+加运算
-减运算
*乘运算
/除运算
%求模运算，返回余数

　　而Scala中的关系运算符如下：

运算符描述
==判断两个对象是否相等
！=判断两个对象是否不等
>判断是否左大于右
<判断是否左小于右
>=判断是否左大于等于右
<=判断是否左小于等于右

　　Scala中的逻辑运算符如下：

运算符描述
&&逻辑与
||逻辑或
!逻辑非

　　Scala中的赋值运算符如下：

运算符描述
=将右侧的值赋给左对象
+=先做加法再赋值
-=先做减法再赋值
*=先做乘法再赋值
/=先做除法再赋值
%=先做求模取余再赋值

2.4基础数据结构

2.4.1定长数组与可变数组

基本概念：

　　在Scala中，数组分为可变(mutable)和不可变(immutable)数组，默认情况下定义的数组为不可变数组，若要定义可变数组，需要导入包scala.collection.mutable.ArrayBuffer，下面是一个示例：

//定义不可变长数组
scala> var array = Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)//导入可变长数组所在包
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer//创建可变长数组
scala> var arrayBuffer = ArrayBuffer(1,2,3,4)
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)

数组相关方法：

　　1.索引

　　对于数组，我们使用 数组名(n) 的方式来索引其从第0位开始第n+1个元素：

 

scala> var array=Array("I","You","He","Her","It")
array: Array[String] = Array(I, You, He, Her, It)scala> array(1)
res0: String = You

 

　　2.将不可变数组转换为可变数组

　　我们使用.toBuffer来完成Array到ArrayBuffer的转变：

scala> var array = Array(1,2,3)
array: Array[Int] = Array(1, 2, 3)scala> array.toBuffer
res1: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3)

　　3.获取数组长度

　　我们使用.length方法来获取数组的长度：

scala> var array10 = new Array[Int](10)
array10: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)scala> array10.length
res2: Int = 10

　　4.在可变数组末尾添加元素

　　我们用 += 的方式为可变长数组在其末尾添加单个或多个元素：

//创建可变长数组
scala> var arrayBuffer = ArrayBuffer(1,2,3)
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)//在创建好的可变长数组的末尾添加单个元素4
scala> arrayBuffer += 4
res3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)//在创建好的可变长数组的末尾添加多个元素
scala> arrayBuffer += (5,6,7)
res4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7)

　　5.在可变长数组末尾追加任何数组

scala> var buff1 = ArrayBuffer(1,2,3)
buff1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)scala> var buff2 = ArrayBuffer(4,5)
buff2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(4, 5)scala> buff1 ++= buff2
res1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

　　6.移除最末端n个元素

　　我们使用.trimEnd(n)来移除数组末端的n个元素：

scala> var arrayBuffer = ArrayBuffer(1,2,3,4,5,6)
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6)scala> arrayBuffer.trimEnd(3)scala> arrayBuffer
res1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

　　7.移除最前端n个元素

　　我们使用.trimStart(n)来移除数组前端的n个元素：

scala> var arrayBuffer = ArrayBuffer(1,2,3,4,5,6)
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6)scala> arrayBuffer.trimStart(3)scala> arrayBuffer
res1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(4, 5, 6)

　　8.移除数组中指定位置的元素

　　我们使用.remove(n)来移除数组中下标为n的元素：

scala> var arrayBuffer = ArrayBuffer(0,1,2,3,4,5)
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5)scala> arrayBuffer.remove(3)
res2: Int = 3scala> arrayBuffer
res3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 4, 5)

　　9.从数组中指定位置开始移除若干个元素

　　我们依旧使用.remove(n,m)来移除数组中下标为n的元素开始往后的m个元素：

scala> var arrayBuffer = ArrayBuffer(0,1,2,3,4,5)
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5)scala> arrayBuffer.remove(3)
res2: Int = 3scala> arrayBuffer
res3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 4, 5)scala> var arrayBuffer = ArrayBuffer(0,1,2,3,4,5)
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5)scala> arrayBuffer.remove(2,2)scala> arrayBuffer
res5: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 4, 5)

 

2.4.2 Map映射

　　与Python中的字典相似，Scala中的映射就是键值对的集合Map，默认情况下Scala中同样是使用不可变的映射，想要使用可变的映射就必须导入scala.collection.mutable.Map类。

　　1.定义映射

　　我们用->连接键值，左边为键，右边为值，键唯一：

 

scala> var DemoMap = Map("Scala"->1,"Python"->2,"R"->3)
DemoMap: scala.collection.immutable.Map[String,Int] = Map(Scala -> 1, Python -> 2, R -> 3)

 

　　2.Map映射的索引

　　直接通过调用键来获取对应的值：

scala> DemoMap("Python")
res1: Int = 2

　　3.判断映射中是否包含某个键的键值对

　　我们使用.contains(键名)来判断某个映射中是否包含指定键名的键值对：

scala> DemoMap.contains("SQL")
res2: Boolean = false

　　4.按下标获取键值对

　　我们使用.drop(n)来获取指定映射中下标为2及其之后下标的键值对：

scala> DemoMap.drop(1)
res7: scala.collection.immutable.Map[String,Int] = Map(Python -> 2, R -> 3)

　　5.构造可变映射

　　为了构造可变的映射，我们需要导入相关包或在Map定义时输入完整路径，这里建议后者：

scala> var DemoMap = scala.collection.mutable.Map("Python"->1,"Java"->2,"R"->3)
DemoMap: scala.collection.mutable.Map[String,Int] = Map(R -> 3, Java -> 2, Python -> 1)

　　6.为可变映射更新或新增键值对

//更新已有的可变Map映射中指定键的值，若不存在此键则创造新键值对
scala> DemoMap("Julia") = 100scala> DemoMap
res1: scala.collection.mutable.Map[String,Int] = Map(R -> 3, Julia -> 100, Java -> 2, Python -> 1)

　　7.提取Map映射中的键集合

　　我们使用.keySet来提取Map映射中的键名集合：

scala> DemoMap.keySet
res3: scala.collection.Set[String] = Set(R, Julia, Java, Python)

　　8.提取Map映射中的值集合

scala> DemoMap.values
res4: Iterable[Int] = HashMap(3, 100, 2, 1)

　　9.逐个的获取Map映射中的键值对信息

scala> for((k,v) <- DemoMap)println(k,"->",v)
(R,->,3)
(Julia,->,100)
(Java,->,2)
(Python,->,1)

 2.4.3 Tuple元组

　　与Python中的元组类似，Scala中的tuple元组也是圆括号包住的，可以存放不同类型的若干元素，且无论是用var还是val方式声明，元组中的元素都不可改变，且元组对内部元素的索引比较特别，是通过._n来索引其内部第n个元素（这里不从0开始）：

//声明一个元组
scala> var tuple1 = (1,2,"3",4.0f,5.0)
tuple1: (Int, Int, String, Float, Double) = (1,2,3,4.0,5.0)//对元组中的第一个元素进行索引
scala> tuple1._1
res0: Int = 1//尝试修改元组中的固有元素
scala> tuple1._1 = 3
<console>:11: error: reassignment to valtuple1._1 = 3

 

2.4.4 List列表

　　也是和Python中的List类似，Scala中的列表被设计来存放各种类型的元素，且Scala中的列表类型有三种模式，一种是当列表内部元素类型统一时，如List[Int]，一种是当列表中同时包含几种不同类型元素时，为List[Any]，最后一种是当列表中不存放任何元素时，为List[Nothing]：

　　1.定义不同的列表

scala> var list1 = List(1,2,3)
list1: List[Int] = List(1, 2, 3)scala> var list1 = List("1","2")
list1: List[String] = List(1, 2)scala> var list1 = List("1",2)
list1: List[Any] = List(1, 2)scala> var list1 = List()
list1: List[Nothing] = List()

　　2.构建多维列表

　　在Scala中，和Python类似，也可以通过多层列表的嵌套来制造多维列表：

 

//声明一个二维列表
scala> var list1 = List(List(1,1),List(2,3))
list1: List[List[Int]] = List(List(1, 1), List(2, 3))scala> list1(0)(1)
res0: Int = 1

 

　　3.列表的拼接方式

　　在Scala中，我们可以通过:::运算符或List.concat()来为已有的列表串联上新的列表：

scala> var list1 = List(1,2,3)
list1: List[Int] = List(1, 2, 3)scala> var list2 = List(4,5)
list2: List[Int] = List(4, 5)scala> list1:::list2
res0: List[Int] = List(1, 2, 3, 4, 5)scala> List.concat(list1,list2)
res1: List[Int] = List(1, 2, 3, 4, 5)scala> List.concat(list2,list1)
res2: List[Int] = List(4, 5, 1, 2, 3)

　　4.列表的一些特殊索引方法

　　和数组类似，列表中也有一些针对头尾若干元素的特殊的索引方式和特殊的判断列表属性的方法：

scala> var list1 = List(1,2,3,4)
list1: List[Int] = List(1, 2, 3, 4)
//使用.head方法获取第一个元素
scala> list1.head
res0: Int = 1
//使用.tail方法获取除第一个元素之外的全部元素
scala> list1.tail
res1: List[Int] = List(2, 3, 4)

 

2.4.5 Set集合

　　和Python中的集合类似，Scala中的集合只允许不重复的若干元素存放在其中，因此可以用来去重，且Set集合分为不可改变的和可变的，即其本身能否被重新赋值或更改，默认情况下Scala中使用不可变的集合，若想使用可变集合就需要使用scala.collection.mutable.Set

//声明不可变长集合
scala> var set1 = Set(1,2,3,3,4)
set1: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)//声明可变长集合
scala> var set2 = scala.collection.mutable.Set(1,2,2,3)
set2: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

 

可以看到，无论是不可变长还是可变长集合，都完成了对输入元素的去重操作，且Set集合的head、tail、isEmpty操作与List基本一致，这里不再赘述。

　　1.向集合中增减新元素

　　我们使用.+()和.-()方法完成对集合中元素的添加或删减：

scala> set2.+(4)
res0: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)scala> set2.-(2)
res1: scala.collection.mutable.Set[Int] = Set(1, 3)

　　2.判断集合中是否包含指定的元素

　　我们使用.contains()方法来判断集合中是否包含指定的元素:

scala> set2.contains(1)
res3: Boolean = true

　　3.返回两个集合的交集、差

 　　我们使用.&()方法和.&~()方法来得到两个集合的交集和差集

scala> var set1 = Set(1,2,3,4)
set1: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)scala> var set2 = Set(3,4,5,6)
set2: scala.collection.immutable.Set[Int] = Set(3, 4, 5, 6)scala> set1.&(set2)
res0: scala.collection.immutable.Set[Int] = Set(3, 4)scala> set1.&~(set2)
res1: scala.collection.immutable.Set[Int] = Set(1, 2)

　　4.计算集合中满足指定条件的元素的个数

　　我们使用.count()来实现此功能：

 

scala> var set1 = Set(1,2,2,3,4,5,5,5,6)
set1: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)scala> set1.count(_ > 2)
res0: Int = 4

 

　　5.集合转换为不可变长数组和可变长数组

scala> var set1 = Set("1","2","3")
set1: scala.collection.immutable.Set[String] = Set(1, 2, 3)scala> set1.toArray
res0: Array[String] = Array(1, 2, 3)scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBufferscala> set1.toBuffer
res1: scala.collection.mutable.Buffer[String] = ArrayBuffer(1, 2, 3)

　　6.快速判断集合中是否存在满足指定条件的元素

scala> var set1 = Set(1,2,3,4,5)
set1: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)scala> set1.exists(_ > 4)
res0: Boolean = true

　　7.得到集合中所有元素的乘积

scala> var set1 = Set(1,2,3,4,5,6,7)
set1: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)scala> set1.product
res0: Int = 5040

　　8.得到集合中所有元素的个数

scala> set1.product
res0: Int = 5040scala> set1.size
res1: Int = 7

　　9.得到一个集合中的最大值、最小值和所有元素之和

scala> var set1 = Set(1,2,3,4,5,6)
set1: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)scala> set1.max
res0: Int = 6scala> set1.min
res1: Int = 1scala> set1.sum
res2: Int = 21

 

三、条件语句和循环语句

3.1条件语句

　　Scala中的if条件语句与R中的相似，主要有两种形式：

　　1、if(布尔表达式)  x else y

object Main {
//创建一个main方法def main(args: Array[String]): Unit = {var x = 1if(x >= 0) println("Yes") else println("Nope")}
}

　　2、if(布尔表达式){

　　　　　　......

　　　　　　} else {

　　　　　　......

　　　　　　}

 

object Main {def main(args: Array[String]): Unit = {var x = 1if(x >= 0){println("Yse")} else {println("Nope")}}
}

 

　　3、利用类似三目运算符的形式为变量赋值

scala> var x = 10
var y = if(x > 0)x else 100
x: Int = 10scala> y: Int = 10

 

3.2循环语句

　　Scala中的循环语句主要有三种：

　　1、for循环

　　Scala中for循环的语法格式为：

　　for(变量<-集合){

　　　　循环体

　　　　}

　　可以用m to n或m until n来定义循环遍历的集合，to表示左右都包括，until不包含右边：

scala> for(i <- 1 to 10){println(i)
}|      | 1
2
3
4
5
6
7
8
9
10
scala> for(i <- 1 until 10){println(i)
}|      | 1
2
3
4
5
6
7
8
9

　　还可以在循环中添加条件语句：

scala> for(i <- 1 until 10 if i % 2 == 0){println(i)
}|      | 2
4
6
8

　　多个for循环结构体嵌套枚举：

scala> for(i <- 1 to 3;j <- 2 to 4)print(i*j+" ")
2 3 4 4 6 8 6 9 12

　　利用for循环和关键词yield来返回新的序列：

scala> var seq1 = for(i <- 1 to 10 if i%3 == 0) yield i
seq1: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 6, 9)

　　2、while循环

　　和R中的while语法相似，在Scala中while循环的格式同样为：

　　while(条件表达式){

　　　　循环体

　}

scala> var i = 1
while(i <= 10){print(i+" ")i += 1
}
i: Int = 1scala>      |      |      | 1 2 3 4 5 6 7 8 9 10

　　由于在Scala中没有自带break、continue两个关键字，所以要实现continue的功能可以使用if语句来控制，而要实现break功能，则需要调取相关包scala.util.control.Breaks._:

import scala.util.control.Breaks._object Main {def main(args: Array[String]): Unit = {var i = 1while(true){if(i >= 10){println("stop")break}else{i += 1println(i)}}}
}

　　3.do-while

　　do-while循环和while循环相似，区别在于do-while循环至少都会运行一次循环体内的代码，其使用格式如下：

　　do{

　　循环体内容

　　}while(条件表达式)

import scala.util.control.Breaks._object Main {def main(args: Array[String]): Unit = {var i = 1do{println(i)i += 1}while(i<=0)}
}

 

3.3异常控制

　　Scala中的异常控制与Java非常相似，处理抛出异常之外，还有捕获异常，这里我们只介绍捕获异常：

　　Scala中捕获异常的格式如下：

　　try{

           ... ...

　　}catch{

　　    case ex:错误类型 => 捕获指定错误后的执行内容

}

在catch中捕获异常或错误，可以像上面一样指定错误类型与对应的处理方法，也可以用case ex:Exception => 的方式来更加泛型的捕获任何错误：

import scala.io.Sourceobject Main {def main(args: Array[String]): Unit = {try{val file = Source.fromFile("F://test.txt")val lines = file.getLines()for(content <- lines){println(content)}}catch{case ex:Exception => println(ex)}finally {println("结束")}}
}

运行结果：

 

 

　　以上就是本文的全部内容，如有笔误，望指出。

 

 

 

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/feffery/p/9465531.html

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

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

相关文章

京东《未来科技趋势白皮书》，101页pdf

京东《未来科技趋势白皮书》，101页pdf

来源&#xff1a;专知2020年&#xff0c;疫情震荡全球&#xff0c;经济波动剧烈&#xff0c;无论是国家还是企业&#xff0c;都希望通过把握未来科技“脉搏”&#xff0c;驱散经济下行阴影&#xff0c;实现组织升级迭代。逝者如斯&#xff0c;新的十年&#xff0c;哪些关键技术…
阅读更多...
JSP中get和post请求方式的区别及乱码解决方法

JSP中get和post请求方式的区别及乱码解决方法

JSP中get和post请求方式的区别及乱码解决方法 get提交方式&#xff1a;默认method“get” 和 地址栏、超链接请求方式默认都属于get提交方式 form表单的method属性&#xff1a;提交服务器的http方法&#xff0c;一般为post和get get与post请求方式的区别&#xff1a; get方式 …
阅读更多...
RISC-V有何特别之处？

RISC-V有何特别之处？

作者&#xff1a;Erik Engheim译者&#xff1a;冬雨整理&#xff1a;陈思20 世纪 90 年代末&#xff0c;RISC 和 CISC 爆发了一场大战&#xff0c;自那以后&#xff0c;大家却说 RISC 和 CISC 的区别没那么重要了了。许多人表示&#xff0c;指令集也就那么回事&#xff0c;对 C…
阅读更多...
数据库存取BLOB类型音乐文件的过程及常见错误

数据库存取BLOB类型音乐文件的过程及常见错误

数据库存取BLOB类型音乐文件的过程及常见错误 数据库端的准备工作&#xff1a; 新建表&#xff0c;用来存放音乐文件&#xff1a;mymusic 第一列&#xff1a;id 类型&#xff1a;int 第二列&#xff1a;music 类型&#xff1a;blob 将音乐文件存入数据库 /*** */ package cn…
阅读更多...
Trie可持久化Trie

Trie可持久化Trie

WARNING&#xff1a;以下代码未经测试&#xff0c;若发现错误&#xff0c;欢迎指出qwq~ Trie树&#xff08;字典树&#xff09; 一种简单的数据结构&#xff0c;可存储大量字符串&#xff0c;可在$O(len)$的时间内完成插入&#xff0c;删除&#xff0c;查找等操作。 下面是一个…
阅读更多...
视觉的目的是什么？从监督学习到对比学习，回顾CV发展史

视觉的目的是什么？从监督学习到对比学习，回顾CV发展史

来源&#xff1a;AI科技评论作者&#xff1a; 周纵苇知乎摘要&#xff1a;视觉&#xff0c;对于人类或动物来说&#xff0c;似乎是一件稀松平常的事情&#xff0c;我们甚至都不需要去有意识地训练自己&#xff0c;就可以天赋一般地认识世界。对于机器而言&#xff0c;理解图片却…
阅读更多...
MVC原理及案例分析

MVC原理及案例分析

MVC原理及案例分析 关于MVC MVC全名是Model View Controller&#xff0c;是模型(model)&#xff0d;视图(view)&#xff0d;控制器(controller)的缩写&#xff0c;一种软件设计典范&#xff0c;用一种业务逻辑、数据、界面显示分离的方法组织代码&#xff0c;将业务逻辑聚集到…
阅读更多...
人工智能的鱼与熊掌：精度与可解释性

人工智能的鱼与熊掌：精度与可解释性

来源&#xff1a;陈德旺科学网博客链接地址&#xff1a;http://blog.sciencenet.cn/blog-57940-1270913.html 人工智能自1956年诞生之日&#xff0c;就肩负用计算机程序模拟人类&#xff08;或生物体&#xff09;智能的初心与使命&#xff0c;从而理解智能的工作原理与运作机制…
阅读更多...
MVC与三层架构的联系及三层架构实现学生注册功能

MVC与三层架构的联系及三层架构实现学生注册功能

MVC与三层架构的联系及三层架构实现学生注册功能 三层架构的逻辑关系&#xff1a; MVC和三层架构的联系&#xff1a; 三层架构实现学生注册功能的逻辑&#xff1a; 学生注册页面&#xff1a; 输入学生信息&#xff1a; 完成学生注册: 代码实现&#xff1a; add.jsp <% …
阅读更多...
MVC5+EF6 入门完整教程11--细说MVC中仓储模式的应用

MVC5+EF6 入门完整教程11--细说MVC中仓储模式的应用

MVC5EF6 入门完整教程11--细说MVC中仓储模式的应用 原文:MVC5EF6 入门完整教程11--细说MVC中仓储模式的应用摘要&#xff1a; 第一阶段1~10篇已经覆盖了MVC开发必要的基本知识。 第二阶段11&#xff5e;20篇将会侧重于专题的讲解&#xff0c;一篇文章解决一个实际问题。 根据…
阅读更多...
Java Web实现信息管理

Java Web实现信息管理

Java Web实现信息管理 前言&#xff1a; 大二上学期刚学完Oracle&#xff0c;老师就要求用Java语言操作Oracle&#xff0c;当时真的是懵了。回顾自己前两年的生活&#xff0c;大一上学期学习C语言&#xff0c;下学期学习Java&#xff0c;当时教课老师是学硬件的。课上讲一些理…
阅读更多...
计算机科学界至今未解决的四大难题

计算机科学界至今未解决的四大难题

作者&#xff1a;Shalitha Suranga译者&#xff1a;弯月 责编&#xff1a;张文出品&#xff1a;CSDN&#xff08;ID&#xff1a;CSDNnews&#xff09;在现实生活中&#xff0c;很多难题的解决方案都用到了计算机科学的基础理论。例如&#xff0c; Git 分布式版本控制系统建立…
阅读更多...
按字编址与按字节编址

按字编址与按字节编址

按字编址与按字节编址 要清楚按字编址和按字节编址的区别&#xff0c;先要知道 比特(bit)&#xff0c;字节(byte)&#xff0c;字(word) 之间的关系。 在计算机系统中&#xff0c;总线以固定大小的一块数据进行传输&#xff0c;这一块的数据也称为字(word)&#xff0c;如今的计…
阅读更多...
2021年AI关键趋势，AI芯片初创公司可能发生并购

2021年AI关键趋势，AI芯片初创公司可能发生并购

来源&#xff1a;雷锋网作者&#xff1a;包永刚编译&#xff1a;雷锋网人工智能&#xff08;AI&#xff09;和机器学习仍然是技术决策者、行业人士和投资者关注的重点。标普全球市场财智&#xff08;S&P Intelligence&#xff09;2020 7月发布的调查显示&#xff0c;有58%的…
阅读更多...
CPU组成结构

CPU组成结构

CPU组成结构 CPU总体构图 CPU中央处理器&#xff08;Central Processing Unit&#xff09; CPU的结构框图&#xff1a;CPU内部由ALU&#xff08;算术逻辑单元&#xff09;、CU&#xff08;控制器&#xff09;、寄存器&#xff08;PC、IR、PSW、DR、通用寄存器等&#xff09;、…
阅读更多...
每一个科学家的内心都住着一位哲学家（节选）

每一个科学家的内心都住着一位哲学家（节选）

来源&#xff1a;腾讯大学&#xff08;ID: tencent_university)作者&#xff1a;张首晟&#xff08;斯坦福大学&#xff09;不少科学家的哲学造诣都很高。在哲学中&#xff0c;有着正负对立的世界观&#xff1a;有阴必有阳、有正必有负、有天使就会有魔鬼。这种哲学观念是如何在…
阅读更多...
总结下载Spring Framework的jar包

总结下载Spring Framework的jar包

总结下载Spring Framework的jar包 下载官网&#xff1a;Spring官网
阅读更多...
ros2中gazebo安装的注意事项

ros2中gazebo安装的注意事项

Install From source&#xff08;推荐安装Fortress版本&#xff0c;好像很方便&#xff09; ROS Be sure youve installed ROS Humble (at least ROS-Base). More ROS dependencies will be installed below. Gazebo Install either Edifice, Fortress, or Garden.(没有har…
阅读更多...
谷歌对2021年的六个预测：数据和云技术的革命即将到来

谷歌对2021年的六个预测：数据和云技术的革命即将到来

来源&#xff1a;AI前线作者&#xff1a;Debanjan Saha译者&#xff1a;平川策划&#xff1a;钰莹预测是充满挑战的&#xff0c;因为具体的预测取决于特定的时间框。但从云应用方面表现出的趋势来说&#xff0c;我们 2020 年看到的一些事情可能预示着 2021 年可能出现的变化。经…
阅读更多...
Vue笔记：webpack项目vue启动流程

Vue笔记：webpack项目vue启动流程

VUE启动流程 1. package.json 在执行npm run dev的时候&#xff0c;会在当前目录中寻找 package.json 文件, 有点类似 Maven 的 pom.xml 文件&#xff0c;包含项目的名称版本、项目依赖等相关信息。 {　# 版本信息"name": "kitty-ui","version":…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023