Goland 2020最新激活码-Golang

“

本文将给大家提供一款工具给Goland续续命，如果你的也到期了，那就拿起小板凳一起来看看。”

当你看到这篇文章时，就说明你的问题已经解决了。

均可激活。一键操作即可成功激活到2089年，特殊情况激活不了的，咔咔也不知道原因哈!不用在私聊或者评论区了。

之前续命过一次，但是莫名其妙的今天给到期了，然后无情的显示了下图(这个已经是激活过了的，界面还是这个样子)

到期图

看了几个解决方法，点进去就是购买插件链接，让我买插件激活？那是不可能的，这辈子都不可能。

看下图，选择免费使用30天，然后点击即可。

选择30天免费试用

此时问题就可以来到跟咔咔第一幅图的位置一样了，看下图。

激活

点击后就会出现咔咔文章头部的第一幅图，在这个位置填上激活码就可以了。

激活码

其实这个时候大家应该看到咔咔的到期时间是2089年了，这个是咔咔已经激活成功的。

你们在哪里看是否激活成功呢！第一种方式就是复制了激活码看是否显示无效激活码，第二种方式如下图。

到期时间

激活码奉上，可直接使用，如果使用不了也不用私聊咔咔，获取评论什么的，那就另寻出路哈！

咔咔也给你解决不了。“

JQE11SV0BR-eyJsaWNlbnNlSWQiOiJKUUUxMVNWMEJSIiwibGljZW5zZWVOYW1lIjoicGlnNiIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IklJIiwiZmFsbGJhY2tEYXRlIjoiMjA4OS0wNy0wNyIsInBhaWRVcFRvIjoiMjA4OS0wNy0wNyJ9LHsiY29kZSI6IkFDIiwiZmFsbGJhY2tEYXRlIjoiMjA4OS0wNy0wNyIsInBhaWRVcFRvIjoiMjA4OS0wNy0wNyJ9LHsiY29kZSI6IkRQTiIsImZhbGxiYWNrRGF0ZSI6IjIwODktMDctMDciLCJwYWlkVXBUbyI6IjIwODktMDctMDcifSx7ImNvZGUiOiJQUyIsImZhbGxiYWNrRGF0ZSI6IjIwODktMDctMDciLCJwYWlkVXBUbyI6IjIwODktMDctMDcifSx7ImNvZGUiOiJHTyIsImZhbGxiYWNrRGF0ZSI6IjIwODktMDctMDciLCJwYWlkVXBUbyI6IjIwODktMDctMDcifSx7ImNvZGUiOiJETSIsImZhbGxiYWNrRGF0ZSI6IjIwODktMDctMDciLCJwYWlkVXBUbyI6IjIwODktMDctMDcifSx7ImNvZGUiOiJDTCIsImZhbGxiYWNrRGF0ZSI6IjIwODktMDctMDciLCJwYWlkVXBUbyI6IjIwODktMDctMDcifSx7ImNvZGUiOiJSUzAiLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiUkMiLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiUkQiLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiUEMiLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiUk0iLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiV1MiLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiREIiLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiREMiLCJmYWxsYmFja0RhdGUiOiIyMDg5LTA3LTA3IiwicGFpZFVwVG8iOiIyMDg5LTA3LTA3In0seyJjb2RlIjoiUlNVIiwiZmFsbGJhY2tEYXRlIjoiMjA4OS0wNy0wNyIsInBhaWRVcFRvIjoiMjA4OS0wNy0wNyJ9XSwiaGFzaCI6IjEyNzk2ODc3LzAiLCJncmFjZVBlcmlvZERheXMiOjcsImF1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsImlzQXV0b1Byb2xvbmdhdGVkIjpmYWxzZX0=-khgsQrnDiglknF0m+yyoYGJXX4vFE3IIVaoMd0bkpfAlMiYM4FUK1JM7uMnVSN0NBC7qtZjYlNzPscEyKE8634uGuY/uToFQnIOCtyUfBxB6j0wF/DcCjhKMNDbnJ1RKZ2VaALuC9B6d6lhtEKm9+urXWTBq7h2VfIBv5wk1Ul9T/m9Dwkz/LccTqnxO0PP288fF13ZbmcLI1/D0dqp/QxYshW6CLR+2Tvk6QCPoaOTKDU/eL1AssD7/mO1g2ZJA+k//8qfRMLgdLmLrMdyiaIhrsM/jJk2qDfTaMcCNylkWXLgKwSvEQG95IhitLN9+GQ4pBW3gOTNl82Gem7jEkA==-MIIElTCCAn2gAwIBAgIBCTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTE4MTEwMTEyMjk0NloXDTIwMTEwMjEyMjk0NlowaDELMAkGA1UEBhMCQ1oxDjAMBgNVBAgMBU51c2xlMQ8wDQYDVQQHDAZQcmFndWUxGTAXBgNVBAoMEEpldEJyYWlucyBzLnIuby4xHTAbBgNVBAMMFHByb2QzeS1mcm9tLTIwMTgxMTAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA5ndaik1GD0nyTdqkZgURQZGW+RGxCdBITPXIwpjhhaD0SXGa4XSZBEBoiPdY6XV6pOfUJeyfi9dXsY4MmT0D+sKoST3rSw96xaf9FXPvOjn4prMTdj3Ji3CyQrGWeQU2nzYqFrp1QYNLAbaViHRKuJrYHI6GCvqCbJe0LQ8qqUiVMA9wG/PQwScpNmTF9Kp2Iej+Z5OUxF33zzm+vg/nYV31HLF7fJUAplI/1nM+ZG8K+AXWgYKChtknl3sW9PCQa3a3imPL9GVToUNxc0wcuTil8mqveWcSQCHYxsIaUajWLpFzoO2AhK4mfYBSStAqEjoXRTuj17mo8Q6M2SHOcwIDAQABo4GZMIGWMAkGA1UdEwQCMAAwHQYDVR0OBBYEFGEpG9oZGcfLMGNBkY7SgHiMGgTcMEgGA1UdIwRBMD+AFKOetkhnQhI2Qb1t4Lm0oFKLl/GzoRykGjAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBggkA0myxg7KDeeEwEwYDVR0lBAwwCgYIKwYBBQUHAwEwCwYDVR0PBAQDAgWgMA0GCSqGSIb3DQEBCwUAA4ICAQBonMu8oa3vmNAa4RQP8gPGlX3SQaA3WCRUAj6Zrlk8AesKV1YSkh5D2l+yUk6njysgzfr1bIR5xF8eup5xXc4/G7NtVYRSMvrd6rfQcHOyK5UFJLm+8utmyMIDrZOzLQuTsT8NxFpbCVCfV5wNRu4rChrCuArYVGaKbmp9ymkw1PU6+HoO5i2wU3ikTmRv8IRjrlSStyNzXpnPTwt7bja19ousk56r40SmlmC04GdDHErr0ei2UbjUua5kw71Qn9g02tL9fERI2sSRjQrvPbn9INwRWl5+k05mlKekbtbu2ev2woJFZK4WEXAd/GaAdeZZdumv8T2idDFL7cAirJwcrbfpawPeXr52oKTPnXfi0l5+g9Gnt/wfiXCrPElX6ycTR6iL3GC2VR4jTz6YatT4Ntz59/THOT7NJQhr6AyLkhhJCdkzE2cob/KouVp4ivV7Q3Fc6HX7eepHAAF/DpxwgOrg9smX6coXLgfp0b1RU2u/tUNID04rpNxTMueTtrT8WSskqvaJd3RH8r7cnRj6Y2hltkja82HlpDURDxDTRvv+krbwMr26SB/40BjpMUrDRCeKuiBahC0DCoU/4+ze1l94wVUhdkCfL0GpJrMSCDEK+XEurU18Hb7WT+ThXbkdl6VpFdHsRvqAnhR2g4b+Qzgidmuky5NUZVfEaZqV/g==”“

坚持学习、坚持写博、坚持分享是咔咔从业以来一直所秉持的信念。希望在偌大互联网中咔咔的文章能带给你一丝丝帮助。我是咔咔，下期见。”

golang结构体怎么判断是否为空

golang结构体怎么判断为空？就是判断是否已经初始化，方法如下：

可以使用if objectA== (structname{}){ // your code }，进行判断。

示例代码如下：

package mainimport ( "fmt" "reflect")type A struct{ name string age int}func (a A) IsEmpty() bool { return reflect.DeepEqual(a, A{})}func main() { var a A if a == (A{}) { // 括号不能去 fmt.Println("a == A{} empty") } if a.IsEmpty() { fmt.Println("reflect deep is empty") }}

更多编程教程，请关注小兔网！

　　以上就是golang结构体怎么判断是否为空的知识。速戳>>知识兔学习精品课！

Map是一种无序的键值对的集合。Map最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值。

Map是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map是无序的，我们无法决定它的返回顺序，这是因为Map是使用hash表来实现的。

golang中判断map是否为空的方法如下：

具体代码如下：

if len(map) == 0 { ....}

更多golang知识请关注小兔网golang教程栏目。

　　以上就是golang怎么判断map是否为空的知识。速戳>>知识兔学习精品课！

升级Golang

主要步骤：

1、卸载旧版本

2、下载新版本

3、安装新版本

4、配置环境变量

详细步骤：

1、卸载旧版本

首先，执行 go env，列出关于go的环境信息，查看 GOROOT 的值，其一般代表go的安装路径；如：

GOROOT="/usr/local/go"

之后，

如果之前是通过 yum 或者 apt-get 安装的go，则执行相关的代码卸载它：

yum remove goapt-get remove go

如果是通过手工直接安装（也就是通过复制到某个目录安装），则可以根据 GOROOT 提供的路径，直接删除go的文件夹:

rm -r /usr/local/go

2、下载新版本

到官网下载最新版本，比如 go1.11.linux-amd64.tar.gz

3、安装新版本

解压缩：tar zxvf go1.11.linux-amd64.tar.gz

得到 go 的文件夹后，将其移动或者复制到刚刚获取的 go 安装路径上：

mv https://xiaotua.com/103/go /usr/local/

4、配置环境变量

将go的可执行文件的路径添加到PATH中：

export PATH="/usr/local/go/bin:$PATH"

如果上一个版本的路径与其相同，则不用重复添加。

更多golang知识请关注golang教程栏目。

　　以上就是golang如何升级？的知识。速戳>>知识兔学习精品课！

下面由golang教程栏目给大家介绍解决GO语言安装air框架时遇到go: inconsistent vendoring问题的方法，希望对需要的朋友有所帮助！

解决GO语言安装air框架时遇到go: inconsistent vendoring问题-Golang

在GO中安装air框架时遇到的问题

使用VS Code时，我想要安装air框架以支持web网页热重载功能，但是安装时报错go: inconsistent vendoring，终止了我运行air。问课程的老师，老师也说是第一次遇到，后来我找到了解决方案。

一. 原因

知识兔

该情况是由于gopath路径和goroot路径一致的原因导致的。

二. 解决方案

知识兔

修改GOPAHT，改到非GOROOT路径。GOROOT是GO语言安装路径，GOPATH是GO语言编译环境所需路径，因此二者不能为同一路径。修改后，通过go mod init重载mod，再执行air，就可以成功了。

　　以上就是解决GO语言安装air框架时遇到go: inconsistent vendoring问题的知识。速戳>>知识兔学习精品课！

在工作的项目中，我的主要开发语言是php，因需求或者为弥补php的缺陷，需要为php做各种各样的扩展，比如php本身不支持线程，没有队列,进程也不无法用于生产环境，可以说php没有任何“程”，因而网上有较多的文章阐述如何实现php队列，多线程等等，在我的理解，与其用php本身实现这种无法保证健壮的特性，不如去发掘运用一些本身集成，且表现优异的语言。

微博中了解到了golang语言， golang的语法类似 C和python，有这两种语言经验的同学入门会比较顺利! golang语言的优点在这里就不一一阐述了！！学习了一段时间之后，维护的业务正好遇到瓶颈,另因我维护的业务属于接口层，逻辑比较简单，只输出json数据，所以开始着手利用golang重构现有系统，改造中，因部分同事对golang比较怀疑，另外网上的性能对比，大部分只是hello word输出，参考意义很小，所以利用线上两台内网机器，做了一次php和golang的正式业务性能对比

服务器配置： 16核 E5620 @ 2.40GHz 11G内存业务包含：DB（oracle）和 redis查询，当有缓存之后，DB不再查询，直接读取redis, 批量查询两个主键

使用apache的ab测试并发200，个请求

golang 并发测试golang的qps 大约在 9675/s, 最高/s 左右，cpu利用率高峰在10.6% 上下golang开启了多核，并且维护了40个redis连接池

上面php的链接是golang的url重写，为了兼容php的项目，不要误解!

PHP并发测试php的QPS大约是 1726/s, 最高2100/s 左右, cpu 高峰在50.1% 比较恐怖

另外也测试了更多主键的批量查询， golang的处理能力降到 4700/s, php到 1078/s, 将ab并发加到400时， php开始出现请求失败的情况，golang的并发加到2500后，惊讶其表现依然出色，有怀疑的可以自行测试

上面的测试结果得出的结论: 因多核利用，golang的”多线程”, 还有redis连接池，使得go在和php并发对比中遥遥领先，处理能力大约是php的4倍

所以建议维护着请求量较大，遇到瓶颈项目的同学可以尝试使用golang改善!

　　以上就是go 为什么比php性能高的知识。速戳>>知识兔学习精品课！

Slice删除元素的本质

Go语言并没有提供用于删除元素的语法或接口，而是通过利用切片本身的特性来删除元素——追加元素。即以被删除元素为分界点，将前后两个部分的内存重新连接起来。

使用切片的追加(append)特性，利用代码实现。

Slice删除元素的实现：

由于切片没有语法糖实现删除，因此利用其追加元素的特性完成元素的删除操作；通过内建函数 append() 实现对单个元素以及元素片段的删除。

具体的思路就是

具体的代码实现如下所示:

// 从切片中删除元素 func SliceDelete() { // 初始化一个新的切片 seq seq := []string{"a", "b", "c", "d", "e", "f", "g"} // 指定删除位置 index := 3 // 输出删除位置之前和之后的元素 fmt.Println(seq[:index], seq[index+1:]) // seq[index+1:]... 表示将后段的整个添加到前段中 // 将删除前后的元素连接起来 seq = append(seq[:index], seq[index+1:]...) // 输出链接后的切片 fmt.Println(seq) } OutPut Result:[a b c] [e f g][a b c e f g]

Slice删除元素的操作过程

a b c d e f g ------------------------------------- | | ↓ seq[:index] ↓ seq[index+1:] a b c e f g ------------- ------------- | | | | ↓ ↓ a b c e f g ---------------------------------- append(seq[:index], seq[index+1:]...)

更多golang知识请关注golang教程栏目。

　　以上就是golang如何删除数组中的元素的知识。速戳>>知识兔学习精品课！

Gin是一个go写的web框架，具有高性能的优点。

一.安装

使用go下载gin库，命令行输入:go get github.com/gin-gonic/gin ，一般使用需要的依赖：

import "github.com/gin-gonic/gin"import "net/http"

二:基本应用

1.gin.Context中的Query方法:get的URL传参

package main import ( "github.com/gin-gonic/gin" "net/http") func getQuery(context *gin.Context){ userid := context.Query("userid") username := context.Query("username") context.String(http.StatusOK,userid+" "+username)}func main(){ // 注册一个默认路由器 router := gin.Default() //注册GET处理 router.GET("/user", getQuery) //默认8080端口 router.Run(":8088")}

浏览器输出:

5 xiaoming

2.gin.Context中的Param方法:RESRful风格URL传参

package main import ( "github.com/gin-gonic/gin" "net/http") func getParam(context *gin.Context){ userid := context.Param("userid") username := context.Param("username") context.String(http.StatusOK,userid+" "+username)}func main(){ // 注册一个默认路由器 router := gin.Default() //注册GET处理 //router.GET("/user", getQuery) router.GET("/user/:userid/:username",getParam) //默认8080端口 router.Run(":8088")}

补充:/:varname必须匹配对应的,/*varname匹配后面的所有,同时不能用多个,否则编译报错

页面输出:

5 xiaoming

　　以上就是gin是什么意思？的知识。速戳>>知识兔学习精品课！

下面由golang教程栏目给大家介绍Golang如何连接Ldap，希望对需要的朋友有所帮助！

今天在这里写一些Golang怎么连接ldap

golang的ldap包有一些，我使用的是

go get -u "gopkg.in/ldap.v2"

我的ldap环境:

rootdn: uid=admin,dc=wjq,dc=com password: openldap

dn: dc=wjq,dc=comdc: wjqobjectClass: topobjectClass: domaindn: ou=Group,dc=wjq,dc=comou: GroupobjectClass: topobjectClass: organizationalUnitdn: ou=People,dc=wjq,dc=comou: PeopleobjectClass: topobjectClass: organizationalUnitdn: uid=admin,dc=wjq,dc=comuid: adminobjectClass: topobjectClass: account

一个组和一个用户:

#组信息dn: cn=test,ou=Group,dc=wjq,dc=comgidNumber: 1003cn: testobjectClass: posixGroup#用户信息dn: uid=test,ou=People,dc=wjq,dc=comuidNumber: 1009gidNumber: 1003gecos: testhomeDirectory: /home/testuid: testshadowMin: 0shadowMax: shadowWarning: 7loginShell: /bin/bashshadowInactive: -1shadowExpire: -1shadowFlag: -1objectClass: posixAccountobjectClass: shadowAccountobjectClass: accountcn: testuserPassword:: e1NTSEF9d053TWhYRTR4STJUUmpJWm5MTkF4VFlBTFhJdStaZ0Q=shadowLastChange:

golang处理步骤如下:

1. ldap.Dail #这一步是底层的连接上

2. ldap.Bind #类似于用户名密码认证

3.操作比如查询，删除，增加用户

第一步: Dail

Dail有两个参数 network, address, 返回 (*Conn, error)

network: 是指网络协议 tcp, udp

address: 是底层要连接的地址，需要带端口号

con, err := ldap.Dial("tcp", "127.0.0.1:389")

第二步: 认证

Bind(rootdn, password) (error)

berror := conn.Bind("uid=admin,dc=wjq,dc=com", "openldap")

第三步: 操作;

操作很有特点，我觉得也许是golang语言的特点，比如

查询， ldap提供一个查询的结构体 -- ldap.NewSearchRequest，只要我们把数据填充进去，然后调用ldap.Search

添加, ldap提供一个添加的结构体 -- ldap.NewAddRequest, 填充好数据，然后调用 ldap.Add

删除, ldap提供删除结构体 -- ldap. NewDelRequest, 然后调用ldap.Del

用户密码修改, ldap提供修改用户密码的结构体 -- ldap.NewPasswordModifyRequest , 然后调用ldap.PasswordModify

这个非常有特点，来看看:

查询用户组NewSearchRequest:

func NewSearchRequest( BaseDN string, Scope, DerefAliases, SizeLimit, TimeLimit int, TypesOnly bool, Filter string, Attributes []string, Controls []Control,) *SearchRequest

BaseDN: 根据我的ldap环境应该是 ou=Group,dc=wjq,dc=com

scope: 我理解的是查询的范围，ldap是一个目录树，我一般设置 ldap.ScopeWholeSubtree

DerefAiases：在搜索中别名(cn, ou)是否废弃，设置: ldap.NeverDerefAliases

SizeLimit: 大小设置,一般设置为0

TimeLimit: 时间设置,一般设置为0

TypesOnly: 设置false（好像返回的值要多一点）

Controls: 是控制我没怎么用过,一般设置nil

这些我也没理解透详细可以参考: https://tools.ietf.org/html/rfc4511

查询中主要的两个参数 Filter， Attributes

Filter 是过滤条件

Attributes 返回的属性值

建立SearchRequest结构体:

srsql := ldap.NewSearchRequest("ou=Group,dc=wjq,dc=com", ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false, "(&(objectClass=posixGroup))", []string{"dn", "cn", "uid"}, nil)

Filter: (&objectClass=posixGroup)）查找所有group,返回每个组的dn, cn, uid

过滤test用户组: (&(objectClass=posixGroup)(cn=test))

过滤用户cn=test,或者uid=test(当然baseDn是用户的): "(|(&(objectClass=posixAccount)(cn=test))(&(objectClass=posixAccount)(uid=test)))"

执行Search并且获取结果(在cur.Entries中)：

cur, er := l.Search(srsql)if er != nil {log.Fatalln(er)}if (len(cur.Entries) > 0){for _, item := range cur.Entries {cn := item.GetAttributeValue("cn")if cn == "" {cn = item.GetAttributeValue("uid")}fmt.Println(cn)}}

以上就是Search的步骤。

在来看看添加用户: NewAddRequest

添加

用户: wujq

password:

家目录: /home/wujq

所属的组: test (id=1003)

1. 首先确认我需要添加的用户dn: uid=wujq,ou=People,dc=wjq,dc=com

2. gidNumber 是 1003

3. 因为需要uidNumber值，假设我设置为1010(系统没有使用)

执行代码如下:

sql := ldap.NewAddRequest("uid=wujq,ou=People,dc=wjq,dc=com")sql.Attribute("uidNumber", []string{"1010"})sql.Attribute("gidNumber", []string{"1003"})sql.Attribute("userPassword", []string{""})sql.Attribute("homeDirectory", []string{"/home/wujq"})sql.Attribute("cn", []string{"wujq"})sql.Attribute("uid", []string{"wujq"})sql.Attribute("objectClass", []string{"shadowAccount", "posixAccount", "account"})er := ldapcon.Add(sql)

　　以上就是Golang如何连接Ldap的知识。速戳>>知识兔学习精品课！

下面由golang教程栏目给大家介绍golang类型断言，希望对需要的朋友有所帮助！

在php中有一个 serialize() 函数可以把数组序列化成字符串进行存储和传输

如果想反序列化这种字符串，在php中只需要一个简单的unserialize() 函数就可以完成了.但是在golang中可就没有这么容易了，非得费个九牛二虎之力，写上不少代码才行。

这时候只想感叹一下，php真的是世界上最好的语言啊！

我就在今天的开发中遇到了这么个问题，需要使用golang去解析php序列化的字符串，在github上找了个解析的包，但是发现解析之后的结果是个interface{}类型。

顿时我就无从下手了，总在想数据实际上是一个map，但是解析后得到一个interface{} ，这让我怎么用啊

感觉需要用类型断言，但又不太会用，遂去社区问一下吧，期望大佬们能给个答案。

实际上确实很管用。

下面贴一下代码：

package mainimport ("github.com/yvasiyarov/php_session_decoder/php_serialize""fmt""log")func main() { // 序列化后的字符串str := `a:3:{s:4:"name";s:3:"tom";s:3:"age";s:2:"23";s:7:"friends";a:2:{i:0;a:1:{s:4:"name";s:5:"jerry";}i:1;a:1:{s:4:"name";s:4:"jack";}}}` // 反序列化 decoder := php_serialize.NewUnSerializer(str)if result, err := decoder.Decode(); err != nil {panic(err)} else { // 此处进行类型断言decodeData, ok := result.(php_serialize.PhpArray)if !ok {log.Println(err)} // 断言后，即可获取内容name := decodeData["name"]age := decodeData["age"]fmt.Println(name, age) // 内层数据仍需再次断言friends, ok := decodeData["friends"].(php_serialize.PhpArray)if !ok {log.Println(err)} // 断言成功后即可获取内部数据for _,v := range friends {fmt.Printf("type:%T, value:%+v

", v,v )friend, ok := v.(php_serialize.PhpArray)if !ok {log.Println(err)}friendName := friend["name"]fmt.Println(friendName)}}}

可以粗暴的这么理解：一个变量是什么类型，就进行什么类型的断言，断言后，即可得到结果

怎么判断一个变量的类型？

打印出来呀：fmt.Printf("%T", verb)

%T这个占位符可以显示变量的类型

下面还有个示例：

", t)case php_serialize.PhpArray:fmt.Println(t)fmt.Println(t["name"])fmt.Println(t["age"])switch f := t["friends"].(type) {default:fmt.Printf("unexpected type %T

", t)case php_serialize.PhpArray:fmt.Println(f)fmt.Println(f[0])fmt.Println(f[1])}}}

上面两个demo都可以达到效果，只是写法不同。

后面我又经人介绍，得到了另外一个包，也能达到效果：

package mainimport ("fmt""log""github.com/wulijun/go-php-serialize/phpserialize")func main() {str := `a:3:{s:4:"name";s:3:"tom";s:3:"age";s:2:"23";s:7:"friends";a:2:{i:0;a:1:{s:4:"name";s:5:"jerry";}i:1;a:1:{s:4:"name";s:4:"jack";}}}`decodedRes, err := phpserialize.Decode(str)if err != nil {panic(err)}//fmt.Printf("%T

", decodedRes) //type is map[interface{}]interface{}//type assertdecodedData, ok := decodedRes.(map[interface{}]interface{})if !ok {fmt.Printf("unexpected type %T

", decodedRes)}fmt.Println(decodedData["name"])fmt.Println(decodedData["age"])//fmt.Printf("%T

", decodedData["friends"]) // type is map[interface{}]interface{}// type assertfriendsRes, ok := decodedData["friends"].(map[interface{}]interface{})if !ok {fmt.Printf("unexpected type %T

", decodedData["friends"])}for _,v := range friendsRes {//fmt.Printf("type: %T, val: %#v

", v,v) // type is map[interface{}]interface{}friend, ok := v.(map[interface{}]interface{})if !ok {fmt.Printf("unexpected type %T

", decodedData["friends"])}//fmt.Printf("type: %T, val: %#v

", friend,friend) // type is map[interface{}]interface{}fmt.Println(friend["name"])}}

这个包解析出来的所有结果的类型都是map[interface{}]interface{},所以做类型断言的时候可以简单粗暴一些。

　　以上就是了解学习golang类型断言的知识。速戳>>知识兔学习精品课！

下面由golang教程栏目给大家介绍goLang进行调试操作方法，希望对需要的朋友有所帮助！

今天去了一个 studygoLang 发现blog让收录一篇。不错的开始。

然后发现有人发了一个debug的一个玩意。说真的不清楚这货是从哪里粘贴过来了。看不明白。

只能靠自己找找了。后面找到了他的 github 地址。

go get github.com/mailgun/godebuggo install github.com/mailgun/godebug

安装完成后。运行一下 godebug命令看看

package mainimport ("fmt")func main() {_ = "brakpoint"x := "debugger"debug_funtion(x)debug_value_save(x)fmt.Println(x)}func debug_funtion(x string) {fmt.Printf("x=,%s!

", x)}func debug_value_save(x string) {x = "sssss"fmt.Printf("goodbye,%s!

", x)}

写了点code .但是用 godebug 运行也就多了个 debugger 也不明白这个玩意怎么玩。

后面折腾一下。再来补充。

　　以上就是goLang进行调试操作方法的知识。速戳>>知识兔学习精品课！

下面由golang教程栏目给大家介绍简单的golang Logrus使用教程，希望对需要的朋友有所帮助！

golang Logrus简易使用教程

使用Logrus的最简单方法：

package mainimport ( log "github.com/sirupsen/logrus")func main() { log.WithFields(log.Fields{ "animal": "walrus", }).Info("A walrus appears")}

请注意，它与stdlib记录器完全api兼容，因此您可以在log任何地方替换导入，log "github.com/sirupsen/logrus" 。也可以自定义所有内容：

package mainimport ( "os" log "github.com/sirupsen/logrus")func init() { // Log 为JSON而不是默认的ASCII格式。 log.SetFormatter(&log.JSONFormatter{}) // 输出到标准输出，而不是默认的标准错误 //可以是任何io.Writer，请参阅下面的文件例如日志。 log.SetOutput(os.Stdout) // 仅记录严重警告以上。 log.SetLevel(log.WarnLevel)}func main() { log.WithFields(log.Fields{ "animal": "walrus", "size": 10, }).Info("A group of walrus emerges from the ocean") log.WithFields(log.Fields{ "omg": true, "number": 122, }).Warn("The group's number increased tremendously!") log.WithFields(log.Fields{ "omg": true, "number": 100, }).Fatal("The ice breaks!") // 一种常见的模式是通过重用 //从WithFields返回的logrus.Entry 来重用日志记录语句之间的字段 contextLogger := log.WithFields(log.Fields{ "common": "this is a common field", "other": "I also should be logged always", }) contextLogger.Info("I'll be logged with common and other field") contextLogger.Info("Me too")}

对于更高级的用法，对于一个大型项目，往往需要一个全局的logrus实例，即logger对象，来记录项目所有的日志。示例如下：

package mainimport ( "os" "github.com/sirupsen/logrus")// 创建记录器的一个新实例。您可以有任意多个实例var log = logrus.New()func main() { // 用于设置属性的API与程序包级别 // 导出的记录器有些不同。见Godoc。 log.Out = os.Stdout // 您可以将其设置为任何`io.Writer` // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) // if err == nil { // log.Out = file // } else { // log.Info("Failed to log to file, using default stderr") // } log.WithFields(logrus.Fields{ "animal": "walrus", "size": 10, }).Info("A group of walrus emerges from the ocean")}

Fields:

Logrus鼓励通过日志记录字段而不是冗长且无法解析的错误消息进行仔细的结构化日志记录。例如，代替：log.Fatalf("Failed to send event %s to topic %s with key %d")，您应该使用：

log.WithFields(log.Fields{ "event": event, "topic": topic, "key": key,}).Fatal("Failed to send event")

我们发现此API会迫使您考虑以产生更多有用日志消息的方式进行日志记录。我们曾经遇到过无数种情况，在该情况下，仅向已存在的日志语句添加一个字段就可以为我们节省时间。该WithFields呼叫是可选的。

通常，使用Logrus使用printf-family函数中的任何一个应被视为提示，您应该添加一个字段，但是，您仍然可以将 printf-family函数与Logrus一起使用。

默认字段

将字段始终附加到应用程序或应用程序的一部分中的日志语句通常会很有帮助。例如，您可能希望始终在请求的上下文中记录 request_id和user_ip。无需log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})在每一行上都写，而是可以创建一个logrus.Entry传递：

requestLogger := log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})requestLogger.Info("something happened on that request") # will log request_id and user_iprequestLogger.Warn("something not great happened")

Hooks

您可以添加用于日志记录级别的挂钩。例如，将错误发送到上的异常跟踪服务Error，Fatal并将Panic信息发送到StatsD或同时记录到多个位置，例如syslog。

Logrus带有内置挂钩。在其中添加这些或您的自定义钩子 init：

import ( log "github.com/sirupsen/logrus" "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "airbrake" logrus_syslog "github.com/sirupsen/logrus/hooks/syslog" "log/syslog")func init() { // Use the Airbrake hook to report errors that have Error severity or above to // an exception tracker. You can create custom hooks, see the Hooks section. log.AddHook(airbrake.NewHook(123, "xyz", "production")) hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "") if err != nil { log.Error("Unable to connect to local syslog daemon") } else { log.AddHook(hook) }}

注意：Syslog钩子还支持连接到本地syslog（例如“ / dev / log”或“ / var / run / syslog”或“ / var / run / log”）。有关详细信息，请检查syslog挂钩README。

可以在此Wiki 页面中找到当前已知的服务挂钩的列表。

日志记录级别

Logrus具有七个日志记录级别：跟踪，调试，信息，警告，错误，严重和紧急。

log.Trace("Something very low level.")log.Debug("Useful debugging information.")log.Info("Something noteworthy happened!")log.Warn("You should probably take a look at this.")log.Error("Something failed but I'm not quitting.")// Calls os.Exit(1) after logginglog.Fatal("Bye.")// Calls panic() after logginglog.Panic("I'm bailing.")

您可以在上设置日志记录级别Logger，然后它将仅记录具有该严重性或更高严重性的条目：

// Will log anything that is info or above (warn, error, fatal, panic). Default.log.SetLevel(log.InfoLevel)

log.Level = logrus.DebugLevel如果应用程序具有调试或详细环境，则在其中进行设置可能会很有用。

参赛作品

除了添加的字段WithField或WithFields某些字段外，还会自动将其添加到所有日志记录事件中：

time。创建条目的时间戳。

msg。呼叫{Info,Warn,Error,Fatal,Panic}后传递到的日志消息AddFields。例如Failed to send event.

level。日志记录级别。例如info。

环境

Logrus没有环境概念。

如果希望只在特定环境中使用钩子和格式化程序，则应自己处理。例如，如果您的应用程序具有全局变量Environment，它是环境的字符串表示形式，则可以执行以下操作：

import ( log "github.com/sirupsen/logrus")init() { // do something here to set environment depending on an environment variable // or command-line flag if Environment == "production" { log.SetFormatter(&log.JSONFormatter{}) } else { // The TextFormatter is default, you don't actually have to do this. log.SetFormatter(&log.TextFormatter{}) }}

此配置是按logrus预期方式使用的，但是生产中的JSON仅在使用Splunk或Logstash等工具进行日志聚合时才有用。

格式化程序

内置的日志格式器是：

logrus.TextFormatter。如果stdout是tty，则以彩色记录事件，否则以彩色记录事件。

注意：要在没有TTY时强制输出彩色，请将ForceColors 字段设置为true。即使有TTY，也要不强制输出彩色，请将DisableColors字段设置为true。对于Windows，请参阅 github.com/mattn/go-colorable。

启用颜色后，默认情况下级别将被截断为4个字符。要禁用截断功能，请将DisableLevelTruncation字段设置为true。

输出到TTY时，以可视方式向下扫描所有级别均为相同宽度的列通常会很有帮助。通过在级别文本中添加填充，将PadLevelText字段设置为true启用此行为。

所有选项都在生成的文档中列出。

logrus.JSONFormatter。将字段记录为JSON。

所有选项都在生成的文档中列出。

第三方日志格式化程序：

FluentdFormatter。格式化可由Kubernetes和Google Container Engine解析的条目。

GELF。格式化条目，使其符合Graylog的GELF 1.1规范。

logstash。将字段记录为Logstash事件。

prefixed。显示日志条目源以及备用布局。

zalgo。调用Zalgo的力量。

nested-logrus-formatter。将对数字段转换为嵌套结构。

powerful-logrus-formatter。打印日志时获取文件名，日志行号和最新函数名称；Sava日志到文件。

caption-json-formatter。添加了人类可读标题的logrus消息json格式化程序。

您可以通过实现Formatter接口（需要一种Format方法）来定义格式化程序。Format需要一个*Entry。entry.Data是一种 Fields类型（map[string]interface{}），其中包含您的所有字段以及默认字段（请参见上面的条目部分）：

type MyJSONFormatter struct {}log.SetFormatter(new(MyJSONFormatter))func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) { // Note this doesn't include Time, Level and Message which are available on // the Entry. Consult `godoc` on information about those fields or read the // source of the official loggers. serialized, err := json.Marshal(entry.Data) if err != nil { return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err) } return append(serialized, '

'), nil}

记录为 io.Writer

Logrus可以转换为io.Writer。该作家是an的结尾，io.Pipe您有责任关闭它。

w := logger.Writer()defer w.Close()srv := http.Server{ // create a stdlib log.Logger that writes to // logrus.Logger. ErrorLog: log.New(w, "", 0),}

写入该写入器的每一行都将使用格式化程序和钩子以常规方式打印。这些条目的级别为info。

这意味着我们可以轻松覆盖标准库记录器：

logger := logrus.New()logger.Formatter = &logrus.JSONFormatter{}// Use logrus for standard log output// Note that `log` here references stdlib's log// Not logrus imported under the name `log`.log.SetOutput(logger.Writer())

日志轮换

Logrus不提供日志轮换。日志轮换应由logrotate(8)可以压缩和删除旧日志条目的外部程序（如）完成。它不应该是应用程序级记录器的功能。

　　以上就是简单的golang Logrus使用教程的知识。速戳>>知识兔学习精品课！

void方法是Java中一个不可实例化的占位符，当方法用void来修饰时表示没有返回值。它有两个作用分别为对函数参数的限定以及对函数返回值的限定

学习过Java的人都知道，在Java中void表示空的意思，它是Java中的关键字。，接下来在文章中将为大家具体介绍这个值的相关知识，具有一定的参考作用，希望对大家有所帮助

【推荐课程：Java教程】

void方法介绍

在Java中只有两种数据类型即基本数据类型和引用数据类型，而void是Java中的一个不可实例化的占位符类。当方法定义为void来修饰时表示没有返回值。

void的作用

（1）对函数参数的限定

如果函数是无参数的，那么应该将声明其参数为void。如下所示

int function（void） { return 1; }

当给它传递一个参数时就会报错，表明这个函数不接受任何参数。如果函数参数可以是任意类型指针，那么应该声明为void的原因如下：

float *p1; int *p2; p1 = p2;

编译器会报错，提示类型不能转换，那么为了编译通过我们加上强制类型转换 p1 = （float*）p2,这样就可以编译成功了。此时的void就不同了，它可以接受其他类型的东西

void *p1; int *p2; p1 =p2;

但这并不意味着p2 = p1也可以因此空类型也具有一定的包容性，而类型则没有包容性

（2）对函数返回值的限定

函数返回值也可以是void，如下案例所示

void* memcpy(void* desc, const void* src,size_t len)

这样任何类型的指针都可以传入memcpy中，这也体现了内存操作函数的意义，因为内存操作函数操纵的对象是一块内存区，而且不管这块内存区是什么样的类型，并且这个函数的返回值也是void

总结：以上就是本篇文章的全部内容了，希望对大家学习Java中的void有所帮助。

　　以上就是Java中void方法的详解的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于javafx中多场景的切换的方法介绍（附代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

前段时间在做javafx的应用程序，遇到一些坑。以本文记录之。(如有更好的解决办法欢迎评论,本人小白，轻喷)

1.问题

按照官方的中文文档，成功的运行了单一界面的表单登录。于是想自己试试多界面跳转，给按钮添加事件响应。可是怎么操作都报错，百度了许久没有解决办法。后来Google后找到了一个合适的解决办法。

2.代码

下面一段代码是我主程序界面fxml文件中，创建字符串的按钮

这是我通过下面方法解决的通过一个按钮动作弹出另一个界面。其中CreateString.fxml是弹出窗口的界面布局。

//创建字符串 @FXML protected void CreateStringOperation(ActionEvent event) throws IOException { Parent Operation_Parent = FXMLLoader.load(getClass().getResource("CreateString.fxml")); Scene Operation_Creating_Scene = new Scene(Operation_Parent); Stage CreateOperation_Stage = (Stage) ((Node) event.getSource()).getScene().getWindow(); CreateOperation_Stage.hide(); CreateOperation_Stage.setScene(Operation_Creating_Scene); CreateOperation_Stage.show(); }

　　以上就是javafx中多场景的切换的方法介绍（附代码）的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于Java多线程处理List数据的三个示例（代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

实例1：

解决问题：如何让n个线程顺序遍历含有n个元素的List集合

import java.util.ArrayList;import java.util.List;import org.apache.commons.lang3.ArrayUtils;public class Test_4 {/*** 多线程处理list** @param data 数据list* @param threadNum 线程数*/public synchronized void handleList(List<String> data, int threadNum) {int length = data.size();int tl = length % threadNum == 0 ? length / threadNum : (length/ threadNum + 1);for (int i = 0; i < threadNum; i++) {int end = (i + 1) * tl;HandleThread thread = new HandleThread("线程[" + (i + 1) + "] ", data, i * tl, end > length ? length : end);thread.start();}}class HandleThread extends Thread {private String threadName;private List<String> data;private int start;private int end;public HandleThread(String threadName, List<String> data, int start, int end) {this.threadName = threadName;this.data = data;this.start = start;this.end = end;}public void run() {List<String> subList = data.subList(start, end)/*.add("^&*")*/;System.out.println(threadName+"处理了"+subList.size()+"条！");}}public static void main(String[] args) {Test_4 test = new Test_4();// 准备数据List<String> data = new ArrayList<String>();for (int i = 0; i < 6666; i++) {data.add("item" + i);}test.handleList(data, 5);System.out.println(ArrayUtils.toString(data));}}

实例2：

List多线程并发读取读取现有的list对象

//测试读取List的线程类，大概34秒package com.thread.list; import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<String>(); Map<Long,Integer> map = new HashMap<Long,Integer>(); for(int i = 0;i<1000;i++){ list.add(""+i); } int pcount = Runtime.getRuntime().availableProcessors(); long start = System.currentTimeMillis(); for(int i=0;i<pcount;i++){ Thread t = new MyThread1(list,map); map.put(t.getId(),Integer.valueOf(i)); t.start(); try { t.join(); } catch (InterruptedException e) { e.printStackTrace(); } // System.out.println(list.get(i)); } System.out.println("----"+(System.currentTimeMillis() - start)); } }//线程类package com.thread.list; import java.util.List;import java.util.Map; public class MyThread1 extends Thread { private List<String> list; private Map<Long,Integer> map; public MyThread1(List<String> list,Map<Long,Integer> map){ this.list = list; this.map = map; } @Override public void run() { int pcount = Runtime.getRuntime().availableProcessors(); int i = map.get(Thread.currentThread().getId()); for(;i<list.size();i+=pcount){ System.out.println(list.get(i)); } } }

实例3：

多线程分段处理List集合

场景:大数据List集合,需要对List集合中的数据同标准库中数据进行对比,生成新增,更新,取消数据解决方案:

List集合分段,

动态创建线程池newFixedThreadPool

将对比操作在多线程中实现

public static void main(String[] args) throws Exception { // 开始时间 long start = System.currentTimeMillis(); List<String> list = new ArrayList<String>(); for (int i = 1; i <= 3000; i++) { list.add(i + ""); } // 每500条数据开启一条线程 int threadSize = 500; // 总数据条数 int dataSize = list.size(); // 线程数 int threadNum = dataSize / threadSize + 1; // 定义标记,过滤threadNum为整数 boolean special = dataSize % threadSize == 0; // 创建一个线程池 ExecutorService exec = Executors.newFixedThreadPool(threadNum); // 定义一个任务集合 List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>(); Callable<Integer> task = null; List<String> cutList = null; // 确定每条线程的数据 for (int i = 0; i < threadNum; i++) { if (i == threadNum - 1) { if (special) { break; } cutList = list.subList(threadSize * i, dataSize); } else { cutList = list.subList(threadSize * i, threadSize * (i + 1)); } // System.out.println("第" + (i + 1) + "组：" + cutList.toString()); final List<String> listStr = cutList; task = new Callable<Integer>() { @Override public Integer call() throws Exception { System.out.println(Thread.currentThread().getName() + "线程：" + listStr); return 1; } }; // 这里提交的任务容器列表和返回的Future列表存在顺序对应的关系 tasks.add(task); } List<Future<Integer>> results = exec.invokeAll(tasks); for (Future<Integer> future : results) { System.out.println(future.get()); } // 关闭线程池 exec.shutdown(); System.out.println("线程任务执行结束"); System.err.println("执行任务消耗了：" + (System.currentTimeMillis() - start) + "毫秒"); }

　　以上就是Java多线程处理List数据的三个示例（代码）的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于模拟HTTP请求调用controller的代码，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

写在前面

MockMvc实现了对Http请求的模拟，能够直接使用网络的形式，转换到Controller调用，这样使得测试速度更快，不依赖网络环境。而且提供了一套验证的工具。

单测代码如下：

@RunWith(SpringRunner.class)@WebMvcTest(MyController.class)public class MyControllerTest { @Autowired private MockMvc mockMvc; /** * 测试方法 */ private void bindAndUnbindTenantPoiTest() throws Exception { MvcResult mvcResult = mockMvc.perform(post(${"访问的url"}) .param("${key1}", "${value1}") .param("${key2}", "${value2}") .param("${key3}", "${value3}")) .andDo(print()) // 定义执行行为 .andExpect(status().isOk()) // 对请求结果进行验证 .andReturn(); // 返回一个MvcResult jsonObject = toJsonObject(mvcResult); assert jsonObject.getIntValue("code") == code; // 断言返回内容是否符合预期 assert message.equals(jsonObject.getString("message")); } }

Perform介绍

perform用来调用controller业务逻辑，有post、get等多种方法，具体可以参考利用Junit+MockMvc+Mockito对Http请求进行单元测试

参数Param介绍

通过param添加http的请求参数，格式是K-V，一个参数一个参数添加或者通过params添加MultiValueMap<String, String>。parma部分源码如下：

/** * Add a request parameter to the {@link MockHttpServletRequest}. * <p>If called more than once, new values get added to existing ones. * @param name the parameter name * @param values one or more values */ public MockHttpServletRequestBuilder param(String name, String... values) { addToMultiValueMap(this.parameters, name, values); return this; } /** * Add a map of request parameters to the {@link MockHttpServletRequest}, * for example when testing a form submission. * <p>If called more than once, new values get added to existing ones. * @param params the parameters to add * @since 4.2.4 */ public MockHttpServletRequestBuilder params(MultiValueMap<String, String> params) { for (String name : params.keySet()) { for (String value : params.get(name)) { this.parameters.add(name, value); } } return this; }

写在后面

还有个坑就是使用注解的时候，看看注解之间是否有重叠，否则会报错。如果同时使用@WebMvcTest @Configuration就错了。具体可以查看注解源码

　　以上就是模拟HTTP请求调用controller的代码的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于PHP框架中MVC架构的分析（附示例），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

junit是无法进行并发测试，但是又有需要并发测试的场景怎么办呢？此时可以借助一个插件（Groboutils Core）来完成这种功能。maven仓库地址：点我直达

实现

第一步：在项目的pom.xml中加入依赖

<dependency> <groupId>net.sourceforge.groboutils</groupId> <artifactId>groboutils-core</artifactId> <version>5</version> <scope>test</scope></dependency>

第二步：在单测中进行代码编写

@Test public void testConcurrentInitOrBind() { // mock一个返回 doReturn(Lists.newArrayList(userMemberCard)).when(operateCardDao) .queryCardByRegisterMobileAndTenantId(anyString(), anyLong()); TestRunnable runner = new TestRunnable() { // 在runTest方法中填写自己的测试方法 @Override public void runTest() throws Throwable { InitCardResVo resVoFirst = operateCardService.initOrBindCard(requestVo); System.out.println("result resVoFirst is:" + resVoFirst.toString()); } }; // 一个数组，代表并发个数。此处并发5个 TestRunnable[] trs = new TestRunnable[5]; for (int i = 0; i < 5; i++) { trs[i] = runner; } MultiThreadedTestRunner mttr = new MultiThreadedTestRunner(trs); try { mttr.runTestRunnables(); } catch (Throwable ex) { ex.printStackTrace(); } }

　　以上就是Junit借助Groboutils Core进行并发测试的实现方法（详细步骤）的知识。速戳>>知识兔学习精品课！

Static关键字在C++和Java中几乎用于相同的目的，但仍有些许不同之处。下面本篇文章就来带大家了解一下在C ++和Java中static关键字的异同点，希望对大家有所帮助。

C++和Java中static关键字的相同点

1、静态数据成员：

在C++和Java中静态数据成员都是类成员，并在所有对象之间共享。例如，在下面的Java程序中，静态变量计数用于计算所创建的对象的数量。

class Test { static int count = 0; Test() { count++; } public static void main(String arr[]) { Test t1 = new Test(); Test t2 = new Test(); System.out.println("共创建了" + count + " 个对象"); } }

输出：

共创建了2个对象

2、静态成员方法

在C++和Java中声明为static的方法是类成员，并具有以下限制：

1）、它们只能调用其他静态方法。例如，以下程序中fun()是非静态的，但它在静态main()中调用，所以会编译失败。

class Main { public static void main(String args[]) { System.out.println(fun()); } int fun() { return 20; } }

2）、必须只访问静态数据。

3）、无法访问this或super。例如，以下程序在编译时失败。

class Base { static int x = 0; } class Derived extends Base { public static void fun() { System.out.println(super.x); // 编译器错误：不能从静态上下文引用非静态变量 } }

说明：

C++和Java都可以在不创建对象的情况下访问静态数据成员和静态方法。可以使用类名访问它们。例如，在以下程序中，无需任何对象即可访问静态数据成员计数和静态方法fun()。

class Test { static int count = 0; public static void fun() { System.out.println("调用了静态方法fun()"); } } class Main { public static void main(String arr[]) { System.out.println("Test.count = " + Test.count); Test.fun(); } }

C++和Java中static关键字的不同点

1、静态块

与C ++不同，Java支持一个特殊的块，称为静态块（也称为静态子句），可用于类的静态初始化；静态块内的此代码仅执行一次。

2、静态局部变量

与C ++不同，Java不支持静态局部变量。例如，以下Java程序在编译时失败。

class Test { public static void main(String args[]) { System.out.println(fun()); } static int fun() { static int x= 10; //编译器错误：不允许静态局部变量 return x--; } }

相关视频教程推荐：《Java教程》、《C++教程》

以上就是本篇文章的全部内容，希望能对大家的学习有所帮助。更多精彩内容大家可以关注小兔网相关教程栏目！！！

　　以上就是C++和Java中static关键字的简单比较的知识。速戳>>知识兔学习精品课！

JavaMail API支持用于发送电子邮件的JavaMail（javax.mail）接口。javax.mail具有发送电子邮件和SMTP，POP3和IMAP等其他邮件协议所需的所有类。在本篇文章中，我们使用JavaMail API通过本地smtp服务器使用Java发送电子邮件。确保在localhost上运行smtp服务器。

第1步：设置JavaMail环境

首先，我们需要下载包含javax.mail中所有类的jar文件。从oracle官方网站下载jar（mail.jar）文件。

现在在系统环境中设置类路径。Windows用户确保为Java安装配置了PATH变量。

Windows:

c:> set classpath=mail.jar;.;

Linux:

# export JAVA_HOME=/opt/jdk1.8.0_05/# export PATH=$PATH:$JAVA_HOME/bin# export CLASSPATH=$JAVA_HOME/jre/lib/ext:$JAVA_HOME/lib/tools.jar:mail.jar:.

第2步：编写一个发送电子邮件的Java程序

使用以下内容创建一个Java文件sEndoJavaApI.java。在此脚本中，需要根据要求将电子邮件从变量更改为变量。

import java.util.Properties;import javax.mail.Message;import javax.mail.MessagingException;import javax.mail.Session;import javax.mail.Transport;import javax.mail.internet.AddressException;import javax.mail.internet.InternetAddress;import javax.mail.internet.MimeMessage; public class SendMailJavaAPI { public static void main(String[] args) throws Exception{ String to="该邮件地址已受到反垃圾邮件插件保护。要显示它需要在浏览器中启用 JavaScript。"; String from="该邮件地址已受到反垃圾邮件插件保护。要显示它需要在浏览器中启用 JavaScript。"; Properties props = new Properties(); Session session = Session.getDefaultInstance(props, null); String msgBody = "Sending email using JavaMail API..."; try { Message msg = new MimeMessage(session); msg.setFrom(new InternetAddress(from, "NoReply")); msg.addRecipient(Message.RecipientType.TO, new InternetAddress(to, "Mr. Recipient")); msg.setSubject("Welcome To Java Mail API"); msg.setText(msgBody); Transport.send(msg); System.out.println("Email sent successfully..."); } catch (AddressException e) { throw new RuntimeException(e); } catch (MessagingException e) { throw new RuntimeException(e); } }}

第3步：执行程序以发送电子邮件

最后，我们需要执行Java程序来发送电子邮件。正如我们所知，这发生在两个STPE中，第一个是编译程序，第二个是运行程序。

# javac SendMailJavaAPI.java# java SendMailJavaAPI

本篇文章到这里就已经全部结束了，更多其他精彩内容可以关注小兔网的其他相关栏目教程！！！

　　以上就是JavaMail API—使用Java从本地SMTP发送电子邮件的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于虚拟如何解决maven无法下载依赖的jar包（示例讲解），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

公司内部有搭建maven私服，自己做了个核心jar包，一开始是xxx-core.1.0.0.SNAPSHOT版本，是本地和项目环境都可以正常使用的。为支持上线，发布稳定版本，xxx-core.1.0.0.jar。

本地编译正常，启动正常，项目环境，gitlab提交后自动部署到Rancher时，发现始终下载不下来jar包。

pom.xml文件的repository配置：

<repositories> <repository> <id>xxxxx.releases</id> <name>Releases</name> <url>https://nexus.xxxxxx.com/repository/maven-releases</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </repository> <repository> <id>xxxxxx.snapshots</id> <name>Snapshot</name> <url>https://nexus.huilianyi.com/repository/maven-snapshots</url> <releases> <enabled>false</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </repository></repositories>

编译时maven报错提示：

Failed to execute goal on project service: Could not resolve dependencies for project com.xxxxx:service:war:1.0-SNAPSHOT: Failure to find com.xxxxx-core:jar:1.0.0 in https://nexus.xxxx.com/repository/maven-releases was cached in the local repository, resolution will not be reattempted until the update interval of xxx.releases has elapsed or updates are forced -> [Help 1]

提示是说，是私库配置的repository的这个id：xxx.releases 有缓存更新间隔，没到这个更新时间，是从缓存里面获取jar的，所以新上传到仓库xxx-core.1.0.0.jar这个jar包是不在缓存里面的

所以没有拉取下来。

解决办法：

pom.xml更改为:

<repositories> <repository> <id>xxxxx.releases</id> <name>Releases</name> <url>https://nexus.xxxxxx.com/repository/maven-releases</url> <releases> <enabled>true</enabled> <updatePolicy>always</updatePolicy> </releases> <snapshots> <enabled>false</enabled> </snapshots> </repository> <repository> <id>xxxxxx.snapshots</id> <name>Snapshot</name> <url>https://nexus.huilianyi.com/repository/maven-snapshots</url> <releases> <enabled>false</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </repository></repositories>

<updatePolicy>标签是更新策略，always是总是下载仓库中最新的依赖。注意：拉下来后，要去掉此配置，不然每次都会去下载jar包，编译起来非常耗时。

　　以上就是如何解决maven无法下载依赖的jar包（示例讲解）的知识。速戳>>知识兔学习精品课！

Iterator和ListIterator是Java三个游标中的两个，都是由Java.UTIL包中的集合框架定义的。那么它们之间有什么区别？下面本篇文章就来给大家介绍Iterator和ListIterator之间的区别，希望对大家有所帮助。

Java中Iterator和ListIterator的区别是什么？-java教程

Iterator是什么

Iterator代表迭代器，是Collection框架中的一个接口；用于遍历集合元素。它允许逐个迭代集合中的每个元素，从集合中获取元素或从集合中删除元素；但无法使用Iterator修改集合中的任何元素。

Iterator有一个iterator()方法，它会将迭代器返回到集合的开头。一旦得到一个集合开头的迭代器，然后遍历集合中的元素，就建立一个循环，每次循环迭代时调用hasNext()。

hasNext()如果返回true，则表示集合中存在下一个元素；如果返回false，则表示遍历所有元素。然后在循环内部，可以使用next()获取集合中的每个元素。next()方法返回集合的下一个元素。

缺点：

●　使用Iterator，就只能向前移动集合。

●　使用Iterator，就无法操纵或修改集合中的元素。

ListIterator是什么

ListIterator是Collection框架中的一个接口；是用于扩展Iterator接口的。使用ListIterator，可以向前和向后遍历集合的元素。还可以添加、删除或修改集合中的任何元素。简而言之，我们可以说它消除了Iterator的缺点。

ListIterator的方法如下：

●　hasNext()：如果返回true，则确认集合中有更多元素。

●　next()：返回列表的下一个元素。

●　nextIndex()：返回列表中下一个元素的索引。

●　hasPrevious()：如果集合中有相反的元素，则返回true。

●　previous()：返回集合中的上一个元素。

●　previousIndex()：返回集合中上一个元素的索引。

●　remove()：从集合中删除元素。

●　set()：修改集合中的元素。

●　add()：在集合中添加新元素。

Iterator和ListIterator之间的主要区别

1、遍历

使用Iterator，可以遍历所有集合，如Map，List，Set；但只能在向前方向上遍历集合中的元素。

使用ListIterator，只能遍历List实现的对象，但可以向前和向后遍历集合中的元素。

2、添加元素

Iterator无法向集合中添加元素；而，ListIteror可以向集合添加元素。

3、修改元素

Iterator无法修改集合中的元素；而，ListIterator可以使用set()修改集合中的元素。

4、索引

Iterator无法获取集合中元素的索引；而，使用ListIterator，可以获取集合中元素的索引。

相关视频教程推荐：《Java教程》

以上就是本篇文章的全部内容，希望能对大家的学习有所帮助。更多精彩内容大家可以关注小兔网相关教程栏目！！！

　　以上就是Java中Iterator和ListIterator的区别是什么？的知识。速戳>>知识兔学习精品课！

如何在java中获取文件的最后修改日期？我们可以使用File类的lastModified()方法来获取。下面本篇文章就来带大家了解一下lastModified()方法的使用，希望对大家有所帮助。

File类的lastModified()方法

lastModified()方法可以用于返回文件最后一次被修改的时间。

基本语法：

public long lastModified()

返回值：lastModified()方法返回由这个抽象路径名表示的文件上次被修改的时间；返回值以毫秒为单位，因此为了使其可读，我们可以使用simpledateformat格式化输出。

如何获取文件的最后修改日期？

下面通过代码示例来看看如何使用lastModified()方法获取件的最后修改日期。

示例：

import java.io.File;import java.text.SimpleDateFormat;public class LastModifiedDateExample{ public static void main(String[] args) { //Specify the file path and nameFile file = new File("D:\Myfile.txt"); SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");System.out.println("最后修改日期为：" + sdf.format(file.lastModified())); }}

输出：

最后修改日期为：03/18/2019 10:41:49

我们可以以任何所需的格式格式化和显示输出。例如，如果我们使用以下模式：

SimpleDateFormat sdf2 = new SimpleDateFormat("MM-dd-yy HH:mm a");System.out.println("Last Modified Date: " + sdf2.format(file.lastModified()));

我们将获得以上输出以上模式：

最后修改日期为：03-18-19 10:41 AM

相关视频教程推荐：《Java教程》

以上就是本篇文章的全部内容，希望能对大家的学习有所帮助。更多精彩内容大家可以关注小兔网相关教程栏目！！！

　　以上就是如何在java中获取文件的最后修改日期？（代码示例）的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于java环境的配置及安装（图文），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

1、安装JDK开发环境

首先登陆https://www.oracle.com

第一步：Products ---- Java ---- Download java(JDK) for Developers

第二步：进入另一个界面的时候找到Java SE 8U202 点击JDK（Download）进行下载

第三步：下载java开发环境

第四步：找到你下载的java开发环境右键以管理员身份运行

第五步：可以根据自己的需要更改安装目录更改完毕点下一步

第六步：安装成功以后又会出现一个安装，这是可以不进行安装，因为继续安装的是Jre

为什么不用安装呢？

因为刚刚安装的是jdk，jdk里面已经包含一个jre。

到这里JDK环境已经安装完成，下面我们开始配置环境变量

2、配置环境变量

Java程序开发而言，主要使用JDK的两个命令：javac.exe、java.exe。路径：C:Javajdk 1.7.0 _09bin。但是这些命令由于不属于windows本身的命令，

所以要想使用，就需要进行路径配置。

获取路径：

(1)新建->变量名"JAVA_HOME"，变量值"C:Javajdk1.8.0_05"（即JDK的安装路径）

第一步：找到你安装好的JDK文件进入

(2)编辑->变量名"Path"，在原变量值的最后面加上“;%JAVA_HOME%bin;”

(3)新建->变量名“CLASSPATH”,变量值“.;%JAVA_HOME%lib;%JAVA_HOME%libdt.jar;%JAVA_HOME%lib ools.jar”

加入环境变量

将这些变量值放进系统环境变量中

操作如下：

首先找到<此电脑>右键进入属性

进入高级系统设置

(1)新建->变量名"JAVA_HOME"，

变量值"C:Javajdk1.8.0_05"（即JDK的安装路径）

(2)编辑-----变量名"Path"，

在原变量值的最后面加上“;%JAVA_HOME%bin” （每个变量值以；隔开）

(3)新建 ----- 变量名“CLASSPATH”,

变量值“.;%JAVA_HOME%lib;%JAVA_HOME%libdt.jar;%JAVA_HOME%lib ools.jar”

检查是否加入环境变量

注：如果没出现变量值，可以重开一下命令或者关机关机重启

代码编写，运行

这样环境变量就配置好了

最后注意一个问题：

如果在CMD中输入javac test.java命令后，显示'javac'不是内部或外部命令，原因是因为没有提前安装好JDK开发环境或环境变量配置有误。

　　以上就是java环境的配置及安装（图文）的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于Java进程CPU占用率100%问题排查的方法，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

100%指的是占用了CPU一个核心，两个核心是200%，以此类推。CPU占用率及对应进程ID（pid）可以通过top命令确定，在top界面按 c （显示完整的命令行参数），按 1 （显示每个核心的统计数据）。（推荐：Java教程）

这个问题最常见的有以下几种可能：

1、堆内存不足导致频繁Full GC可以通过两个命令确定

sudo jmap -heap pid 查看堆内存的消耗情况

sudo jstat -gc pid interval count 查看GC情况，示例：sudo jstat -gc 5746 3000 5 代表查看5746进程的GC情况、每隔3000毫秒打印一次、总共打印5次。如果FGC/FGCT增长明显，说明Full GC很频繁。

后续处理：

如果情况紧急，那得马上重启Java应用进程不紧急的话需要获取相关信息用于分析为什么堆内存被消耗完了，可能有内存泄漏问题，可以用 1）sudo jmap -histo pid | head -n 20 查看Java对象的占用统计信息，2）sudo jmap -dump:live,format=b,file=heap.bin pid 把堆转储导出到本地文件，可以用 Eclipse MAT 工具分析内存泄漏

2、代码实现问题

思路：追查具体是哪个线程占用了CPU，1）先查到本地系统CPU占用率高的线程ID，2）找到对应的Java线程及线程堆栈

top -H -p pid 查看某个进程里面哪些线程占用了CPU，把对应的线程ID拷贝下来，转为十六进制【IDEA》Tools》Groovy Console》println Long.toHexString(1234) 即可完成转换】。

sudo jstack -l -F pid | less 获取Java线程堆栈，用十六进制的本地线程ID搜索，会在某一行的nid处找到对应的线程。查看Java线程堆栈，找到对应的Java类及行号，然后阅读代码查找可能的问题原因。

jstack堆栈信息里tid/nid的说明https://docs.oracle.com/javas...

The thread dump consists of the thread stack, including the thread state, for all Java threads in the virtual machine.The header line contains the following information about the thread:- Thread ID (tid), which is the address of a thread structure in memory.- ID of the native thread (nid).

　　以上就是Java进程CPU占用率100%问题排查的方法的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于怎么使用JVM捕获Java异常？（附示例），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

1.异常的两大关键因素

(1)抛出异常1.显式：应用程序手动抛出异常。具体就是使用throw抛出异常2.隐式：Java虚拟机对于无法执行的代码，自动抛出异常

（推荐：Java教程）

(2)捕获异常1.try 代码块：用来标记需要进行异常监控的代码。2.catch 代码块：跟在 try 代码块之后，用来捕获在 try 代码块中触发的某种指定类型的异常。除了声明所捕获异常的类型之外，catch 代码块还定义了针对该异常类型的异常处理器。在 Java中，try 代码块后面可以跟着多个 catch 代码块，来捕获不同类型的异常。Java 虚拟机会从上至下匹配异常处理器。因此，前面的 catch 代码块所捕获的异常类型不能覆盖后边的，否则编译器会报错。3.fnally 代码块：跟在 try 代码块和 catch 代码块之后，用来声明一段必定运行的代码。它的设计初衷是为了避免跳过某些关键的清理代码，例如关闭已打开的系统资源。在程序正常执行的情况下，这段代码会在 try 代码块之后运行。否则，也就是 try 代码块触发异常的情况下，如果该异常没有被捕获，fnally 代码块会直接运行，并且在运行之后重新抛出该异常。如果该异常被 catch 代码块捕获，fnally 代码块则在 catch 代码块之后运行。在某些不幸的情况下，catch 代码块也触发了异常，那么 fnally 代码块同样会运行，并会抛出 catch 代码块触发的异常。在某些极端不幸的情况下，fnally 代码块也触发了异常，那么只好中断当前 fnally 代码块的执行，并往外抛异常。

2.异常的分类

1.所有异常的父类都是Throwable2.Error异常是程序的执行状态无法恢复的状态，只能中止线程甚至中止JVM的异常3.Exception是相对Error没有这么严重的异常4.Runtime Exception和Error都属于不需要检查的异常5.除了Runtime Exception和Error的异常都是Check Exception异常6.Check Exception异常都是需要显式捕获的异常3.Java虚拟机是如何捕获异常的？java虚拟机构造异常实例非常昂贵。虚拟机需要生成该异常的栈轨迹。该操作会逐一访问当前线程的 Java 栈帧，并且记录下各种调试信息，包括栈帧所指向方法的名字，方法所在的类名、文件名，以及在代码中的第几行触发该异常。既然异常实例的构造十分昂贵，我们是否可以缓存异常实例，在需要用到的时候直接抛出呢？从语法角度上来看，这是允许的。然而，该异常对应的栈轨迹并非 throw 语句的位置，而是新建异常的位置。因此，这种做法可能会误导开发人员，使其定位到错误的位置。这也是为什么在实践中，我们往往选择抛出新建异常实例的原因。

异常处理器1.来源：每个方法在编译的时候都会生成一个异常表。异常表里面的每一个条目都代表一个异常处理器。2.组成：(1)from指针，to指针：代表捕获异常的范围，就是Try的范围。(2)target指针：代表处理器的开始位置，就是catch的起始位置。(3)捕获的异常类型。3.捕获异常(1)当程序触发异常时，Java 虚拟机会从上至下遍历异常表中的所有条目。当触发异常的字节码的索引值在某个异常表条目的监控范围内，Java 虚拟机会判断所抛出的异常和该条目想要捕获的异常是否匹配。如果匹配，Java 虚拟机会将控制流转移至该条目 target 指针指向的字节码。(2)如果遍历完所有异常表条目，Java 虚拟机仍未匹配到异常处理器，那么它会弹出当前方法对应的Java 栈帧，并且在调用者（caller）中重复上述操作。在最坏情况下，Java 虚拟机需要遍历当前线程 Java 栈上所有方法的异常表。4.finally代码的编译：当前版本 Java 编译器的做法，是复制 fnally 代码块的内容，分别放在 try-catch 代码块所有正常执行路径以及异常执行路径的出口中。

代码1：Try{Try block} catch {Catch block} finally {Finally block}

代码2：Try {Try blockFinally block} catch {Catch blockFinally block} finally{Finally block}代码1是我们的Java代码，代码2是编译之后的Java代码。

注意：如果 catch 代码块捕获了异常，并且触发了另一个异常，那么 fnally 捕获并且重抛的异常是哪个呢？答案是后者。也就是说原本的异常便会被忽略掉，这对于代码调试来说十分不利。5.Java7的 Supressed 异常以及语法糖

针对上节说的会将catch的异常忽略掉，Java7引入了 Supressed 异常处理这个问题。但是使用起来还是很麻烦（没有感受，

　　以上就是怎么使用JVM捕获Java异常？（附示例）的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于Java向上转型和向下转型的使用介绍（附代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

1 向上转型（子类转型成父类）举例：

package a.b;public class A {public void a1() { System.out.println("Superclass");}}A的子类B：package a.b;public class B extends A {public void a1() { System.out.println("Childrenclass"); //覆盖父类方法} public void b1(){} //B类定义了自己的新方法}C类：package a.b;public class C {public static void main(String[] args) { A a = new B(); //向上转型 a.a1();}}

如果运行C，输出的是Superclass 还是Childrenclass？不是你原来预期的Superclass，而是Childrenclass。这是因为a实际上指向的是一个子类对象。当然，你不用担心，Java虚拟机会自动准确地识别出究竟该调用哪个具体的方法。不过，由于向上转型，a对象会遗失和父类不同的方法，例如b1()。有人可能会提出疑问：这不是多此一举吗？我们完全可以这样写：

B a = new B();

a.a1();

确实如此！但这样就丧失了面向抽象的编程特色，降低了可扩展性。其实，不仅仅如此，向上转型还可以减轻编程工作量。来看下面的显示器类Monitor：

package a.b;public class Monitor{public void displayText() {}public void displayGraphics() {}}液晶显示器类LCDMonitor是Monitor的子类：package a.b;public class LCDMonitor extends Monitor {public void displayText() { System.out.println("LCD display text");}public void displayGraphics() { System.out.println("LCD display graphics");}}阴极射线管显示器类CRTMonitor自然也是Monitor的子类：package a.b;public class CRTMonitor extends Monitor {public void displayText() { System.out.println("CRT display text");}public void displayGraphics() { System.out.println("CRT display graphics");}}等离子显示器PlasmaMonitor也是Monitor的子类：package a.b;public class PlasmaMonitor extends Monitor {public void displayText() { System.out.println("Plasma display text");}public void displayGraphics() { System.out.println("Plasma display graphics");}}现在有一个MyMonitor类。假设没有向上转型，MyMonitor类代码如下：package a.b;public class MyMonitor {public static void main(String[] args) { run(new LCDMonitor()); run(new CRTMonitor()); run(new PlasmaMonitor());}public static void run(LCDMonitor monitor) { monitor.displayText(); monitor.displayGraphics();}public static void run(CRTMonitor monitor) { monitor.displayText(); monitor.displayGraphics();}public static void run(PlasmaMonitor monitor) { monitor.displayText(); monitor.displayGraphics();}}可能你已经意识到上述代码有很多重复代码，而且也不易维护。有了向上转型，代码可以更为简洁：package a.b;public class MyMonitor {public static void main(String[] args) { run(new LCDMonitor()); //向上转型 run(new CRTMonitor()); //向上转型 run(new PlasmaMonitor()); //向上转型}public static void run(Monitor monitor) { //父类实例作为参数 monitor.displayText(); monitor.displayGraphics();}}我们也可以采用接口的方式，例如：package a.b;public interface Monitor {abstract void displayText();abstract void displayGraphics();}将液晶显示器类LCDMonitor稍作修改：package a.b;public class LCDMonitor implements Monitor {public void displayText() { System.out.println("LCD display text");}public void displayGraphics() { System.out.println("LCD display graphics");}}

2 向下转型（父类转型成子类）

A类：package a.b;public class A {void aMthod() { System.out.println("A method");}}A的子类B：package a.b;public class B extends A {void bMethod1() { System.out.println("B method 1");}void bMethod2() { System.out.println("B method 2");}}C类：package a.b;public class C { public static void main(String[] args) { A a1 = new B(); // 向上转型 a1.aMthod(); // 调用父类aMthod()，a1遗失B类方法bMethod1()、bMethod2() B b1 = (B) a1; // 向下转型，编译无错误，运行时无错误 b1.aMthod(); // 调用父类A方法 b1.bMethod1(); // 调用B类方法 b1.bMethod2(); // 调用B类方法 A a2 = new A(); B b2 = (B) a2; // 向下转型，编译无错误，运行时将出错 b2.aMthod(); b2.bMethod1(); b2.bMethod2(); }}从上面的代码我们可以得出这样一个结论：向下转型需要使用强制转换。运行C程序，控制台将输出：Exception in thread "main" java.lang.ClassCastException: a.b.A cannot be cast to a.b.B at a.b.C.main(C.java:14)A methodA methodB method 1B method 2

其实B b2 = (B) a2处的向下转型代码后的注释已经提示你将发生运行时错误。为什么前一句向下转型代码可以，而后一句代码却出错？这是因为a1指向一个子类B的对象，所以子类B的实例对象b1当然也可以指向a1。而a2是一个父类对象，子类对象b2不能指向父类对象a2。那么如何避免在执行向下转型时发生运行时ClassCastException异常？使用5.7.7节学过的instanceof就可以了。我们修改一下C类的代码：

A a2 = new A();if (a2 instanceof B) {B b2 = (B) a2;b2.aMthod();b2.bMethod1();b2.bMethod2();}

这样处理后，就不用担心类型转换时发生ClassCastException异常了。

　　以上就是Java向上转型和向下转型的使用介绍（附代码）的知识。速戳>>知识兔学习精品课！

本篇文章给大家带来的内容是关于如何在SpringBoot中集成JWT鉴权（附代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

1、关于JWT

1.1 什么是JWT

老生常谈的开头，我们要用这样一种工具，首先得知道以下几个问题。这个工具是什么，这个工具解决了什么问题是否适用于当前我们所处得业务场景用了之后是否会带来任何其他问题怎么用才是最佳实践

那什么是JWT呢？以下是我对jwt官网上对JWT介绍的翻译。JSON Web Token （JWT）是一种定义了一种紧凑并且独立的，用于在各方之间使用JSON对象安全的传输信息的一个开放标准（RFC 7519）。

现在我们知道，JWT其实是一种开放标准，用于在多点之间安全地传输用JSON表示的数据。在传输的过程中，JWT以字符串的形式出现在我们的视野中。该字符串中的信息可以通过数字签名进行验证和信任。（推荐：Java教程）

1.2 应用场景

JWT在实际的开发中，有哪些应用场景呢？1.2.1 授权

这应该算是JWT最常见的使用场景。在前端界面中，一旦用户登录成功，会接收到后端返回的JWT。后续的请求都会包含后端返回的JWT，作为对后端路由、服务以及资源的访问的凭证。1.2.2 信息交换

利用JWT在多方之间相互传递信息具有一定的安全性，例如JWT可以用HMAC、RSA非对称加密算法以及ECDSA数字签名算法对JWT进行签名，可以确保消息的发送者是真的发送者，而且使用header和payload进行的签名计算，我们还可以验证发送的消息是否被篡改了。

2.JWT的结构

知识兔

通俗来讲JWT由三部分组成的字符串，网上有太多帖子介绍这一块了，所以在这里就简单介绍一下就好了。

2.1 header

由使用的签名算法和令牌的类型的组成，例如令牌的类型就是JWT这种开放标准，而使用的签名算法就是，也就是算法。其他的加密算法还有、等等。

然后将这个包含两个属性的JSON对象转化为字符串然后使用Base64编码，最终形成了JWT的header。

2.2 payload

说直白一些就类似你的requestBody中的数据。只不过是分了三种类型，预先申明好的、自定义的以及私有的。像发件人，过期时间都是预先注册好的申明。

预先申明在载荷中的数据不是强制性的使用，但是官方建议使用。然后这串类似于requestBody的JSON经过Base64编码形成了JWT的第二部分。

2.3 signature

如果要生成，就需要使用jwt自定义配置项中的secret，也就是Hmac算法加密所需要的密钥。将之前经过Base64编码的header和payload用相连，再使用自定义的密钥，对该消息进行签名，最终生成了签名。

生成的签名用于验证消息在传输的过程中没有被更改。在使用非对称加密算法进行签名的时候，还可以用于验证JWT的发件人是否与payload中申明的发件人是同一个人。

3.JWT在Spring项目中的应用场景

知识兔

3.1 生成JWT

代码如下。

public String createJwt(String userId, String projectId) throws IllegalArgumentException, UnsupportedEncodingException { Algorithm al = Algorithm.HMAC256(secret); Instant instant = LocalDateTime.now().plusHours(outHours).atZone(ZoneId.systemDefault()).toInstant(); Date expire = Date.from(instant); String token = JWT.create() .withIssuer(issuer) .withSubject("userInfo") .withClaim("user_id", userId) .withClaim("project_id", projectId) .withExpiresAt(expire) .sign(al); return token;}

传入的两个Claim是项目里自定义的payload，是选择的算法，而就是对信息签名的密钥，则是该token的主题，标识了该token的过期时间。

3.2 返回JWT

在用户登录系统成功之后，将token作为返回参数，返回给前端。

3.3 验证token

在token返回给前端之后，后端要做的就是验证这个token是否是合法的，是否可以访问服务器的资源。主要可以通过以下几种方式去验证。3.3.1 解析token

使用解析token，这是验证token是否合法的第一步，例如前端传过来的token是一串没有任何意义的字符串，在这一步就可以抛出错误。示例代码如下。

try { Algorithm algorithm = Algorithm.HMAC256(secret); JWTVerifier verifier = JWT.require(algorithm).build(); DecodedJWT jwt = verifier.verify(token);} catch (JWTVerificationException e) { e.printStackTrace();}

JWTVerifier可以使用用制定secret签名的算法，指定的claim来验证token的合法性。3.3.2 判断token时效性

判断了token是有效的之后，再对token的时效性进行验证。

try { Algorithm algorithm = Algorithm.HMAC256(secret); JWTVerifier verifier = JWT.require(algorithm).build(); DecodedJWT jwt = verifier.verify(token); if (jwt.getExpiresAt().before(new Date())) { System.out.println("token已过期"); return null; }} catch (JWTVerificationException e) { e.printStackTrace(); return null;}

如果该token过期了，则不允许访问服务器资源。具体的流程如下。

3.3.3 刷新过期时间

上面创建token的有效时间是可以配置的，假设是2个小时，并且用户登录进来连续工作了1小时59分钟，在进行一个很重要的操作的时候，点击确定，这个时候token过期了。如果程序没有保护策略，那么用户接近两个小时的工作就成为了无用功。

遇到这样的问题，我们之前的流程设计必然面对一次重构。可能大家会有疑问，不就是在用户登录之后，每次操作对去刷新一次token的过期时间吗？

那么问题来了，我们知道token是由三段内容组成的，而过期时间则是属于payload，如果改变了过期的时间，那么最终生成的payload的hash则势必与上一次生成的不同。

换句话说，这是一个全新的token。前端要怎么接收这个全新的token呢？可想到的解决方案无非就是每次请求，根据response header中的返回不断的刷新的token。但是这样的方式侵入了前端开发的业务层。使其每一个接口都需要去刷新token。

大家可能会说，无非就是加一个拦截器嘛，对业务侵入不大啊。即使这部分逻辑是写在拦截器里的，但是前端因为token鉴权的逻辑而多出了这部分代码。而这部分代码从职能分工上来说，其实是后端的逻辑。

说的直白一些，刷新token，对token的时效性进行管理，应该是由后端来做。前端不需要也不应该去关心这一部分的逻辑。3.3.4 redis大法好

综上所述，刷新token的过期时间势必要放到后端，并且不能通过判断JWT中payload中的expire来判断token是否有效。

所以，在用户登录成功之后并将token返回给前端的同时，需要以某一个唯一表示为key，当前的token为value，写入Redis缓存中。并且在每次用户请求成功后，刷新token的过期时间，流程如下所示。

经过这样的重构之后，流程就变成了这样。

在流程中多了一个刷新token的流程。只要用户登录了系统，每一次的操作都会刷新token的过期时间，就不会出现之前说的在进行某个操作时突然失效所造成数据丢失的情况。

在用户登录之后的两个小时内，如果用户没有进行任何操作，那么2小时后再次请求接口就会直接被服务器拒绝访问。

4.总结

总的来说，JWT中是不建议放特别敏感信息的。如果没有用非对称加密算法的话，把token复制之后直接可以去jwt官网在线解析。如果请求被拦截到了，里面的所有信息等于是透明的。

但是JWT可以用来当作一段时间内运行访问服务器资源的凭证。例如JWT的payload中带有userId这个字段，那么就可以对该token标识的用户的合法性进行验证。例如，该用户当前状态是否被锁定？该userId所标识的用户是否存在于我们的系统？等等。

并且通过实现token的公用，可以实现用户的多端同时登录。像之前的登录之后创建token，就限定了用户只能同时在一台设备上登录。

　　以上就是如何在SpringBoot中集成JWT鉴权（附代码）的知识。速戳>>知识兔学习精品课！

在Java中，引用类型包括有：1、强引用（StrongReference）；2、软引用（SoftRefernce）；3、弱引用（WeakReference）；4、虚引用（PhantomReference）。

Java的引用类型

Java类型一般有两种，即基本数据类型与引用数据类型。其中，引用数据类型在存储堆中对需要引用的对象进行引用，引用是Java面向对象的一个特点。

从JDK1.2开始，Java中的引用类型分为四种，分别是：

①强引用（StrongReference）

②软引用（SoftRefernce）

③弱引用（WeakReference）

④虚引用（PhantomReference）

强引用-StrongReference

这种引用是平时开发中最常用的，例如Stringstrong=newString("StrongReference")，当一个实例对象具有强引用时，垃圾回收器不会回收该对象，当内存不足时，宁愿抛出OutOfMemeryError异常也不会通过回收强引用的对象，因为JVM认为强引用的对象是用户正在使用的对象，它无法分辨出到底该回收哪个，强行回收有可能导致系统严重错误。

软引用-SoftReference

如果一个对象只有软引用，那么只有当内存不足时，JVM才会去回收该对象，其他情况不会回收。软引用可以结合ReferenceQueue来使用，当由于系统内存不足，导致软引用的对象被回收了，JVM会把这个软引用加入到与之相关联的ReferenceQueue中。

ReferenceQueuereferenceQueue=newReferenceQueue();SoftReference<Book>softReference=newSoftReference<>(newBook(),referenceQueue);Bookbook=softReference.get();Referencereference=referenceQueue.poll();

当系统内存不足时，触发gc，这个Book就会被回收，reference将不为null。

弱引用-WeakReference

只有弱引用的对象，当JVM触发gc时，就会回收该对象。与软引用不同的是，不管是否内存不足，弱引用都会被回收。弱引用可以结合ReferenceQueue来使用，当由于系统触发gc，导致软引用的对象被回收了，JVM会把这个弱引用加入到与之相关联的ReferenceQueue中，不过由于垃圾收集器线程的优先级很低，所以弱引用不一定会被很快回收。下面通过一个主动触发gc的例子来验证此结论。

ReferenceQueuereferenceQueue=newReferenceQueue();WeakReference<Book>weakReference=newWeakReference(newBook(),referenceQueue);Bookbook=softReference.get();System.gc();//Runtime.getRuntime().gc();Referencereference=referenceQueue.poll();

当然这不是每次都能复现，因为我们调用System.gc()只是告诉JVM该回收垃圾了，但是它什么时候做还是不一定的，但就我测试来看，只要多写几次System.gc()，复现的概率还是很高的。

虚引用-PhantomReference

如果一个对象只有虚引用在引用它，垃圾回收器是可以在任意时候对其进行回收的，虚引用主要用来跟踪对象被垃圾回收器回收的活动，当被回收时，JVM会把这个弱引用加入到与之相关联的ReferenceQueue中。

与软引用和弱引用不同的是，虚引用必须有一个与之关联的ReferenceQueue，通过phantomReference.get()得到的值为null，试想一下，如果没有ReferenceQueue与之关联还有什么存在的价值呢？

PhantomReference<Book>phantomReference=newPhantomReference<>(newBook(),referenceQueue);Bookbook=phantomReference.get();//此值为nullReferencereference=referenceQueue.poll();

推荐教程：《java教程》

　　以上就是Java引用类型包括哪些？的知识。速戳>>知识兔学习精品课！

string类的常用方法有：length()、charAt()、substring()、compareTo()、compareToIgnore()、equals()、concat()、indexOf()、lastIndexOf()等等。

一、String类

String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。java把String类声明的final类，不能有类。String类对象创建后不能修改，由0或多个字符组成，包含在一对双引号之间。

二、String类对象的创建

字符串声明：String stringName;

字符串创建：stringName = new String(字符串常量);或stringName = 字符串常量;

三、String类构造方法

1、public String()

无参构造方法，用来创建空字符串的String对象。

String str1 = new String();

2、public String(String value)

用已知的字符串value创建一个String对象。

String str2 = new String("asdf"); String str3 = new String(str2);

3、public String(char[] value)

用字符数组value创建一个String对象。

char[] value = {'a','b','c','d'};String str4 = new String(value);//相当于String str4 = new String("abcd");

4、public String(char chars[], int startIndex, int numChars)

用字符数组chars的startIndex开始的numChars个字符创建一个String对象。

char[] value = {'a','b','c','d'};String str5 = new String(value, 1, 2);//相当于String str5 = new String("bc");

5、public String(byte[] values)

用比特数组values创建一个String对象。

byte[] strb = new byte[]{65,66};String str6 = new String(strb);//相当于String str6 = new String("AB");

四、String类常用方法

1、求字符串长度

public int length()//返回该字符串的长度

String str = new String("asdfzxc");int strlength = str.length();//strlength = 7

2、求字符串某一位置字符

public char charAt(int index)//返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。

String str = new String("asdfzxc");char ch = str.charAt(4);//ch = z

3、提取子串

用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:

1)public String substring(int beginIndex)//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。

2)public String substring(int beginIndex, int endIndex)//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

String str1 = new String("asdfzxc");String str2 = str1.substring(2);//str2 = "dfzxc"String str3 = str1.substring(2,5);//str3 = "dfz"

4、字符串比较

1)public int compareTo(String anotherString)//该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。

2)public int compareToIgnore(String anotherString)//与compareTo方法相似，但忽略大小写。

3)public boolean equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。

4)public boolean equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。

String str1 = new String("abc");String str2 = new String("ABC");int a = str1.compareTo(str2);//a>0int b = str1.compareToIgnoreCase(str2);//b=0boolean c = str1.equals(str2);//c=falseboolean d = str1.equalsIgnoreCase(str2);//d=true

5、字符串连接

public String concat(String str)//将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。

String str = "aa".concat("bb").concat("cc");//相当于String str = "aa"+"bb"+"cc";

6、字符串中单个字符查找

1)public int indexOf(int ch/String str)//用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。

2)public int indexOf(int ch/String str, int fromIndex)//改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。

3)public int lastIndexOf(int ch/String str)//该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。

4)public int lastIndexOf(int ch/String str, int fromIndex)//该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。

String str = "I am a good student";int a = str.indexOf('a');//a = 2int b = str.indexOf("good");//b = 7int c = str.indexOf("w",2);//c = -1int d = str.lastIndexOf("a");//d = 5int e = str.lastIndexOf("a",3);//e = 2

7、字符串中字符的大小写转换

1)public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串

2)public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串

String str = new String("asDF");String str1 = str.toLowerCase();//str1 = "asdf"String str2 = str.toUpperCase();//str2 = "ASDF"

8、字符串中字符的替换

1)public String replace(char oldChar, char newChar)//用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。

2)public String replaceFirst(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串，应将新的字符串返回。

3)public String replaceAll(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串，应将新的字符串返回。

String str = "asdzxcasd";String str1 = str.replace('a','g');//str1 = "gsdzxcgsd"String str2 = str.replace("asd","fgh");//str2 = "fghzxcfgh"String str3 = str.replaceFirst("asd","fgh");//str3 = "fghzxcasd"String str4 = str.replaceAll("asd","fgh");//str4 = "fghzxcfgh"

9、其他类方法

1)String trim()//截去字符串两端的空格，但对于中间的空格不处理。

String str = " a sd ";String str1 = str.trim();int a = str.length();//a = 6int b = str1.length();//b = 4

2)boolean statWith(String prefix)或boolean endWith(String suffix)//用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同，重载方法中同时还可以指定比较的开始位置offset。

String str = "asdfgh";boolean a = str.statWith("as");//a = trueboolean b = str.endWith("gh");//b = true

3)regionMatches(boolean b, int firstStart, String other, int otherStart, int length)//从当前字符串的firstStart位置开始比较，取长度为length的一个子字符串，other字符串从otherStart位置开始，指定另外一个长度为length的字符串，两字符串比较，当b为true时字符串不区分大小写。

4)contains(String str)//判断参数s是否被包含在字符串中，并返回一个布尔类型的值。

String str = "student";str.contains("stu");//truestr.contains("ok");//false

5)String[] split(String str)//将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。

String str = "asd!qwe|zxc#";String[] str1 = str.split("!|#");//str1[0] = "asd";str1[1] = "qwe";str1[2] = "zxc";

五、字符串与基本类型的转换

1、字符串转换为基本类型

java.lang包中有Byte、Short、Integer、Float、Double类的调用方法：

1)public static byte parseByte(String s)

2)public static short parseShort(String s)

3)public static short parseInt(String s)

4)public static long parseLong(String s)

5)public static float parseFloat(String s)

6)public static double parseDouble(String s)

例如：

int n = Integer.parseInt("12");float f = Float.parseFloat("12.34");double d = Double.parseDouble("1.124");

2、基本类型转换为字符串类型

String类中提供了String valueOf()放法，用作基本类型转换为字符串类型。

1)static String valueOf(char data[])

2)static String valueOf(char data[], int offset, int count)

3)static String valueOf(boolean b)

4)static String valueOf(char c)

5)static String valueOf(int i)

6)static String valueOf(long l)

7)static String valueOf(float f)

8)static String valueOf(double d)

例如：

String s1 = String.valueOf(12);String s1 = String.valueOf(12.34);

3、进制转换

使用Long类中的方法得到整数之间的各种进制转换的方法：

Long.toBinaryString(long l)Long.toOctalString(long l)Long.toHexString(long l)Long.toString(long l, int p)//p作为任意进制

推荐教程：《java教程》

　　以上就是Java中string类的常用方法有哪些？的知识。速戳>>知识兔学习精品课！

1. Date.compareTo（）

提供了在Java中比较两个日期的经典方法compareTo（）。

1、如果两个日期相等，则返回值为0。

2、如果Date在date参数之后，则返回值大于0。

3、如果Date在date参数之前，则返回值小于0。

@Testvoid testDateCompare() throws ParseException { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date date1 = sdf.parse("2009-12-31"); Date date2 = sdf.parse("2019-01-31"); System.out.println("date1 : " + sdf.format(date1)); System.out.println("date2 : " + sdf.format(date2)); if (date1.compareTo(date2) > 0) { System.out.println("Date1 时间在 Date2 之后"); } else if (date1.compareTo(date2) < 0) { System.out.println("Date1 时间在 Date2 之前"); } else if (date1.compareTo(date2) == 0) { System.out.println("Date1 时间与 Date2 相等"); } else { System.out.println("程序怎么会运行到这里?正常应该不会"); }}

输出结果：

date1 : 2009-12-31date2 : 2019-01-31Date1 时间在 Date2 之前

2. Date.before（），Date.after（）和Date.equals（）

一种语义上比较友好的方法来比较两个

@Testvoid testDateCompare2() throws ParseException { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date date1 = sdf.parse("2009-12-31"); Date date2 = sdf.parse("2019-01-31"); System.out.println("date1 : " + sdf.format(date1)); System.out.println("date2 : " + sdf.format(date2)); if (date1.after(date2)) { System.out.println("Date1 时间在 Date2 之后"); } if (date1.before(date2)) { System.out.println("Date1 时间在 Date2 之前"); } if (date1.equals(date2)) { System.out.println("Date1 时间与 Date2 相等"); }}

输出结果

date1 : 2009-12-31date2 : 2019-01-31Date1 时间在 Date2 之前

3. Calender.before（），Calender.after（）和Calender.equals（）

使用比较两个Date日期

@Testvoid testDateCompare3() throws ParseException { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date date1 = sdf.parse("2009-12-31"); Date date2 = sdf.parse("2019-01-31"); System.out.println("date1 : " + sdf.format(date1)); System.out.println("date2 : " + sdf.format(date2)); Calendar cal1 = Calendar.getInstance(); Calendar cal2 = Calendar.getInstance(); cal1.setTime(date1); cal2.setTime(date2); if (cal1.after(cal2)) { System.out.println("Date1 时间在 Date2 之后"); } if (cal1.before(cal2)) { System.out.println("Date1 时间在 Date2 之前"); } if (cal1.equals(cal2)) { System.out.println("Date1 时间与 Date2 相等"); }}

输出结果：

date1 : 2009-12-31date2 : 2019-01-31Date1 时间在 Date2 之前

4. Java 8日期比较方法

在Java 8中，可以使用新的isBefore（），isAfter（），isEqual（）和compareTo（）来比较LocalDate，LocalTime和LocalDateTime。以下示例以比较两个

@Testvoid testDateCompare4() throws ParseException { DateTimeFormatter sdf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); LocalDate date1 = LocalDate.of(2009, 12, 31); LocalDate date2 = LocalDate.of(2019, 1, 31); System.out.println("date1 : " + sdf.format(date1)); System.out.println("date2 : " + sdf.format(date2)); System.out.println("Is..."); if (date1.isAfter(date2)) { System.out.println("Date1 时间在 Date2 之后"); } if (date1.isBefore(date2)) { System.out.println("Date1 时间在 Date2 之前"); } if (date1.isEqual(date2)) { System.out.println("Date1 时间与 Date2 相等"); }}

输出结果

date1 : 2009-12-31date2 : 2019-01-31Is...Date1 时间在 Date2 之前

推荐教程：《java教程》

　　以上就是java中如何进行日期时间比较？4种方法介绍的知识。速戳>>知识兔学习精品课！

过滤器是一个程序，它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息。

在这之后，过滤器可以作如下的选择：

①以常规的方式调用资源（即，调用servlet或JSP页面）。

②利用修改过的请求信息调用资源。

③调用资源，但在发送响应到客户机前对其进行修改。

④阻止该资源调用，代之以转到其他的资源，返回一个特定的状态代码或生成替换输出。

过滤器的工作原理

在Servlet作为过滤器使用时，它可以对客户的请求进行处理。处理完成后，它会交给下一个过滤器处理，这样，客户的请求在过滤链里逐个处理，直到请求发送到目标为止。例如，某网站里有提交“修改的注册信息”的网页，当用户填写完修改信息并提交后，服务器在进行处理时需要做两项工作：判断客户端的会话是否有效；对提交的数据进行统一编码。这两项工作可以在由两个过滤器组成的过滤链里进行处理。当过滤器处理成功后，把提交的数据发送到最终目标；如果过滤器处理不成功，将把视图派发到指定的错误页面。

过滤器的生命周期

public void init(FilterConfig filterConfig) throws ServletException;//初始化

和我们编写的Servlet程序一样，Filter的创建和销毁由WEB服务器负责。 web 应用程序启动时，web 服务器将创建Filter 的实例对象，并调用其init方法，读取web.xml配置，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作（filter对象只会创建一次，init方法也只会执行一次）。开发人员通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;//拦截请求

这个方法完成实际的过滤操作。当客户请求访问与过滤器关联的URL的时候，Servlet过滤器将先执行doFilter方法。FilterChain参数用于访问后续过滤器。

public void destroy();//销毁

Filter对象创建后会驻留在内存，当web应用移除或服务器停止时才销毁。在Web容器卸载 Filter 对象之前被调用。该方法在Filter的生命周期中仅执行一次。在这个方法中，可以释放过滤器使用的资源。

推荐教程：《java教程》

　　以上就是什么是过滤器？的知识。速戳>>知识兔学习精品课！

Java中switch case 语句的用法：1、switch语句可以拥有多个case语句；2、case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量；3、当遇到break语句时，switch语句终止。

Java中switch case 语句的用法：

语法

switch case 语句语法格式如下：

switch(expression){ case value : //语句 break; //可选 case value : //语句 break; //可选 //你可以有任意数量的case语句 default : //可选 //语句}

相关学习推荐：java基础教程

二、在Java中实现多线程

我们不妨设想，为了创建一个新的线程，我们需要做些什么？很显然，我们必须指明这个线程所要执行的代码，而这就是在Java中实现多线程我们所需要做的一切！

作为一个完全面向对象的语言，Java提供了类 java.lang.Thread 来方便多线程编程，这个类提供了大量的方法来方便我们控制自己的各个线程。

那么如何提供给 Java 我们要线程执行的代码呢？让我们来看一看 Thread 类。Thread 类最重要的方法是 run（），它为Thread 类的方法 start（）所调用，提供我们的线程所要执行的代码。为了指定我们自己的代码，只需要覆盖它！

方法一：继承 Thread 类，重写方法 run（），我们在创建的 Thread 类的子类中重写 run（），加入线程所要执行的代码即可。下面是一个例子：

public class TwoThread extends Thread { public void run() { for ( int i = 0; i < 10; i++ ) { System.out.println("New thread"); } } public static void main(String[] args) { TwoThread tt = new TwoThread(); tt.start(); for ( int i = 0; i < 10; i++ ) { System.out.println("Main thread"); } }}

这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承，则无法再继承 Thread 类。

方法二：实现 Runnable 接口

Runnable 接口只有一个方法 run（），我们声明自己的类实现 Runnable 接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持，我们还必须创建 Thread 类的实例，这一点通过 Thread 类的构造函数public Thread（Runnable target）；来实现。下面是一个例子：

public class MyThread implements Runnable {int count=1, number;public MyThread(int num) {number = num;System.out.println("创建线程 " + number);}public void run() {while(true) {System.out.println("线程 " + number + ":计数 " + count);if(++count== 6) return;}}public static void main(String args[]) {for(int i = 0; i < 5; i++)new Thread(new MyThread(i+1)).start();}}

使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装下面让我们一起来研究一下多线程使用中的一些问题。

三、线程的四种状态

1、新状态：线程已被创建但尚未执行（start（）尚未被调用）。

2、可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。

3、阻塞状态：线程不会被分配 CPU 时间，无法执行；可能阻塞于I/O，或者阻塞于同步锁。

4、死亡状态：正常情况下run（）返回使得线程死亡。调用 stop（）或 destroy（）亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。

四、线程的优先级

线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

你可以调用 Thread 类的方法 getPriority（）和 setPriority（）来存取线程的优先级，线程的优先级界于1（MIN_PRIORITY）和10（MAX_PRIORITY）之间，缺省是5（NORM_PRIORITY）。

五、线程的同步

由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

1. synchronized 方法：通过在方法声明中加入synchronized关键字来声明 synchronized 方法。synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized，以控制其对类的静态成员变量的访问。

synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法run（）声明为synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何synchronized方法的调用都永远不会成功。

2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：

synchronized(syncObject) {//允许访问控制的代码}

synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject 的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

相关学习推荐：编程视频

　　以上就是java多线程指的是什么的知识。速戳>>知识兔学习精品课！

java安装win10教程：首先下载JDK；然后配置用户变量和系统变量；接着配置系统变量path，在path里面加入路径值；最后测试是否成功即可。

java安装教程win10

一.下载JDK

如果不修改安装路径，一直点击下一步，安装好

相关学习推荐：java基础教程

二.配置环境变量

1.用户变量

新建用户变量，变量名为： JAVA_HOME ，变量值为； C:Program FilesJavajdk1.8.0_131，也就是JDK安装的路径

2.系统变量

新建系统变量，变量名为：JAVA_HOME，变量值为：C:Program FilesJavajdk1.8.0_131，也就是JDK安装的路径

3.配置系统变量path，在path里面加入路径值

在系统变量path里面头部，加入

%JAVA_HOME%bin;%JAVA_HOME%jrebin;

或者path里面的尾部，加入

%JAVA_HOME%bin;%JAVA_HOME%jrebin;

其实就是注意与前面之间的分割符;，注意是半角分号

4.测试是否成功

win+r或直接输入cmd，进入命令行

输入：javac，Java等进行测试

相关学习推荐：java基础教程

　　以上就是json格式不正确怎么解决的知识。速戳>>知识兔学习精品课！

java常用代码有：1、字符串有整型的相互转换；2、向文件末尾添加内容；3、得到当前方法的名字；4、转字符串到日期；5、使用JDBC链接Oracle；6、使用NIO进行快速的文件拷贝。

java常用代码有：

1. 字符串有整型的相互转换

String a = String.valueOf(2); //integer to numeric string int i = Integer.parseInt(a); //numeric string to an int

相关学习推荐：java基础教程

2. 向文件末尾添加内容

BufferedWriter out = null; try { out = new BufferedWriter(new FileWriter(”filename”, true)); out.write(”aString”); } catch (IOException e) { // error processing code } finally { if (out != null) { out.close(); } }

3. 得到当前方法的名字

String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();

4. 转字符串到日期

java.util.Date = java.text.DateFormat.getDateInstance().parse(date String);//或者是：SimpleDateFormat format = new SimpleDateFormat( "dd.MM.yyyy" ); Date date = format.parse( myString );

5. 使用JDBC链接Oracle

public class OracleJdbcTest { String driverClass = "oracle.jdbc.driver.OracleDriver"; Connection con; public void init(FileInputStream fs) throws ClassNotFoundException, SQLException, FileNotFoundException, IOException { Properties props = new Properties(); props.load(fs); String url = props.getProperty("db.url"); String userName = props.getProperty("db.user"); String password = props.getProperty("db.password"); Class.forName(driverClass); con=DriverManager.getConnection(url, userName, password); } public void fetch() throws SQLException, IOException { PreparedStatement ps = con.prepareStatement("select SYSDATE from dual"); ResultSet rs = ps.executeQuery(); while (rs.next()) { // do the thing you do } rs.close(); ps.close(); } public static void main(String[] args) { OracleJdbcTest test = new OracleJdbcTest(); test.init(); test.fetch(); } }

6. 把 Java util.Date 转成 sql.Date

java.util.Date utilDate = new java.util.Date(); java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());

7. 使用NIO进行快速的文件拷贝

public static void fileCopy( File in, File out ) throws IOException { FileChannel inChannel = new FileInputStream( in ).getChannel(); FileChannel outChannel = new FileOutputStream( out ).getChannel(); try { // inChannel.transferTo(0, inChannel.size(), outChannel); // original -- apparently has trouble copying large files on Windows // magic number for Windows, 64Mb - 32Kb) int maxCount = (64 * 1024 * 1024) - (32 * 1024); long size = inChannel.size(); long position = 0; while ( position < size ) { position += inChannel.transferTo( position, maxCount, outChannel ); } } finally { if ( inChannel != null ) { inChannel.close(); } if ( outChannel != null ) { outChannel.close(); } } }

8. 创建图片的缩略图

private void createThumbnail(String filename, int thumbWidth, int thumbHeight, int quality, String outFilename) throws InterruptedException, FileNotFoundException, IOException { // load image from filename Image image = Toolkit.getDefaultToolkit().getImage(filename); MediaTracker mediaTracker = new MediaTracker(new Container()); mediaTracker.addImage(image, 0); mediaTracker.waitForID(0); // use this to test for errors at this point: System.out.println(mediaTracker.isErrorAny()); // determine thumbnail size from WIDTH and HEIGHT double thumbRatio = (double)thumbWidth / (double)thumbHeight; int imageWidth = image.getWidth(null); int imageHeight = image.getHeight(null); double imageRatio = (double)imageWidth / (double)imageHeight; if (thumbRatio < imageRatio) { thumbHeight = (int)(thumbWidth / imageRatio); } else { thumbWidth = (int)(thumbHeight * imageRatio); } // draw original image to thumbnail image object and // scale it to the new size on-the-fly BufferedImage thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB); Graphics2D graphics2D = thumbImage.createGraphics(); graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null); // save thumbnail image to outFilename BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFilename)); JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out); JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(thumbImage); quality = Math.max(0, Math.min(quality, 100)); param.setQuality((float)quality / 100.0f, false); encoder.setJPEGEncodeParam(param); encoder.encode(thumbImage); out.close(); }

9.创建 JSON 格式的数据

并下面这个JAR 文件：json-rpc-1.0.jar (75 kb)/http://t.cn/Rz0bhUA

import org.json.JSONObject; ... ... JSONObject json = new JSONObject(); json.put("city", "Mumbai"); json.put("country", "India"); ... String output = json.toString(); ...

10. 使用iText JAR生成PDF

import java.io.File; import java.io.FileOutputStream; import java.io.OutputStream; import java.util.Date; import com.lowagie.text.Document; import com.lowagie.text.Paragraph; import com.lowagie.text.pdf.PdfWriter; public class GeneratePDF { public static void main(String[] args) { try { OutputStream file = new FileOutputStream(new File("C:\Test.pdf")); Document document = new Document(); PdfWriter.getInstance(document, file); document.open(); document.add(new Paragraph("Hello Kiran")); document.add(new Paragraph(new Date().toString())); document.close(); file.close(); } catch (Exception e) { e.printStackTrace(); } } }

11. HTTP 代理设置

System.getProperties().put("http.proxyHost", "someProxyURL"); System.getProperties().put("http.proxyPort", "someProxyPort"); System.getProperties().put("http.proxyUser", "someUserName"); System.getProperties().put("http.proxyPassword", "somePassword");

12. 单实例Singleton 示例

public class SimpleSingleton { private static SimpleSingleton singleInstance = new SimpleSingleton(); //Marking default constructor private //to avoid direct instantiation. private SimpleSingleton() { } //Get instance for class SimpleSingleton public static SimpleSingleton getInstance() { return singleInstance; } }

13. 抓屏程序

import java.awt.Dimension; import java.awt.Rectangle; import java.awt.Robot; import java.awt.Toolkit; import java.awt.image.BufferedImage; import javax.imageio.ImageIO; import java.io.File; ... public void captureScreen(String fileName) throws Exception { Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Rectangle screenRectangle = new Rectangle(screenSize); Robot robot = new Robot(); BufferedImage image = robot.createScreenCapture(screenRectangle); ImageIO.write(image, "png", new File(fileName)); } ...

14. 列出文件和目录

File dir = new File("directoryName"); String[] children = dir.list(); if (children == null) { // Either dir does not exist or is not a directory } else { for (int i=0; i < children.length; i++) { // Get filename of file or directory String filename = children[i]; } } // It is also possible to filter the list of returned files. // This example does not return any files that start with `.'. FilenameFilter filter = new FilenameFilter() { public boolean accept(File dir, String name) { return !name.startsWith("."); } }; children = dir.list(filter); // The list of files can also be retrieved as File objects File[] files = dir.listFiles(); // This filter only returns directories FileFilter fileFilter = new FileFilter() { public boolean accept(File file) { return file.isDirectory(); } }; files = dir.listFiles(fileFilter);

15. 创建ZIP和JAR文件

import java.util.zip.*; import java.io.*; public class ZipIt { public static void main(String args[]) throws IOException { if (args.length < 2) { System.err.println("usage: java ZipIt Zip.zip file1 file2 file3"); System.exit(-1); } File zipFile = new File(args[0]); if (zipFile.exists()) { System.err.println("Zip file already exists, please try another"); System.exit(-2); } FileOutputStream fos = new FileOutputStream(zipFile); ZipOutputStream zos = new ZipOutputStream(fos); int bytesRead; byte[] buffer = new byte[1024]; CRC32 crc = new CRC32(); for (int i=1, n=args.length; i < n; i++) { String name = args[i]; File file = new File(name); if (!file.exists()) { System.err.println("Skipping: " + name); continue; } BufferedInputStream bis = new BufferedInputStream( new FileInputStream(file)); crc.reset(); while ((bytesRead = bis.read(buffer)) != -1) { crc.update(buffer, 0, bytesRead); } bis.close(); // Reset to beginning of input stream bis = new BufferedInputStream( new FileInputStream(file)); ZipEntry entry = new ZipEntry(name); entry.setMethod(ZipEntry.STORED); entry.setCompressedSize(file.length()); entry.setSize(file.length()); entry.setCrc(crc.getValue()); zos.putNextEntry(entry); while ((bytesRead = bis.read(buffer)) != -1) { zos.write(buffer, 0, bytesRead); } bis.close(); } zos.close(); } }

16. 解析/读取XML 文件

XML文件

<?xml version="1.0"?> <students> <student> <name>John</name> <grade>B</grade> <age>12</age> </student> <student> <name>Mary</name> <grade>A</grade> <age>11</age> </student> <student> <name>Simon</name> <grade>A</grade> <age>18</age> </student> </students>

Java代码

<span style="font-family:Arial;font-size:14px;">package net.viralpatel.java.xmlparser; import java.io.File; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; public class XMLParser { public void getAllUserNames(String fileName) { try { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); File file = new File(fileName); if (file.exists()) { Document doc = db.parse(file); Element docEle = doc.getDocumentElement(); // Print root element of the document System.out.println("Root element of the document: " + docEle.getNodeName()); NodeList studentList = docEle.getElementsByTagName("student"); // Print total student elements in document System.out .println("Total students: " + studentList.getLength()); if (studentList != null && studentList.getLength() > 0) { for (int i = 0; i < studentList.getLength(); i++) { Node node = studentList.item(i); if (node.getNodeType() == Node.ELEMENT_NODE) { System.out .println("====================="); Element e = (Element) node; NodeList nodeList = e.getElementsByTagName("name"); System.out.println("Name: " + nodeList.item(0).getChildNodes().item(0) .getNodeValue()); nodeList = e.getElementsByTagName("grade"); System.out.println("Grade: " + nodeList.item(0).getChildNodes().item(0) .getNodeValue()); nodeList = e.getElementsByTagName("age"); System.out.println("Age: " + nodeList.item(0).getChildNodes().item(0) .getNodeValue()); } } } else { System.exit(1); } } } catch (Exception e) { System.out.println(e); } } public static void main(String[] args) { XMLParser parser = new XMLParser(); parser.getAllUserNames("c:\test.xml"); } }

17. 把 Array 转换成 Map

import java.util.Map; import org.apache.commons.lang.ArrayUtils; public class Main { public static void main(String[] args) { String[][] countries = { { "United States", "New York" }, { "United Kingdom", "London" }, { "Netherland", "Amsterdam" }, { "Japan", "Tokyo" }, { "France", "Paris" } }; Map countryCapitals = ArrayUtils.toMap(countries); System.out.println("Capital of Japan is " + countryCapitals.get("Japan")); System.out.println("Capital of France is " + countryCapitals.get("France")); } }

18. 发送邮件

import javax.mail.*; import javax.mail.internet.*; import java.util.*; public void postMail( String recipients[ ], String subject, String message , String from) throws MessagingException { boolean debug = false; //Set the host smtp address Properties props = new Properties(); props.put("mail.smtp.host", "smtp.example.com"); // create some properties and get the default Session Session session = Session.getDefaultInstance(props, null); session.setDebug(debug); // create a message Message msg = new MimeMessage(session); // set the from and to address InternetAddress addressFrom = new InternetAddress(from); msg.setFrom(addressFrom); InternetAddress[] addressTo = new InternetAddress[recipients.length]; for (int i = 0; i < recipients.length; i++) { addressTo[i] = new InternetAddress(recipients[i]); } msg.setRecipients(Message.RecipientType.TO, addressTo); // Optional : You can also set your custom headers in the Email if you Want msg.addHeader("MyHeaderName", "myHeaderValue"); // Setting the Subject and Content Type msg.setSubject(subject); msg.setContent(message, "text/plain"); Transport.send(msg); }

19. 发送代数据的HTTP 请求

import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.URL; public class Main { public static void main(String[] args) { try { URL my_url = new URL("http://coolshell.cn/"); BufferedReader br = new BufferedReader(new InputStreamReader(my_url.openStream())); String strTemp = ""; while(null != (strTemp = br.readLine())){ System.out.println(strTemp); } } catch (Exception ex) { ex.printStackTrace(); } } }

20. 改变数组的大小

/** * Reallocates an array with a new size, and copies the contents * of the old array to the new array. * @param oldArray the old array, to be reallocated. * @param newSize the new array size. * @return A new array with the same contents. */private static Object resizeArray (Object oldArray, int newSize) { int oldSize = java.lang.reflect.Array.getLength(oldArray); Class elementType = oldArray.getClass().getComponentType(); Object newArray = java.lang.reflect.Array.newInstance( elementType,newSize); int preserveLength = Math.min(oldSize,newSize); if (preserveLength > 0) System.arraycopy (oldArray,0,newArray,0,preserveLength); return newArray; } // Test routine for resizeArray(). public static void main (String[] args) { int[] a = {1,2,3}; a = (int[])resizeArray(a,5); a[3] = 4; a[4] = 5; for (int i=0; i<a.length; i++) System.out.println (a[i]); }

相关学习推荐：编程视频

　　以上就是java常用代码有哪些的知识。速戳>>知识兔学习精品课！

java调用php接口的方法：首先使用PostMethod创建一个请求方法，并设置header参数；然后设置请求过程中要传递的参数值；接着执行请求方法返回code；最后封装返回结果即可。

java调用php接口的方法：

1、先创建一个请求方法，这里就先判断下编码格式，如图

相关学习推荐：java基础教程

2、然后创建请求方式这里使用的是PostMethod，如图

3、然后设置下header参数，php只有当content-type为application/x-www-data-urlencoded和multipart/form-data的两种情况下参数，如图

4、设置请求过程中要传递的参数值，如图

5、然后执行请求方法返回code

6、最后封装返回结果，然后就可以调用这个方法传入php的接口地址了，如图

相关学习推荐：php编程（视频）

　　以上就是java调用php接口的方法是什么的知识。速戳>>知识兔学习精品课！

jvm类加载的过程：首先执行加载；然后验证确保Class文件的字节流中包含的信息符合当前虚拟机的要求；接着准备为类的静态变量分配内存，初始化为系统的初始值；最后解析，并初始化。

jvm类加载的过程：

1.加载

加载时jvm做了这三件事：

1）通过一个类的全限定名来获取该类的二进制字节流

2）将这个字节流的静态存储结构转化为方法区运行时数据结构

3）在内存堆中生成一个代表该类的java.lang.Class对象，作为该类数据的访问入口

2.验证

验证、准备、解析这三步可以看做是一个连接的过程，将类的字节码连接到JVM的运行状态之中

验证是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，不会威胁到jvm的安全

验证主要包括以下几个方面的验证：

1）文件格式的验证，验证字节流是否符合Class文件的规范，是否能被当前版本的虚拟机处理

2）元数据验证，对字节码描述的信息进行语义分析，确保符合java语言规范

3）字节码验证通过数据流和控制流分析，确定语义是合法的，符合逻辑的

4）符号引用验证这个校验在解析阶段发生

3.准备，为类的静态变量分配内存，初始化为系统的初始值。对于final static修饰的变量，

直接赋值为用户的定义值。如下面的例子：这里在准备阶段过后的初始值为0，而不是7

public static int a=7

4.解析

解析是将常量池内的符号引用转为直接引用（如物理内存地址指针）

5.初始化

到了初始化阶段，jvm才真正开始执行类中定义的java代码

1）初始化阶段是执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译器自动收集

类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生的。

2）当初始化一个类的时候，如果发现其父类还没有进行过初始化、则需要先触发其父类的初始化。

3）虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

相关学习推荐：java基础教程

　　以上就是jvm类加载的过程是什么的知识。速戳>>知识兔学习精品课！

前言在开始分享之前，请大家思考三个问题。1，什么是多态？2，多态有几种实现方式（除了接口还有什么可以实现多态，答案不唯一。）3，多态的好处答案：大家可以把自己的见解分享到下面评论里下面以接口的方式，实现多态。

案例案例分析功能分析：关系图：案例实现结果源码模块下载

相关学习推荐：java基础教程

案例

案例分析

功能分析：

知识兔

关系图：

知识兔

从这个关系图里可以看到，接口和电脑之间的关系。以及接口和鼠标，键盘之间的关系。

案例实现

USB接口：

package cn.itcast.day10.demo07;public interface USB { void open();//打开设备 void close();//关闭设备}

键盘类：实现USB接口

package cn.itcast.day10.demo07;//键盘本身就是一个USB设备public class keyboard implements USB { @Override public void open() { System.out.println("打开键盘"); } @Override public void close() { System.out.println("关闭键盘"); }}

鼠标类：实现USB接口

package cn.itcast.day10.demo07;//鼠标本身就是一个USB设备public class Mouse implements USB { @Override public void open() { System.out.println("打开鼠标"); } @Override public void close() { System.out.println("关闭鼠标"); }}

计算机类：使用USB接口

package cn.itcast.day10.demo07;public class Computer { //电脑本身自带的功能 public void powerOn(){ System.out.println("笔记本电脑开机"); } public void powerOff(){ System.out.println("笔记本电脑关机"); } //使用USB接口方法 public void useDevice(USB usb){ usb.open(); usb.close(); }}

客户端类：

package cn.itcast.day10.demo07;public class DemoMain { public static void main(String[] args) { Computer computer=new Computer();//实例化电脑 //省略向上转型 computer.powerOn(); computer.useDevice(new Mouse()); //使用向上转型 USB usb=new keyboard(); computer.useDevice(usb); computer.powerOff(); }}

结果

相关学习推荐：编程视频

　　以上就是Java接口实现多态之笔记本电脑综合实例的知识。速戳>>知识兔学习精品课！

先建个钉钉群，并加好机器人

此时，机器人已经添加完毕，接下来编写我们连接机器人小哥的代码

import com.alibaba.fastjson.JSON;import com.google.common.collect.Lists;import com.google.common.collect.Maps;import java.util.List;import java.util.Map;/** * @author yanghao * @version DingTalkTest.java, v 0.1 2019-03-29 11:36 */public class DingTalkTest { public static void main(String[] args){ try { //钉钉机器人地址（配置机器人的webhook） String dingUrl = "https://oapi.dingtalk.com/robot/send?access_token=............"; //是否通知所有人 boolean isAtAll = false; //通知具体人的手机号码列表 List<String> mobileList = Lists.newArrayList(); //钉钉机器人消息内容 String content = "小哥，你好！"; //组装请求内容 String reqStr = buildReqStr(content, isAtAll, mobileList); //推送消息（http请求） String result = HttpUtil.postJson(dingUrl, reqStr); System.out.println("result == " + result); }catch (Exception e){ e.printStackTrace(); } } /** * 组装请求报文 * @param content * @return */ private static String buildReqStr(String content, boolean isAtAll, List<String> mobileList) { //消息内容 Map<String, String> contentMap = Maps.newHashMap(); contentMap.put("content", content); //通知人 Map<String, Object> atMap = Maps.newHashMap(); //1.是否通知所有人 atMap.put("isAtAll", isAtAll); //2.通知具体人的手机号码列表 atMap.put("atMobiles", mobileList); Map<String, Object> reqMap = Maps.newHashMap(); reqMap.put("msgtype", "text"); reqMap.put("text", contentMap); reqMap.put("at", atMap); return JSON.toJSONString(reqMap); }}

运行结果如下：

result == {"errmsg":"ok","errcode":0}

钉钉群显示消息：

ok,简单的消息推送，这就完成了！

我们再来测试一下通知所有人和通知具体人

将isAtAll更改为true

//是否通知所有人boolean isAtAll = true;//通知具体人的手机号码列表List<String> mobileList = Lists.newArrayList();

增加通知人号码列表（注：isAtAll和mobileList 不能同时生效）

//是否通知所有人boolean isAtAll = false;//通知具体人的手机号码列表List<String> mobileList = Lists.newArrayList();mobileList.add("182********");

再来测试一下特殊符号

换行标识符

/** * 换行标识符 */private static final String NEWLINE = "

";//钉钉机器人消息内容//String content = "小哥，你好！";StringBuffer sb = new StringBuffer();sb.append("小哥，你好！") .append(NEWLINE) .append("看会书");String content = sb.toString();

emoji图片

先获取emoji图片的unicode编码

编写代码如下：

/** * 苹果unicode编码 */private static final String APPLE = "🍎";//钉钉机器人消息内容//String content = "小哥，你好！";StringBuffer sb = new StringBuffer();sb.append("小哥，你好！") .append(NEWLINE) .append("看会书") .append(NEWLINE) .append("吃个").append(APPLE);String content = sb.toString();

通常在我们的项目中，作为一些告警加入，方便且实用很有意思的钉钉机器人，很多实用技巧，可以深入去探索一波！

更新于2019-12-05

很多小伙伴留言咨询http请求，这边给大家2个http请求代码

1. maven项目

添加依赖

<dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>4.0.12</version></dependency>

http请求代码

private static final int timeout = ; public static String postJson(String url, String reqStr) { String body = null; try { body = HttpRequest.post(url).body(reqStr).timeout(timeout).execute().body(); } catch (Exception e) { e.printStackTrace(); } return body;}

2. 非maven项目

添加jar包httpclient-xxx.jarcommons-logging-xxx.jar

http请求代码

public static String postJson(String url, String body) { // 创建Httpclient对象 CloseableHttpClient httpClient = createCustomClient(); CloseableHttpResponse response = null; String resultString = null; try { // 创建Http Post请求 HttpPost httpPost = new HttpPost(url); httpPost.addHeader("Content-Type", "application/json"); if (body != null) { httpPost.setEntity(new StringEntity(body, "utf-8")); } // 执行http请求 response = httpClient.execute(httpPost); resultString = EntityUtils.toString(response.getEntity(), "utf-8"); } catch (Exception e) { e.printStackTrace(); } finally { try { if (response != null) { response.close(); } } catch (Exception e) { e.printStackTrace(); } } return resultString; } public static CloseableHttpClient createCustomClient() { RequestConfig defaultRequestConfig = RequestConfig.custom() .setSocketTimeout(120 * 1000) .setConnectTimeout(120 * 1000) .setConnectionRequestTimeout(120 * 1000) .setStaleConnectionCheckEnabled(true) .build(); return HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig).build(); }

方法仅供参考，项目里面有现成的http请求，可以直接用！

相关学习推荐：java基础教程

　　以上就是学习java实现钉钉机器人消息推送的示例代码的知识。速戳>>知识兔学习精品课！

java中char类型占2个字节，char类型字节与我们使用的字符集有关系，如果使用ASCII编码集，那么char占用一个字节，如果使用UTF8编码格式，那么char占用两个字节。

char在设计之初的时候被用来存储字符，可是世界上那么多字符，如果有1个字节，就意味着只能存储256中，显然不合适，而如果有两个字节呢，那么就可以存储2^16()种，这个数量符合大多数国家的语言字符个数于是Java团队使用unicode作为编码，一个char作为2个字节来存储。

但是unicode只是一个标准，具体的实现还是有如：UTF-8或UTF-16等编码。

Java的char一定是2个字节吗？

不一定，与我们使用的字符集有关系，如果使用ASCII编码集，那么char占用一个字节，如果使用UTF-8编码格式呢？UTF-8是不定长编码，编码的长度是动态的，所以不一定。

char能存储中文吗？

这个问题依旧归结于使用的编码集，如果使用ASCII，那肯定不能存储，如果采用UTF-8，那可以。

总结

char的长度和是否能存储中文字符是和编码格式有关的。对于我们在编码的时候如果跨平台编码时，应该在编码、解码的时候设置对应的格式，防止由于编解码导致的异常。

相关学习推荐：java基础教程

　　以上就是java中char类型占几个字节的知识。速戳>>知识兔学习精品课！

区别：Android是一种基于Linux的开放源码操作系统，主要用于便携设备（智能手机，平板电脑）；Java是一种面向对象的编程语言。学Android的主要从事移动互联方向开发，学Java的主要从事软件方向开发。

Android和JAVA区别：

简单地说，一种是操作系统，一种是开发语言。

具体来说，Android是一种基于Linux的开放源码操作系统，主要用于便携设备（智能手机，平板电脑）。Java是一种面向对象的编程语言，它的最大的特点就是开源和免费，这因为如此，中国的大部分大型的软件系统是用Java开发的。

Android的应用层上的应用程序是用Java编写的，以Java作为开发语言，但是，Java并不等同于Android，因为Android SDK引用了Java SDK的大部分，少数部分被Android SDK所抛弃。所以，要想从事Android的开发,就必须有Java基础。另外，在Windows系统中可以搭建Android的Java开发环境，这样就可以实现在Windows系统中测试Android项目了。

Android开发与JAVA两者是相辅相成的。JAVA给Android提供了开发的语言环境，Android的开发通过JAVA语言去实现。

更多编程相关知识，可访问：编程入门！！

　　以上就是android和java的区别是什么？的知识。速戳>>知识兔学习精品课！

java数组使用的方法：首先使用前先声明数组，告诉计算机数据类型是什么；然后分配空间，告诉计算机分配几个连续的空间；最后给数组赋值。

【相关学习推荐：java基础教程】

java数组使用的方法：

1、我们学习了java中数组的定义和意思，但是怎么使用呢？我们在实验数组的时候使用关键字NEW进行实例化数组，才能使用，从第五步开始我们详细介绍。

2、使用前先声明数组。声明数组就是告诉计算机数据类型是什么。具体实现步骤如下

3、然后分配空间。分配空间就是告诉计算机分配几个连续的空间。

4、最后给数组赋值。给数组赋值就是向分配的格子里放数据、

5、如何给数组赋值。上面我们介绍了给数组赋值，但是具体怎样赋值呢？一般有两种情况，也是最经常使用的情况，记住不要使数组的大小超过长度。

相关学习推荐：编程视频

　　以上就是java数组怎么使用的知识。速戳>>知识兔学习精品课！

java输入换行的方法：1、换一行，使用【System.out.println()】；2、换两行，使用【System.out.println("

")】；3、换三行，使用【System.out.println("

)】。

java输入换行的方法：

第一种：使用

System.out.println()

这是换一行。

第二种：使用

System.out.print("

");

这也是换一行.

第一种和第二种差不多。只是，如果你要换两行，三行，多行的话。

就用：

System.out.println("

");

换两行

换三行：

System.out.println("

);

相关学习推荐：java基础教程

　　以上就是java怎么输入换行的知识。速戳>>知识兔学习精品课！

java的api打开方法：首先下载Oracle，并选择【...for Developers】；然后点击界面右侧的【Java APIs】；最后击自己需要的版本，就可以在线打开相应的Java API文档。

java的api打开方法：

1、打开百度，搜索Oracle，打开Oracle官方网站。

2、点击Oracle网站界面下方的“Download Java for Developers”。

3、点击界面右侧的“Java APIs”。

4、接着就可以看到各个版本的Java API。

5、点击自己需要的版本，就可以在线打开相应的Java API文档。

相关学习推荐：java基础教程

　　以上就是java的api怎么打开的知识。速戳>>知识兔学习精品课！

java保存数据的方法：1、使用寄存器保存，是最快的保存区域；2、使用堆栈，会创建新的内存；3、使用静态存储，其将随时等候调用；4、使用常数存储，是直接置于程序代码内部。

java保存数据的方法：

(1) 寄存器。

这是最快的保存区域，因为它位于和其他所有保存方式不同的地方：处理器内部。然而，寄存器的数量十分有限，所以寄存器是根据需要由编译器分配。我们对此没有直接的控制权，也不可能在自己的程序里找到寄存器存在的任何踪迹。

(2) 堆栈。

驻留于常规RAM（随机访问存储器）区域，但可通过它的“堆栈指针”获得处理的直接支持。堆栈指针若向下移，会创建新的内存；若向上移，则会释放那些内存。这是一种特别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java 编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java 数据要保存在堆栈里——特别是对象句柄，但Java 对象并不放到其中。

(3) 堆。

一种常规用途的内存池（也在RAM 区域），其中保存了Java 对象。和堆栈不同，“内存堆”或“堆”（Heap）最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new 命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！

(4) 静态存储。

这儿的“静态”（Static）是指“位于固定位置”（尽管也在RAM 里）。程序运行期间，静态存储的数据将随时等候调用。可用static 关键字指出一个对象的特定元素是静态的。但Java 对象本身永远都不会置入静态存储空间。

(5) 常数存储。

常数值通常直接置于程序代码内部。这样做是安全的，因为它们永远都不会改变。有的常数需要严格地保护，所以可考虑将它们置入只读存储器（ROM）。

(6) 非RAM 存储。

若数据完全独立于一个程序之外，则程序不运行时仍可存在，并在程序的控制范围之外。其中两个最主要的例子便是“流式对象”和“固定对象”。对于流式对象，对象会变成字节流，通常会发给另一台机器。而对于固定对象，对象保存在磁盘中。即使程序中止运行，它们仍可保持自己的状态不变。对于这些类型的数据存储，一个特别有用的技巧就是它们能存在于其他媒体中。一旦需要，甚至能将它们恢复成普通的、基于RAM 的对象。Java 1.1 提供了对Lightweight persistence 的支持。未来的版本甚至可能提供更完整的方案。

相关学习推荐：java基础教程

　　以上就是java怎么保存数据的知识。速戳>>知识兔学习精品课！

java运算符优先级：1、级别高的运算符先执行运算，级别低的运算符后执行运算；2、小括号【（）】优先级最高，表达式含有小括号的，优先执行小括号的内容，如果包含多个小括号，执行顺序是从左到右。

java运算符优先级：

Java表达式可能存在多个运算符，运算符之间存在优先级的关系，级别高的运算符先执行运算，级别低的运算符后执行运算，下表列出了运算符的优先级。表中优先级栏，数字越小优先级越高，每个运算符用中文顿号分割。

表中结合性指运算符结合的顺序，通常都是从左到右。从右到左的运算符最典型的就是数值前面的正负号，例如3+-4，则意义为3加-4，符号首先和运算符右侧的内容结合。

表中运算符‘[]’前面没有讲到，该运算符表示声明一个数组，关于数组后面会详细讲述。

表中小括号‘()’优先级最高，表达式含有小括号的，优先执行小括号的内容，如果包含多个小括号，执行顺序是从左到右。

例如，假设变量a的值为12，下述语句的执行会有不同的结果：

（1）执行 a + 18 % 4 ，因为运算符%的优先级高于运算符+，该语句先执行取余运算，再执行加法运算，其结果为14；

（2）执行( a + 18 ) % 4 ，因为小括号的优先级最高，该语句先执行小括号里的表达式a+18，再执行取余运算，其结果为2;

（3）执行 a * ( ( a + 18 ) % 4 )，该语句括号内嵌套括号，执行顺序是先执行内层括号的运算，再执行外层括号的运算，其运算结果为24。

程序功能主要是演示运算符的优先级。

语句“a += ++b;”，涉及到运算符+=和++两个运算符，从运算符优先级表可知，++运算符的优先级要高于+=运算符，b应先做自增运算，然后再与a相加，结果为15。一个特例是，语句“a += b++;”，虽然++的优先级高于+=，但此语句的++是后缀式，后缀式是先使用再自增（参见算术运算符一节），因此，b先与a相加后，再做自增运算，结果为14。

编译“PrioritySample.java”文件，在命令行窗口输入“javac PrioritySample.java”并执行命令，编译通过后，在命令行窗口输入“java PrioritySample”运行Java程序，命令行窗口显示如下信息：

从上述结果可以看出，++运算符的优先级要高于+=运算符，b应先做自增运算，然后再与a相加，结果为15

相关学习推荐：java基础教程

　　以上就是java运算符优先级是什么样的的知识。速戳>>知识兔学习精品课！

【相关学习推荐：java基础教程】

案例：

知识兔

在这里插入图片描述

案例图解：

知识兔

划分为三个类，一个父类把金额和姓名都放在父类里。然后在新建两个类，分别是群主类和普通成员类。群主类有发红包的方法，普通成员类里有收红包的方法。也就是只有群主才可以发红包，普通成员只能收红包。

代码实现：

知识兔

父类

package cn.itcast.day09.demo14;public class User { private String name;//姓名 private int money;//余额 public User() { } public User(String name, int money) { this.name = name; this.money = money; } //显示余额 public void show(){ System.out.println("我叫"+name+"，我有多少钱；"+money); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; }}

群主类：

package cn.itcast.day09.demo14;import cn.itcast.day09.demo04.Arraylis;import java.util.ArrayList;public class Manager extends User { public Manager(){ } public Manager(String name, int money) { super(name, money); } //发红包方法 public ArrayList<Integer> send(int totalMoney,int count){ //首先需要一个集合，用来存储若干个红包金额 ArrayList<Integer> redList=new ArrayList<>(); //首先看下群主自己有多少钱 int LeftMoney=super.getMoney();//获取群主当前余额 //判断群主余额是否充足 if(totalMoney>LeftMoney){ System.out.println("余额不足"); return redList;//返回空集合 } //扣钱，更新余额。 //公式：最新余额=上次余额-发的钱 super.setMoney(LeftMoney-totalMoney); //发红包需要平均拆分成为count份 int avg=totalMoney/count; int mod=totalMoney %count;//余数，也就是零头 //下面把红包一个一个放到集合当中 for (int i = 0; i < count-1; i++) { redList.add(avg); //除不开的零头，抱在最后一个红包当中 /*if(i==count-1){ redList.add(avg+mod); }*/ } int last=(avg+mod); //除不开的零头，抱在最后一个红包当中 redList.add(last); return redList; }}

普通成员类：

package cn.itcast.day09.demo14;import java.util.ArrayList;import java.util.Random;//普通成员public class Member extends User{ public Member() { } public Member(String name, int money) { super(name, money); } //收红包的方法 public void recive(ArrayList<Integer> list){ //从多个红包当中随便抽取一个，给自己 //随机获取一个list集合当中的随机编号 int index=new Random().nextInt(list.size()); //根据索引，从集合当中删除，并且得到被删除的红包给自己。 int delta=list.remove(index); //当前成员本来有多少钱 int money=super.getMoney(); //从新设置余额 super.setMoney(money+delta); }}

客户端：

package cn.itcast.day09.demo14;import java.util.ArrayList;public class MainRedPacket { public static void main(String[] args) { Manager manager=new Manager("群主",100); Member one=new Member("成员A",0); Member two=new Member("成员B",0); Member three=new Member("成员C",0); manager.show(); one.show(); two.show(); three.show(); System.out.println("================================="); ArrayList<Integer> redList=manager.send(20,3); //三个普通成员收红包 one.recive(redList); two.recive(redList); three.recive(redList); //群主最新余额 manager.show(); //成员最新余额 one.show(); two.show(); three.show(); }}

结果

知识兔

相关学习推荐：编程视频

　　以上就是Java发红包实例之继承练习的知识。速戳>>知识兔学习精品课！

java异常捕获与处理的方法：1、throws关键字，由系统自动将所捕获的异常信息抛给上级调用方法；2、throw的作用是手工抛出异常类的实例化对象；3、RunException是Exception的子类，由用户选择是否进行处理。

【相关学习推荐：java基础教程】

java异常捕获与处理的方法：

一、异常处理的使用

由于finally块是可以省略的，异常处理格式可以分为三类：try{ }——catch{ }、try{ }——catch{ }——finally{ }、try{ }——finally{ }。

1 public class DealException 2 { 3 public static void main(String args[]) 4 { 5 try 6 //要检查的程序语句 7 { 8 int a[] = new int[5]; 9 a[10] = 7;//出现异常10 }11 catch(ArrayIndexOutOfBoundsException ex)12 //异常发生时的处理语句13 {14 System.out.println("超出数组范围！");15 }16 finally17 //这个代码块一定会被执行18 {19 System.out.println("*****");20 }21 System.out.println("异常处理结束！");22 }23 }

可以看出，在异常捕捉的过程中要进行两个判断，第一是try程序块是否有异常产生，第二是产生的异常是否和catch()括号内想要捕捉的异常相同。

那么，如果出现的异常和catch()内想要捕捉的异常不相同时怎么办呢？事实上我们可以在一个try语句后跟上多个异常处理catch语句，来处理多种不同类型的异常。

1 public class DealException 2 { 3 public static void main(String args[]) 4 { 5 try 6 //要检查的程序语句 7 { 8 int a[] = new int[5]; 9 a[0] = 3;10 a[1] = 1;11 //a[1] = 0;//除数为0异常12 //a[10] = 7;//数组下标越界异常13 int result = a[0]/a[1];14 System.out.println(result);15 }16 catch(ArrayIndexOutOfBoundsException ex)17 //异常发生时的处理语句18 {19 System.out.println("数组越界异常");20 ex.printStackTrace();//显示异常的堆栈跟踪信息21 }22 catch(ArithmeticException ex)23 {24 System.out.println("算术运算异常");25 ex.printStackTrace();26 }27 finally28 //这个代码块一定会被执行29 {30 System.out.println("finally语句不论是否有异常都会被执行。");31 }32 System.out.println("异常处理结束！");33 }34 }

上述例子中ex.printStackTrace();就是对异常类对象ex的使用，输出了详细的异常堆栈跟踪信息，包括异常的类型，异常发生在哪个包、哪个类、哪个方法以及异常发生的行号。

二、throws关键字

throws声明的方法表示该方法不处理异常，而由系统自动将所捕获的异常信息抛给上级调用方法。

1 public class throwsDemo 2 { 3 public static void main(String[] args) 4 { 5 int[] a = new int[5]; 6 try 7 { 8 setZero(a,10); 9 }10 catch(ArrayIndexOutOfBoundsException ex)11 {12 System.out.println("数组越界错误！");13 System.out.println("异常："+ex);14 }15 System.out.println("main()方法结束。");16 }17 private static void setZero(int[] a,int index) throws ArrayIndexOutOfBoundsException18 {19 a[index] = 0;20 }21 }

throws关键字抛出异常，“ArrayIndexOutOfBoundsException”表明setZero()方法可能存在的异常类型，一旦方法出现异常，setZero()方法自己并不处理，而是将异常提交给它的上级调用者main()方法。

三、throw关键字

throw的作用是手工抛出异常类的实例化对象。

1 public class throwDemo 2 { 3 public static void main(String[] args) 4 { 5 try 6 { 7 //抛出异常的实例化对象 8 throw new ArrayIndexOutOfBoundsException("

个性化异常信息：

数组下标越界"); 9 }10 catch(ArrayIndexOutOfBoundsException ex)11 {12 System.out.println(ex);13 }14 }15 }

我们能发现，throw好像属于没事找事，引发运行期异常，并自定义提示信息。事实上，throw通常和throws联合使用，抛出的是程序中已经产生的异常类实例。

ExceptionDemo

输出结果：

setZero方法开始：

setZero方法结束。

异常：java.lang.ArrayIndexOutOfBoundsException: 10

main()方法结束！

四、RuntimeException类

Exception和RuntimeException的区别：

Exception:强制性要求用户必须处理；

RunException:是Exception的子类，由用户选择是否进行处理。

五、自定义异常类

自定义异常类继承自Exception类，可以使用父类的大量的方法，也可自己编写方法来处理特定的事件。Java提供用继承的方式运行用户自己编写的异常类。

1 class MyException extends Exception 2 { 3 public MyException(String message) 4 { 5 super(message); 6 } 7 } 8 public class DefinedException 9 {10 public static void main(String[] args) 11 {12 try13 {14 throw new MyException("

自定义异常类！");15 }16 catch(MyException e)17 {18 System.out.println(e);19 }20 }21 }

相关学习推荐：编程视频

　　以上就是java异常如何捕获与处理的知识。速戳>>知识兔学习精品课！

java的语法的意思是指java中的规则，即java的命名规则：1、包的命名，全部小写，由域名定义；2、类的命名，单词首字母大写；3、方法的命名，首字母小写，字母开头大写；4、常量的命名，全部大写，常加下划线。

【相关学习推荐：java基础教程】

java中的语法是指java中的规则，即java的命名规则：

1、包的命名　（全部小写，由域名定义）

Java包的名字都是由小写单词组成。但是由于Java面向对象编程的特性，每一名Java程序员都可以编写属于自己的Java包，为了保障每个Java包命名的唯一性，在最新的Java编程规范中，要求程序员在自己定义的包的名称之前加上唯一的前缀。由于互联网上的域名称是不会重复的，所以程序员一般采用自己在互联网上的域名称作为自己程序包的唯一前缀。例如：net.frontfree.javagroup

2、类的命名（单词首字母大写）

根据约定，Java类名通常以大写字母开头，如果类名称由多个单词组成，则每个单词的首字母均应为大写例如TestPage；如果类名称中包含单词缩写，则这个所写词的每个字母均应大写，如：XMLExample,还有一点命名技巧就是由于类是设计用来代表对象的，所以在命名类时应尽量选择名词。

例如： Graphics

3、方法的命名（首字母小写，字母开头大写）

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头。

例如：drawImage

4、常量的命名（全部大写，常加下划线）

常量的名字应该都使用大写字母，并且指出该常量完整含义。如果一个常量名称由多个单词组成，则应该用下划线来分割这些单词。

例如：MAX_VALUE

5、参数的命名

参数的命名规范和方法的命名规范相同，而且为了避免阅读程序时造成迷惑，请在尽量保证参数名称为一个单词的情况下使参数的命名尽可能明确。

知识扩展：

在变量命名时要注意以下几点：

1.选择有意义的名字，注意每个单词首字母要大写。

2.在一段函数中不使用同一个变量表示前后意义不同的两个数值。

3.i、j、k等只作为小型循环的循环索引变量。

4.避免用Flag来命名状态变量。

5.用Is来命名逻辑变量，如：blnFileIsFound。通过这种给布尔变量肯定形式的命名方式，使得其它开发人员能够更为清楚的理解布尔变量所代表的意义。

6.如果需要的话，在变量最后附加计算限定词，如：curSalesSum。

7.命名不相包含，curSales和curSalesSum。

8.static final 变量(常量)的名字应该都大写，并且指出完整含义。

9.如果需要对变量名进行缩写时，一定要注意整个代码中缩写规则的一致性。例如，如果在代码的某些区域中使用intCnt，而在另一些区域中又使用intCount，就会给代码增加不必要的复杂性。建议变量名中尽量不要出现缩写。

10.通过在结尾处放置一个量词，就可创建更加统一的变量，它们更容易理解，也更容易搜索。例如，请使用 strCustomerFirst和strCustomerLast，而不要使用strFirstCustomer和strLastCustomer。常用的量词后缀有：First（一组变量中的第一个）、Last（一组变量中的最后一个）、Next（一组变量中的下一个变量）、Prev（一组变量中的上一个）、Cur（一组变量中的当前变量）。

11.每个变量选择最佳的数据类型，这样即能减少对内存的需求量，加快代码的执行速度，又会降低出错的可能性。用于变量的数据类型可能会影响该变量进行计算所产生的结果。在这种情况下，编译器不会产生运行期错误，它只是迫使该值符合数据类型的要求。这类问题极难查找。

12.尽量缩小变量的作用域。如果变量的作用域大于它应有的范围，变量可继续存在，并且在不再需要该变量后的很长时间内仍然占用资源。它们的主要问题是，任何类中的任何方法都能对它们进行修改，并且很难跟踪究竟是何处进行修改的。占用资源是作用域涉及的一个重要问题。对变量来说，尽量缩小作用域将会对应用程序的可靠性产生巨大的影响。

关于常量的命名方法，在JAVA代码中，无论什么时候，均提倡应用常量取代数字、固定字符串。也就是说，程序中除0，1以外，尽量不应该出现其他数字。常量可以集中在程序开始部分定义或者更宽的作用域内，名字应该都使用大写字母，并且指出该常量完整含义。如果一个常量名称由多个单词组成，则应该用下划线“_”来分割这些单词如：NUM_DAYS_IN_WEEK、MAX_VALUE。

相关学习推荐：编程视频

　　以上就是java的语法是什么意思的知识。速戳>>知识兔学习精品课！

java md5加密的方法：1、使用 java自带jar工具MessageDigest实现，语法为【java.security.MessageDiges】；2、使用spring自带的工具DigestUtils实现。

java md5加密的方法：

1 、加密方法：

1.1 java自带jar工具MessageDigest实现

java.security.MessageDiges

public class MD5Utils { public static String stringToMD5(String plainText) { byte[] secretBytes = null; try { secretBytes = MessageDigest.getInstance("md5").digest( plainText.getBytes()); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("没有这个md5算法！"); } String md5code = new BigInteger(1, secretBytes).toString(16); for (int i = 0; i < 32 - md5code.length(); i++) { md5code = "0" + md5code; } return md5code; }}

1.2 spring自带的工具DigestUtils实现

org.springframework.util.DigestUtils

DigestUtils.md5DigestAsHex("1234".getBytes())

2 、使用方法：

@Testpublic void testMd5() throws NoSuchAlgorithmException{ MessageDigest md = MessageDigest.getInstance("MD5"); // java自带工具包MessageDigest String resultString = MD5Utils.md5(""); System.out.println(resultString); // e10adc3949ba59abbe56e057f20f883e String resultString1 = MD5Utils.md5("1234"); System.out.println(resultString1); //81dc9bdb52d04dcdbd8313ed055 // spring自带工具包DigestUtils System.out.println(DigestUtils.md5DigestAsHex("1234".getBytes())); // 81dc9bdb52d04dcdbd8313ed055}

相关学习推荐：java基础教程

　　以上就是java怎么给md5加密的知识。速戳>>知识兔学习精品课！

java用random类方法：1、函数【Random()】创建一个新的随机数生成器；2、函数【Random(long seed)】，使用单个long种子创建一个新的随机数生成器。

java用random类方法：

直接使用方法生成随机数的方法。

//随机生成1~100之间的一个整数 int randomNumber = (int)(Math.random() * 100) + 1; System.out.println(randomNumber);

还有使用Random类的方法。

Random()：创建一个新的随机数生成器。

Random(long seed)：使用单个 long 种子创建一个新的随机数生成器。

第一种构造方法是使用默认当前系统时间的毫秒数作为种子数:;

Random random = new Random();int randomNumber1= random.nextInt(100);

第二种方法是使用自己指定的种子数

Random random1 = new Random(100);for(int i = 0; i < 10; i++){System.out.print(random1.nextInt(10) + " ");}

发现只要种子数和nextInt()中的参数一致的话，每次生成的随机数都是一样的（所以这是伪随机数）。

System.out.println("

使用同一种子生成的随机数如下：");Random random2 = new Random(100);for(int i = 0; i < 10; i++){System.out.print(random2.nextInt(10) + " ");}

截图如下：

相关学习推荐：java基础教程

　　以上就是java怎么用random类方法的知识。速戳>>知识兔学习精品课！

java如何用cmd命令的方法：1、使用Runtime中【exec(String command)】方法执行cmd命令；2、先将执行的cmd命令写入到文件中后再执行，这是如果执行错误日志可以打印，线程也不会卡死。

【相关学习推荐：java基础教程】

java如何用cmd命令的方法：

1.使用Runtime中exec(String command)方法执行cmd命令，如下：

Process p = Runtime.getRuntime().exec(cmd);

此方法会抛出IOException，但是在项目中遇到没有出现异常，命令也没有执行的情况。

2.此方法可以达到大多的cmd调用的期望结果，但有些时候回出现命令卡死在p.waitFor();上，造成线程阻塞

public static boolean runCMD(String cmd) throws IOException, InterruptedException { final String METHOD_NAME = "runCMD"; Process p = Runtime.getRuntime().exec(cmd); BufferedReader br = null; try { br = new BufferedReader(new InputStreamReader(p.getErrorStream())); String readLine = br.readLine(); StringBuilder builder = new StringBuilder(); while (readLine != null) { readLine = br.readLine(); builder.append(readLine); } logger.debug(METHOD_NAME + "#readLine: " + builder.toString()); p.waitFor(); int i = p.exitValue(); logger.info(METHOD_NAME + "#exitValue = " + i); if (i == 0) { return true; } else { return false; } } catch (IOException e) { logger.error(METHOD_NAME + "#ErrMsg=" + e.getMessage()); e.printStackTrace(); throw e; } finally { if (br != null) { br.close(); } } }

3.使用以下方法不会出现和2一样情况下得阻塞的问题，与2的区别就是获取流不同，将getErrorStream换成getInputStream就好了

public static boolean runCMD(String cmd) throws IOException, InterruptedException { final String METHOD_NAME = "runCMD"; // Process p = Runtime.getRuntime().exec("cmd.exe /C " + cmd); Process p = Runtime.getRuntime().exec(cmd); BufferedReader br = null; try { // br = new BufferedReader(new InputStreamReader(p.getErrorStream())); br = new BufferedReader(new InputStreamReader(p.getInputStream())); String readLine = br.readLine(); StringBuilder builder = new StringBuilder(); while (readLine != null) { readLine = br.readLine(); builder.append(readLine); } logger.debug(METHOD_NAME + "#readLine: " + builder.toString()); p.waitFor(); int i = p.exitValue(); logger.info(METHOD_NAME + "#exitValue = " + i); if (i == 0) { return true; } else { return false; } } catch (IOException e) { logger.error(METHOD_NAME + "#ErrMsg=" + e.getMessage()); e.printStackTrace(); throw e; } finally { if (br != null) { br.close(); } } }

4.对于3方法有个缺点是执行错误时无法将错误消息打印出来，还有一个方法是先将执行的cmd命令写入到文件中后再执行，这是如果执行错误日志可以打印，线程也不会卡死。

a.将执行的命名写入到文件中。FileUtils.java

public static boolean writeFile(File exportFile, final String content) { if (exportFile == null || StringUtils.isEmpty(content)) { return false; } if (!exportFile.exists()) { try { exportFile.getParentFile().mkdirs(); exportFile.createNewFile(); } catch (IOException e) { e.printStackTrace(); logger.error("create local json file exception: " + e.getMessage()); return false; } } BufferedWriter bufferedWriter = null; try { FileOutputStream os = new FileOutputStream(exportFile); FileDescriptor fd = os.getFD(); bufferedWriter = new BufferedWriter(new OutputStreamWriter(os, "UTF-8")); bufferedWriter.write(content); //Flush the data from the streams and writes into system buffers //The data may or may not be written to disk. bufferedWriter.flush(); //block until the system buffers have been written to disk. //After this method returns, the data is guaranteed to have //been written to disk. fd.sync(); } catch (UnsupportedEncodingException e) { logger.error("saveDBData#catch an UnsupportedEncodingException (" + e.getMessage() + ")"); return false; } catch (FileNotFoundException e) { logger.error("saveDBData#catch an FileNotFoundException (" + e.getMessage() + ")"); return false; } catch (IOException e) { logger.error("saveDBData#catch an IOException (" + e.getMessage() + ")"); return false; } catch (Exception e) { logger.error("saveDBData#catch an exception (" + e.getMessage() + ")"); return false; } finally { try { if (bufferedWriter != null) { bufferedWriter.close(); bufferedWriter = null; } } catch (IOException e) { logger.error("writeJsonToFile#catch an exception (" + e.getMessage() + ")"); } } return true; }

b.执行命令

public static boolean excuteCMDBatFile(String cmd) { final String METHOD_NAME = "excuteCMDBatFile#"; boolean result = true; Process p; File batFile = new File("D:/test/cmd.bat"); System.out.println(batFile.getAbsolutePath()); boolean isSuccess = FileUtils.writeFile(batFile, cmd); if(!isSuccess) { logger.error(METHOD_NAME + "write cmd to File failed."); return false; } String batFilePath = """ + MigrateContants.CMD_BAT_FILE + """; logger.info("cmd path:" + batFilePath); try { p = Runtime.getRuntime().exec(batFilePath); InputStream fis = p.getErrorStream();//p.getInputStream(); InputStreamReader isr = new InputStreamReader(fis, System.getProperty("file.encoding")); BufferedReader br = new BufferedReader(isr); String line = null; StringBuilder builder = new StringBuilder(); while ((line = br.readLine()) != null) { builder.append(line); } p.waitFor(); int i = p.exitValue(); logger.info(METHOD_NAME + "exitValue = " + i); if (i != 0) { result = false; logger.error(METHOD_NAME + "excute cmd failed, [result = " + result + ", error message = " + builder.toString() + "]"); System.out.println(METHOD_NAME + "excute cmd failed, [result = " + result + ", error message = " + builder.toString() + "]"); }else { // logger.debug(METHOD_NAME + "excute cmd result = " + result); System.out.println(METHOD_NAME + "result = " + result); } } catch (Exception e) { result = false; e.printStackTrace(); logger.error(METHOD_NAME + "fail to excute bat File [ErrMsg=" + e.getMessage() + "]"); } return result; }

相关学习推荐：编程视频

　　以上就是java如何用cmd命令的知识。速戳>>知识兔学习精品课！

JAVA中应用AJAX的中文乱码的解决办法：1、ajax提交时采用escape或encodeURI方法，且必须使用2次；2、后台java用【java.net.URLDecoder】类的decode方法。

【相关学习推荐：java基础教程】

JAVA中应用AJAX的中文乱码的解决办法：

1、ajax提交时采用escape或encodeURI方法。必须使用2次

2、后台java用java.net.URLDecoder类的decode方法。

前台页面局部代码:

/** * marging是一个js对像用于承载页面部分功能和参数 * xmlHttp是改写后的AJAX对像，属性paramString为post方式发送到服务端的参数 * 前台，后台页面都采用的GBK编码,使用了编码过滤器 */xmlHttp.paramString="mName="+marging.mNames;//参数经过2次encodeURI编码xmlHttp.paramString=encodeURI(xmlHttp.paramString);xmlHttp.paramString=encodeURI(xmlHttp.paramString);//发送保存请求var xmlReq=xmlHttp.getTextByPost("mailMerginged.jsp");

后台页面代码:

/** * 当调用request.getParameter()函数时，会自动进行一次URI的解码过程 * 调用时内置的解码过程会导致乱码出现。而URI编码两次后，request.getParameter()函数 * 得到的是原信息URI编码一次的内容。再用可控的解码函数java.net.URLDecoder.decode() * 就可解出原始的正确的信息。 */String mName=java.net.URLDecoder.decode(request.getParameter("mName"),"UTF-8");

相关文章推荐：ajax视频教程

　　以上就是JAVA中应用AJAX的中文乱码怎么办的知识。速戳>>知识兔学习精品课！

实现java冒泡排序的方法：首先比较第1个和第2个数，将小数放前，大数放后；然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后；最后重复第一趟步骤，直至全部排序完成。

【相关学习推荐：java基础教程】

实现java冒泡排序的方法：

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

举例说明：要排序数组：int[] arr={6,3,8,2,9,1};

第一趟排序：

第一次排序：6和3比较，6大于3，交换位置： 3 6 8 2 9 1

第二次排序：6和8比较，6小于8，不交换位置：3 6 8 2 9 1

第三次排序：8和2比较，8大于2，交换位置： 3 6 2 8 9 1

第四次排序：8和9比较，8小于9，不交换位置：3 6 2 8 9 1

第五次排序：9和1比较：9大于1，交换位置： 3 6 2 8 1 9

第一趟总共进行了5次比较，排序结果： 3 6 2 8 1 9

---------------------------------------------------------------------

第二趟排序：

第一次排序：3和6比较，3小于6，不交换位置：3 6 2 8 1 9

第二次排序：6和2比较，6大于2，交换位置： 3 2 6 8 1 9

第三次排序：6和8比较，6大于8，不交换位置：3 2 6 8 1 9

第四次排序：8和1比较，8大于1，交换位置： 3 2 6 1 8 9

第二趟总共进行了4次比较，排序结果： 3 2 6 1 8 9

---------------------------------------------------------------------

第三趟排序：

第一次排序：3和2比较，3大于2，交换位置： 2 3 6 1 8 9

第二次排序：3和6比较，3小于6，不交换位置：2 3 6 1 8 9

第三次排序：6和1比较，6大于1，交换位置： 2 3 1 6 8 9

第二趟总共进行了3次比较，排序结果： 2 3 1 6 8 9

---------------------------------------------------------------------

第四趟排序：

第一次排序：2和3比较，2小于3，不交换位置：2 3 1 6 8 9

第二次排序：3和1比较，3大于1，交换位置： 2 1 3 6 8 9

第二趟总共进行了2次比较，排序结果： 2 1 3 6 8 9

---------------------------------------------------------------------

第五趟排序：

第一次排序：2和1比较，2大于1，交换位置： 1 2 3 6 8 9

第二趟总共进行了1次比较，排序结果： 1 2 3 6 8 9

---------------------------------------------------------------------

最终结果：1 2 3 6 8 9

---------------------------------------------------------------------

冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

相关学习推荐：java基础教程

　　以上就是java如何实现自定义注解的知识。速戳>>知识兔学习精品课！

【相关学习推荐：java基础教程】

说明：

图片服务器是用Nginx搭建的，用的是PHP语言

这个功能需要用到两个js文件：

jquery.js和jQuery.form.js

下面是上传成功截图：

下图是上传成功后访问图片：访问地址：http://u01.madailvxing.cn/images/2017_09/ecfa22a20bbf955a7f83.jpg2017_9:文件夹名

ecfa22a20bbf955a7f83：php同事那边随机生成的这张图片的文件名

相关文章推荐：ajax视频教程

　　以上就是掌握Java使用Ajax实现跨域上传图片功能的知识。速戳>>知识兔学习精品课！

【相关学习推荐：java基础教程】

需求

通过ajax异步刷新页面验证用户输入的账号密码是否在数据库中存在。

技术栈

JSP+Servlet+Oracle

具体代码

JSP部分：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><script> function createXMLHttpRequest() { try { xmlHttp = new XMLHttpRequest();//除了ie之外的其他浏览器使用ajax } catch (tryMS) { try { xmlHttp = new ActiveXObject("Msxml2.XMLHTTP");//ie浏览器适配 } catch (otherMS) { try { xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");//ie浏览器适配 } catch (failed) { xmlHttp = null; } } } return xmlHttp; } //提交请求 var xmlHttp; function checkUserExists() { var u = document.getElementById("uname"); var username = u.value; if (username == "") { alert("请输入用户名"); u.focus(); return false; } //访问字符串 var url = "loginServlet"; //创建核心xmlhttprequest组件 xmlHttp = createXMLHttpRequest(); //设置回调函数 xmlHttp.onreadystatechange = proessRequest; //初始化核心组件 xmlHttp.open("post", url, true); //设置请求头 xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded;"); //发送请求 xmlHttp.send("uname="+username); } //回调函数 function proessRequest() { if (xmlHttp.status==200 && xmlHttp.readyState == 4) { var b = xmlHttp.responseText;//得到服务端的输出结果 if (b=="true") { document.getElementById("alert").innerHTML = "<font color='red'>用户名已经存在！</font>"; }else { document.getElementById("alert").innerHTML = "<font color='blue'>用户名可以使用！</font>"; } } }</script><body> 请输入用户名： <input id="uname" name="uname" type="text" onblur="checkUserExists()" /><p id="alert" style="display:inline"></p></body></html>

这里没有用Dao层，直接用servlet和service层进行验证。

下面是service下JDBC查询的代码：

import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import com.stx.service.User;import com.stx.service.ConnectionManager;public class ajaxService { public boolean searchUser (String uname) { //jdbc查询用户名是否存在 boolean isFalse = false; Connection connection = null; Statement stmt = null; ResultSet rs = null; connection = ConnectionManager.getConnection(); try { stmt = connection.createStatement(); String sql = "select * from user_b where uname='"+uname+"'";//sql语句 rs = stmt.executeQuery(sql); isFalse=rs.next(); } catch (SQLException e) { e.printStackTrace(); } finally { ConnectionManager.closeResultSet(rs); ConnectionManager.closeStatement(stmt); ConnectionManager.closeConnection(connection); } return isFalse; }}

JDBC连接代码：

import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class ConnectionManager { private final static String DRIVER_CLASS = "oracle.jdbc.OracleDriver"; private final static String URL = "jdbc:oracle:thin:@localhost:1521:orcl"; private final static String DBNAME = "ibook"; private final static String PASSWORD = "qwer"; public static Connection getConnection() { Connection connection = null; try { Class.forName(DRIVER_CLASS); connection = DriverManager.getConnection(URL, DBNAME, PASSWORD); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } return connection; } public static void closeResultSet(ResultSet rs) { try { if (rs != null) rs.close(); } catch (SQLException e) { e.printStackTrace(); } } public static void closeConnection(Connection connection) { try { if (connection != null && !connection.isClosed()) connection.close(); } catch (SQLException e) { e.printStackTrace(); } } public static void closeStatement(Statement stmt) { try { if (stmt != null) stmt.close(); } catch (SQLException e) { e.printStackTrace(); } }}

关于user类：

public class User { private String uname; public User() { super(); } public User(String uname) { super(); this.uname = uname; } public String getUname() { return uname; } public void setUname(String uname) { this.uname = uname; }

关于控制层servlet：

import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import com.stx.service.ajaxService;/** * Servlet implementation class loginServlet */public class loginServlet extends HttpServlet { private static final long serialVersionUID = 1L; private ajaxService ajaxService = new ajaxService(); /** * @see HttpServlet#HttpServlet() */ public loginServlet() { super(); // TODO Auto-generated constructor stub } /** * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) */ protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("UTF-8"); String uname = request.getParameter("uname");//获取到输入的用户名 boolean isUname = ajaxService.searchUser(uname);//调用service中的查询方法 response.setCharacterEncoding("UTF-8");//设置字符编码 PrintWriter out = response.getWriter(); out.print(isUname); out.flush(); out.close();//关闭资源 } /** * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) */ protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // TODO Auto-generated method stub doGet(request, response); }}

相关文章推荐：ajax视频教程

　　以上就是实现AJAX+JAVA用户登陆注册验证的代码的知识。速戳>>知识兔学习精品课！

Java包装类型有8种，分别是：1、Byte；2、Integer；3、Short；4、Long；5、Float；6、Double；7、Boolean；8、Character。

【相关学习推荐：java基础教程】

Java包装类型有8种，分别是：

Java中的基本类型功能简单，不具备对象的特性，为了使基本类型具备对象的特性，所以出现了包装类，就可以像操作对象一样操作基本类型数据。

一、基本类型对应的包装类

基本类型包装类型

byte 　　　　　　　　 Byte

int Integer

short Short

long Long

float Float

double Double

boolean Boolean

char Character

A.创建一个包装类对象：

Integer i = new Integer(4);

//创建了一个Integer对象，表示指定的int值。

Integer s = new Integer("8");

//创建了一个Integer对象，表示String 参数"8"指定的int 值。

包装类常用的方法如下：

有了基本的数据类型，为什么还需要包装类型？

1、比如果业务中的一条数据，通过id去判断时候存在数据库的时候，包装类的好处就出来了，可以用Integer 来表示存储ID,判断它是否为空即可

2、转换成包装类之后可以当成对象处理，有的方法允许存入基本类型，只能存入对象~

3、

3.1 在Java中，一切皆对象，但八大基本类型却不是对象。

3.2声明方式的不同，基本类型无需通过new关键字来创建，而封装类型需new关键字。

3.3存储方式及位置的不同，基本类型是直接存储变量的值保存在堆栈中能高效的存取，封装类型需要通过引用指向实例，具体的实例保存在堆中。

3.4初始值的不同，封装类型的初始值为null，基本类型的的初始值视具体的类型而定，比如int类型的初始值为0，boolean类型为false；

3.5使用方式的不同：如与集合类合作使用时只能使用包装类型。

　　以上就是Java包装类型有几种的知识。速戳>>知识兔学习精品课！

【相关学习推荐：java基础教程】

0x01 创建要转换的类和主函数

注意这里一定要实现序列化

package day1; import java.io.Serializable; public class Test360 implements Serializable { @Override public String toString() { return "Test360{" + "name='" + name + ''' + '}'; } String name="test";}

0x02 对象和字节数组互转

package day1; import sun.jvm.hotspot.utilities.Assert; import java.io.*; public class arreytobytes { public static void main(String[] args) throws Exception { Test360 test =new Test360(); System.out.print ( "java class对象转字节数组

" ); byte[] bufobject = getBytesFromObject(test); for(int i=0 ; i<bufobject.length ; i++) { System.out.print(bufobject[i] + ","); } System.out.println ("

"); System.out.print ("字节数组还原对象

"); Object object1 = null; object1=deserialize(bufobject); Test360 t1 =(Test360)object1; System.out.println (t1.name); } public static byte[] getBytesFromObject(Serializable obj) throws Exception { if (obj == null) { return null; } ByteArrayOutputStream bo = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bo); oos.writeObject(obj); return bo.toByteArray(); } public static Object deserialize(byte[] bytes) { Object object = null; try { ByteArrayInputStream bis = new ByteArrayInputStream(bytes);// ObjectInputStream ois = new ObjectInputStream(bis); object = ois.readObject(); ois.close(); bis.close(); } catch (IOException ex) { ex.printStackTrace(); } catch (ClassNotFoundException ex) { ex.printStackTrace(); } return object; }}

运行结果

java class对象转字节数组

-84,-19,0,5,115,114,0,12,100,97,121,49,46,84,101,115,116,51,54,48,76,-69,81,12,-51,122,126,-123,2,0,0,120,112,

字节数组还原对象

补充知识：java对象与byte[]数组之间的相互转化，压缩解压缩操作

下面介绍一下java对象之间和byte[]数组之间的相互转化。并对byte[]数据进行压缩操作。java对象转化为byte[]数组可用于redis中实现缓存。（这里暂不做介绍）.话不多说直接开实例：

首先我们创建一个java对象：Person.java

public class Person implements Serializable{ private String userName; private String password; private String phone; private String email; private String sex; private String age; public Person(){} public Person(String userName, String password, String phone, String email, String sex, String age) { super(); this.userName = userName; this.password = password; this.phone = phone; this.email = email; this.sex = sex; this.age = age; } @Override public String toString() { return "Person [userName=" + userName + ", password=" + password + ", phone=" + phone + ", email=" + email + ", sex=" + sex + ", age=" + age + "]"; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public String getAge() { return age; } public void setAge(String age) { this.age = age; }}

下面演示对person对象的转换：Object2ByteArray.java

public class Object2ByteArray { public static void main(String[] args) { try { Person person=new Person("userName", "password", "phone", "email", "sex", "age"); System.out.println("person:"+person); ByteArrayOutputStream bos=new ByteArrayOutputStream(); ObjectOutputStream oos=new ObjectOutputStream(bos); oos.writeObject(person); //得到person对象的byte数组 byte[] personByteArray = bos.toByteArray(); System.out.println("before compress:"+personByteArray.length); //将byte数据压缩 byte[] zipPersonByteArray = compress(personByteArray); System.out.println("after compress:"+zipPersonByteArray.length); closeStream(oos); closeStream(bos); //从byte数组中还原person对象 ByteArrayInputStream bin=new ByteArrayInputStream(personByteArray); ObjectInputStream ois=new ObjectInputStream(bin); Person restorePerson = (Person) ois.readObject(); System.out.println(restorePerson); closeStream(ois); closeStream(bin); //从压缩的byte数组中还原person对象 byte[] unCompressByte = unCompress(zipPersonByteArray); ByteArrayInputStream zipBin=new ByteArrayInputStream(unCompressByte); ObjectInputStream zipOis=new ObjectInputStream(zipBin); Person zipBytePerson=(Person) zipOis.readObject(); System.out.println("compress person:"+zipBytePerson.toString()); closeStream(zipOis); closeStream(zipBin); } catch (Exception e) { e.printStackTrace(); } } /** * * @description 关闭数据流 * @param oStream * */ public static void closeStream(Closeable oStream){ if(null!=oStream){ try { oStream.close(); } catch (IOException e) { oStream=null;//赋值为null,等待垃圾回收 e.printStackTrace(); } } } /** * * @description 将byte 数组压缩 * @param bt * @return */ public static byte[] compress(byte[] bt){ //将byte数据读入文件流 ByteArrayOutputStream bos=null; GZIPOutputStream gzipos=null; try { bos=new ByteArrayOutputStream(); gzipos=new GZIPOutputStream(bos); gzipos.write(bt); } catch (Exception e) { e.printStackTrace(); }finally{ closeStream(gzipos); closeStream(bos); } return bos.toByteArray(); } /** * * @description 解压缩byte数组 * @param bt * @return */ public static byte[] unCompress(byte[] bt){ //byte[] unCompress=null; ByteArrayOutputStream byteAos=null; ByteArrayInputStream byteArrayIn=null; GZIPInputStream gzipIn=null; try { byteArrayIn=new ByteArrayInputStream(bt); gzipIn=new GZIPInputStream(byteArrayIn); byteAos=new ByteArrayOutputStream(); byte[] b=new byte[4096]; int temp = -1; while((temp=gzipIn.read(b))>0){ byteAos.write(b, 0, temp); } } catch (Exception e) { e.printStackTrace(); return null; }finally{ closeStream(byteAos); closeStream(gzipIn); closeStream(byteArrayIn); } return byteAos.toByteArray(); }}

上面的示例显示了：java对象到byte[]数据的转化；

byte[]数据的压缩和解压缩操作；

byte[]数据还原java对象的操作；

运行结果：

person:Person [userName=userName, password=password, phone=phone, email=email, sex=sex, age=age]before compress:189after compress:156Person [userName=userName, password=password, phone=phone, email=email, sex=sex, age=age]compress person:Person [userName=userName, password=password, phone=phone, email=email, sex=sex, age=age]

　　以上就是JAVA对象和字节数组互转过程的知识。速戳>>知识兔学习精品课！

【相关学习推荐：java基础教程】

1、什么是JSONP

一般来说位于 server1.example.com 的网页无法与不是 server1.example.com的服务器沟通，而 HTML 的<script> 元素是一个例外。利用 <script> 元素的这个开放策略，网页可以得到从其他来源动态产生的 JSON 资料，而这种使用模式就是所谓的 JSONP。用 JSONP 抓到的资料并不是 JSON，而是任意的JavaScript，用 JavaScript 直译器执行而不是用 JSON 解析器解析。

JSONP是一种协议，为了解决客户端请求服务器跨域的问题，但是并非是正式的传输协议。该协议的一个要点就是允许用户传递一个callback参数给服务端，然后服务端返回数据时会将这个callback参数作为函数名来包裹住JSON数据，这样客户端就可以随意定制自己的函数来自动处理返回数据了.

2、Ajax 请求其他域接口

我这个项目要请求另外一个第一个后台接口请求数据，在页面渲染的时候，通过ajax加载数据如下：

$.ajax({ url: 'http://www.xxx.cn/lalala?method=&page=1&pageSize=10', type: 'GET', dataType: 'json', timeout: 5000, contentType: 'application/json; charset=utf-8', success: function (result) { alter("aaaa"); } });

这样就出现跨域的错误，如下所示：

No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'null' is therefore not allowed access. The response had HTTP status code 500.

这里就说明不允许跨域请求，那么怎么办？换成jsonp好了。就改了dataType这个字段。

$.ajax({ url: 'http://www.xxx.cn/lalala?method=&page=1&pageSize=10', type: 'GET', dataType: 'jsonp', timeout: 5000, contentType: 'application/json; charset=utf-8', success: function (result) { alter("aaaa"); } });

结果： Uncaught SyntaxError: Unexpected token!

what the fuck！

明明请求回来数据，结果还是报错。原因是ajax请求服务器，而返回的数据格式不符合jsonp的返回格式，那么jsonp格式是什么样的？

Callback({msg:'this is json data'})

这是什么叼东西，奇葩谁定义的！如果你这么想，看来你没有仔细看第1点，JSON是一种轻量级的数据交换格式，像xml一样。JSONP是一种使用JSON数据的方式，返回的不是JSON对象，是包含JSON对象的javaScript脚本。但是上图是一段json串，所以报错啦。

3、参数返回处理

有一点你会发现在你是用jsonp协议请求时，在参数中除了自己填写的参数外还有名为callback的参数，如图：

看看这个参数是什么东西，因为我在ajax请求的时候没有指定，jsonp这个参数，那么系统默认参数名为“callback”。没有指定jsonpCallback参数, 那么jquery会生成随机的函数名，如上图所示。

比如我如下配置：

$.ajax({ url: 'http://www.xxx.cn/lalala?method=&page=1&pageSize=10', type: 'GET', dataType: 'jsonp', jsonp:'callbacka',//传递给请求处理程序或页面的，用以获得jsonp回调函数名的参数名(默认为:callback) jsonpCallback:"success_jsonpCallback",//自定义的jsonp回调函数名称，默认为jQuery自动生成的随机函数名 timeout: 5000, contentType: 'application/json; charset=utf-8', success: function (result) { alter("aaaa"); } });

那么服务器亦可以通过下面方法获取回调的函数名：

代码如下:

string callbackFunName =request.getParameter（"callbacka"）;//获取的就是success_jsonpCallback 字符串

注意：系统会区分函数名大小写。

那么下面按照格式包装一下看看咯：

String callback = request.getParameter("callback"); //不指定函数名默认 callbackreturn callback+ "(" + jsonStr + ")"

包了一下，结果真的不报错，看下返回数据如下图：

4、JSONP的执行过程

首先在客户端注册一个callback (如:'jsoncallback'), 然后把callback的名字(如:jsonp01)传给服务器。注意：服务端得到callback的数值后，要用jsonp01(......)把将要输出的json内容包括起来，此时，服务器生成 json 数据才能被客户端正确接收。

然后,以 javascript 语法的方式，生成一个function， function 名字就是传递上来的参数 'jsoncallback'的值 jsonp01 .

最后,将 json 数据直接以入参的方式，放置到 function 中，这样就生成了一段 js 语法的文档，返回给客户端。客户端浏览器，解析script标签，并执行返回的 javascript 文档，此时javascript文档数据，作为参数，传入到了客户端预先定义好的 callback 函数(如上例中jquery $.ajax()方法封装的的success: function (json))里。

相关文章推荐：ajax视频教程

　　以上就是一起看看Java Ajax jsonp跨域请求的知识。速戳>>知识兔学习精品课！

【相关视频推荐：ajax视频教程】

环境：eclipse+struts

要实现的效果：点击按钮提交数据到后台之后回到前台显示出来数据

index.jsp

struts.xml

<action name="TestAction" class="com.action.Test"> <result>index.jsp</result> </action>

Test.java

package com.action; import java.io.PrintWriter; import java.util.Map; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts2.ServletActionContext; import com.opensymphony.xwork2.ActionContext; import com.opensymphony.xwork2.ActionSupport; public class Test extends ActionSupport { @Override public String execute() throws Exception { // TODO Auto-generated method stub HttpServletRequest request = org.apache.struts2.ServletActionContext.getRequest(); HttpServletResponse response = ServletActionContext.getResponse(); request.setCharacterEncoding("utf-8"); response.setCharacterEncoding("utf-8"); PrintWriter out = response.getWriter(); out.write(request.getParameter("username")); out.flush(); out.close(); return SUCCESS; } }

相关学习推荐：java基础教程

　　以上就是ajax提交到java后台实现处理数据的知识。速戳>>知识兔学习精品课！

java web是一个技术的总和，把Web看成一个容器而已，主要使用JavaEE技术来实现，在加上各种中间件，可以通过JavaWeb制作一个软件，一个ERP，一个网页，甚至是一个网络游戏都可以。

Java Web其实就是一个技术的总和,把Web看成一个容器而已，主要使用技术来实现.在加上各种中间件(SSH等4102)

JavaWeb其实做什么都可以,你可以通过JavaWeb制作一个软件,一个ERP,一个网页,甚至是一个网络游戏都可以丫。

没有特定的范畴.在加上Java的可移植性,现在普遍用于各种ERP,大型交互式网站的开发. 说白了跟JavaSE中的 GUI 原理上是一样的,只不过JavaSE GUI是以桌面的形式展现的,就好像普通版QQJavaWeb是以网页的形式展现的.就好像网页版QQ

相关学习推荐：java基础教程

　　以上就是java web是干什么的的知识。速戳>>知识兔学习精品课！

【相关学习推荐：java基础教程】

反射到底是好是坏

知识兔

说到Java 中的反射，初学者在刚刚接触到反射的各种高级特性时，往往表示十分兴奋，甚至会在一些不需要使用反射的场景中强行使用反射来「炫技」。而经验较为丰富的长者，看到反射时往往会发出灵魂三问：为什么要用反射？反射不会降低性能么？不用还有什么办法可以解决这个问题？

那么今天我们就来深入探讨下，反射到底对性能有多大影响？顺便探讨下，反射为什么对性能有影响？

编码试验

知识兔

在我们分析具体原理之前，我们可以通过编写代码做实验得出结论。

反射可能会涉及多种类型的操作，比如生成实例，获取/设置变量属性，调用方法等。经过简单的思考，我们认为生成实例对性能的影响相对其他操作要大一些，所以我们采用生成实例来做试验。

在如下代码中，我们定义了一个类，我们测试分别使用和来生成个实例，并打印出耗时时间。

public class MainActivity extends AppCompatActivity { private static final String TAG = "MainAc"; private final int MAX_TIMES = 100 * 1000; private InnerClass innerList[]; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); innerList = new InnerClass[MAX_TIMES]; long startTime = SystemClock.elapsedRealtime(); for (int i=0; i < MAX_TIMES; i++) { innerList[i] = new InnerClass(); } Log.e(TAG, "totalTime: " + (SystemClock.elapsedRealtime() - startTime)); long startTime2 = SystemClock.elapsedRealtime(); for (int i=0; i < MAX_TIMES; i++) { innerList[i] = newInstanceByReflection(); } Log.e(TAG, "totalTime2: " + (SystemClock.elapsedRealtime() - startTime2)); } public InnerClass newInstanceByReflection() { Class clazz = InnerClass.class; try { return (InnerClass) clazz.getDeclaredConstructor().newInstance(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } return null; } static class InnerClass { }}复制代码

输出日志：

2020-03-19 22:34:49.738 2151-2151/? E/MainAc: totalTime: -03-19 22:34:50.409 2151-2151/? E/MainAc: totalTime2: 670复制代码

使用反射生成 10万个实例，耗时 670ms，明显高于直接使用关键字的 15ms，所以反射性能低。别急，这个结论总结的还有点早，我们将要生成的实例总数改为 1000个试试，输出日志：

2020-03-19 22:39:21.287 3641-3641/com.example.myapplication E/MainAc: totalTime: -03-19 22:39:21.296 3641-3641/com.example.myapplication E/MainAc: totalTime2: 9复制代码

使用反射生成 1000 个实例，虽然需要9ms，高于的 2ms，但是 9ms 和 2ms 的差距本身肉眼不可见，而且通常我们在业务中写的反射一般来说执行频率也未必会超过 1000 次，这种场景下，我们还能理直气壮地说反射性能很低么？

很显然，不能。

除了代码执行耗时，我们再看看反射对内存的影响。我们仍然以生成 10万个实例为目标，对上述代码做略微改动，依次只保留方式和反射方式，然后运行程序，观察内存占用情况。

使用方式

使用反射

对比两图，我们可以看到第二张图中多了很多和对象实例，这两部分占用的内存2.7M。因此，我们可以得出结论，反射会产生大量的临时对象，并且会占用额外内存空间。

刨根问底：反射原理是什么

知识兔

我们以前面试验中反射生成实例的代码为入口。

首先回顾下虚拟机中类的生命周期：加载，连接（验证，准备，解析），初始化，使用，卸载。在加载的过程中，虚拟机会把类的字节码转换成运行时数据结构，并保存在方法区，在内存中会生成一个代表这个类数据结构的 java.lang.Class 对象，后续访问这个类的数据结构就可以通过这个 Class 对象来访问。

public InnerClass newInstanceByReflection() { // 获取虚拟机中 InnerClass 类的 Class 对象 Class clazz = InnerClass.class; try { return (InnerClass) clazz.getDeclaredConstructor().newInstance(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } return null;}复制代码

代码中用于获取类中定义的构造方法，由于我们没有显式定义构造方法，所以会返回编译器为我们自己生成的默认无参构造方法。

下面我们看下是如何返回构造方法的。以下均以 jdk 1.8代码为源码。

@CallerSensitivepublic Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException { // 权限检查 checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true); return getConstructor0(parameterTypes, Member.DECLARED);}复制代码

方法首先做了权限检查，然后直接调用方法。

private Constructor<T> getConstructor0(Class<?>[] parameterTypes, int which) throws NoSuchMethodException{ // privateGetDeclaredConstructors 方法是获取所有的构造方法数组 Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC)); // 遍历所有的构造方法数组，根据传入的参数类型依次匹配，找到合适的构造方法后就会拷贝一份作为返回值 for (Constructor<T> constructor : constructors) { if (arrayContentsEq(parameterTypes, constructor.getParameterTypes())) { // 拷贝构造方法 return getReflectionFactory().copyConstructor(constructor); } } // 没有找到的话，就抛出异常 throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));}复制代码

方法主要做了两件事：获取所有构造方法组成的数组遍历构造方法数组，找到匹配的

遍历匹配没啥好说的，我们重点看下第一件事，怎么获取的所有构造方法数组，也就是这个方法。

private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) { checkInitted(); Constructor<T>[] res; // 获取缓存的 ReflectionData 数据 ReflectionData<T> rd = reflectionData(); // 如果缓存中有 ReflectionData，就先看看 ReflectionData 中的 publicConstructors 或 declaredConstructors是否为空 if (rd != null) { res = publicOnly ? rd.publicConstructors : rd.declaredConstructors; if (res != null) return res; } // 如果没有缓存，或者缓存中构造方法数组为空 // No cached value available; request value from VM // 对接口类型的字节码特殊处理 if (isInterface()) { @SuppressWarnings("unchecked") // 如果是接口类型，那么生成一个长度为0的构造方法数组 Constructor<T>[] temporaryRes = (Constructor<T>[]) new Constructor<?>[0]; res = temporaryRes; } else { // 如果不是接口类型，就调用 getDeclaredConstructors0 获取构造方法数组 res = getDeclaredConstructors0(publicOnly); } // 获取到构造方法数组后，再赋值给缓存 ReflectionData 中的对应属性 if (rd != null) { if (publicOnly) { rd.publicConstructors = res; } else { rd.declaredConstructors = res; } } return res;}复制代码

上述代码中我已经对关键代码进行了注释，在讲解整个流程之前，我们看到了一个陌生的类型。它对应的数据结构是：

private static class ReflectionData<T> { volatile Field[] declaredFields; volatile Field[] publicFields; volatile Method[] declaredMethods; volatile Method[] publicMethods; volatile Constructor<T>[] declaredConstructors; volatile Constructor<T>[] publicConstructors; // Intermediate results for getFields and getMethods volatile Field[] declaredPublicFields; volatile Method[] declaredPublicMethods; volatile Class<?>[] interfaces; // Value of classRedefinedCount when we created this ReflectionData instance final int redefinedCount; ReflectionData(int redefinedCount) { this.redefinedCount = redefinedCount; }}复制代码

这个类就是用来保存从虚拟机中获取到的一些数据。同时我们可以看到所有反射属性都使用了关键字修饰。

获取缓存的数据是通过调用方法获取的。

// 定义在 Class 类中的反射缓存对象private volatile transient SoftReference<ReflectionData<T>> reflectionData;private ReflectionData<T> reflectionData() { SoftReference<ReflectionData<T>> reflectionData = this.reflectionData; int classRedefinedCount = this.classRedefinedCount; ReflectionData<T> rd; if (useCaches && reflectionData != null && (rd = reflectionData.get()) != null && rd.redefinedCount == classRedefinedCount) { return rd; } // else no SoftReference or cleared SoftReference or stale ReflectionData // -> create and replace new instance return newReflectionData(reflectionData, classRedefinedCount);}复制代码

我们可以看到实际上是一个软引用，软引用会在内存不足的情况下被虚拟机回收，所以方法在开始的地方，先判断了是否可以使用缓存以及缓存是否失效，如果失效了，就会调用方法生成一个新的实例。

接下来看看方法。

private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData, int classRedefinedCount) { // 如果不允许使用缓存，直接返回 null if (!useCaches) return null; while (true) { ReflectionData<T> rd = new ReflectionData<>(classRedefinedCount); // try to CAS it... if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) { return rd; } // else retry oldReflectionData = this.reflectionData; classRedefinedCount = this.classRedefinedCount; if (oldReflectionData != null && (rd = oldReflectionData.get()) != null && rd.redefinedCount == classRedefinedCount) { return rd; } }}复制代码

中使用 volatile + 死循环 + CAS 机制保证线程安全。注意到这里的死循环每执行一次都会构造一个新的实例。

你可能会有疑问，中属性什么时候被赋值的，其实是封装在这个方法里了，他会检测当前对象中的是否与相等，如果相等，就会把赋值给。

到现在为止，关于的背景知识都介绍完了。我们再回到中看看获取构造方法的流程。

流程图

可以看到对于普通类，最终通过调用方法获取的构造方法列表。

private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);复制代码

这个方法是 native 的，具体逻辑在 jdk 源码中。

在文件中，

void getDeclaredConstructors0(Frame * frame){ // Frame 可以理解为调用native方法时，java层传递过来的数据的一种封装LocalVars * vars = frame->localVars;Object * classObj = getLocalVarsThis(vars); // 取得java方法的入参bool publicOnly = getLocalVarsBoolean(vars, 1);uint16_t constructorsCount = 0; // 获取要查询的类的 Class 对象Class * c = classObj->extra; // 获取这个类的所有构造方法，且数量保存在 constructorsCount 中Method* * constructors = getClassConstructors(c, publicOnly, &constructorsCount);// 获取 java 方法调用所属的 classLoaderClassLoader * classLoader = frame->method->classMember.attachClass->classLoader;// 拿到 Constructor 对应的 class 对象Class * constructorClass = loadClass(classLoader, "java/lang/reflect/Constructor"); //创建一个长度为 constructorsCount 的数组保存构造方法Object * constructorArr = newArray(arrayClass(constructorClass), constructorsCount);pushOperandRef(frame->operandStack, constructorArr);// 后面是具体的赋值逻辑。将native中的Method对象转化为java层的Constructor对象if (constructorsCount > 0){Thread * thread = frame->thread;Object* * constructorObjs = getObjectRefs(constructorArr);Method * constructorInitMethod = getClassConstructor(constructorClass, _constructorConstructorDescriptor);for (uint16_t i = 0; i < constructorsCount; i++){Method * constructor = constructors[i];Object * constructorObj = newObject(constructorClass);constructorObj->extra = constructor;constructorObjs[i] = constructorObj;OperandStack * ops = newOperandStack(9);pushOperandRef(ops, constructorObj);pushOperandRef(ops, classObj);pushOperandRef(ops, toClassArr(classLoader, methodParameterTypes(constructor), constructor->parsedDescriptor->parameterTypesCount));if (constructor->exceptions != NULL)pushOperandRef(ops, toClassArr(classLoader, methodExceptionTypes(constructor), constructor->exceptions->number_of_exceptions));elsepushOperandRef(ops, toClassArr(classLoader, methodExceptionTypes(constructor), 0));pushOperandInt(ops, constructor->classMember.accessFlags);pushOperandInt(ops, 0);pushOperandRef(ops, getSignatureStr(classLoader, constructor->classMember.signature)); // signaturepushOperandRef(ops, toByteArr(classLoader, constructor->classMember.annotationData, constructor->classMember.annotationDataLen));pushOperandRef(ops, toByteArr(classLoader, constructor->parameterAnnotationData, constructor->parameterAnnotationDataLen));Frame * shimFrame = newShimFrame(thread, ops);pushThreadFrame(thread, shimFrame);// init constructorObjInvokeMethod(shimFrame, constructorInitMethod);}}}复制代码

从上面的逻辑，可以知道获取构造方法的核心方法是，所在文件为。

Method* * getClassConstructors(Class * self, bool publicOnly, uint16_t * constructorsCount){ // 分配大小为 sizeof(Method) 的长度为 methodsCount 的连续内存地址，即数组Method* * constructors = calloc(self->methodsCount, sizeof(Method));*constructorsCount = 0; // 在native 层，构造方法和普通方法都存在 methods 中，逐一遍历for (uint16_t i = 0; i < self->methodsCount; i++){Method * method = self->methods + i; // 判断是否是构造方法if (isMethodConstructor(method)){ // 检查权限if (!publicOnly || isMethodPublic(method)){ // 符合条件的构造方法依次存到数组中constructors[*constructorsCount] = method;(*constructorsCount)++;}}}return constructors;}复制代码

可以看到实际上就是对进行了一次过滤，过滤的条件为：1.是构造方法；2.权限一致。

方法的判断逻辑也是十分简单，不是静态方法，而且方法名是即可。

bool isMethodConstructor(Method * self){return !isMethodStatic(self) && strcmp(self->classMember.name, "<init>") == 0;}复制代码

所以核心的逻辑变成了中的数组何时被初始化赋值的？我们刨根问底的追踪下。

我们先找到类加载到虚拟机中的入口方法：

Class * loadNonArrayClass(ClassLoader * classLoader, const char * className){int32_t classSize = 0;char * classContent = NULL;Class * loadClass = NULL;classSize = readClass(className, &classContent);if (classSize > 0 && classContent != NULL){#if 0printf("class size:%d,class data:[", classSize);for (int32_t i = 0; i < classSize; i++){printf("0x%02x ", classContent[i]);}printf("]

");#endif}if (classSize <= 0){printf("Could not found target class

");exit(127);}// 解析字节码文件loadClass = parseClassFile(classContent, classSize);loadClass->classLoader = classLoader;// 加载defineClass(classLoader, loadClass);// 链接linkClass(classLoader, loadClass);//printf("[Loaded %s

", loadClass->name);return loadClass;}复制代码

在方法中，调用了方法。

Class * parseClassFile(char * classContent, int32_t classSize){ClassFile * classFile = NULL;classFile = parseClassData(classContent, classSize);return newClass(classFile);}复制代码

方法在文件中。

Class * newClass(ClassFile * classFile){Class * c = calloc(1, sizeof(Class));c->accessFlags = classFile->accessFlags;c->sourceFile = getClassSourceFileName(classFile);newClassName(c, classFile);newSuperClassName(c, classFile);newInterfacesName(c, classFile);newConstantPool(c, classFile);newFields(c, classFile);newMethods(c, classFile);return c;}复制代码

可以看到，在native层创建了一个对象，我们重点看方法啊，这个方法定义在中。

Method * newMethods(struct Class * c, ClassFile * classFile){c->methodsCount = classFile->methodsCount;c->methods = NULL;if (c->methodsCount == 0)return NULL;c->methods = calloc(classFile->methodsCount, sizeof(Method));for (uint16_t i = 0; i < c->methodsCount; i++){c->methods[i].classMember.attachClass = c;copyMethodInfo(&c->methods[i], &classFile->methods[i], classFile);copyAttributes(&c->methods[i], &classFile->methods[i], classFile);MethodDescriptor * md = parseMethodDescriptor(c->methods[i].classMember.descriptor);c->methods[i].parsedDescriptor = md;calcArgSlotCount(&c->methods[i]);if (isMethodNative(&c->methods[i])){injectCodeAttribute(&c->methods[i], md->returnType);}} return NULL;}复制代码

上述代码可以看出，实际上就是把中解析到的方法逐一赋值给了对象的数组。

总算梳理清楚了，反射创建对象的调用链为：

loadClass -> loadNonArrayClass -> parseClassFile -> newMethods -> Class 的 methods数组privateGetDeclaredConstructors -> getDeclaredConstructors0 -> getClassConstructors (过滤Class 的 methods数组)复制代码

到目前为止，我们搞明白反射时如何找到对应的构造方法的。下面我们来看方法。

(InnerClass) clazz.getDeclaredConstructor().newInstance();复制代码

public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { // 构造方法是否被重载了 if (!override) { if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { Class<?> caller = Reflection.getCallerClass(); // 检查权限 checkAccess(caller, clazz, null, modifiers); } } // 枚举类型报错 if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects"); // ConstructorAccessor 是缓存的，如果为空，就去创建一个 ConstructorAccessor ca = constructorAccessor; // read volatile if (ca == null) { // 创建 ConstructorAccessor ca = acquireConstructorAccessor(); } @SuppressWarnings("unchecked") // 使用 ConstructorAccessor 的 newInstance 构造实例 T inst = (T) ca.newInstance(initargs); return inst; }复制代码

接着看下方法。

private ConstructorAccessor acquireConstructorAccessor() { // First check to see if one has been created yet, and take it // if so. ConstructorAccessor tmp = null; // 可以理解为缓存的对象 if (root != null) tmp = root.getConstructorAccessor(); if (tmp != null) { constructorAccessor = tmp; } else { // Otherwise fabricate one and propagate it up to the root // 生成一个 ConstructorAccessor，并缓存起来 tmp = reflectionFactory.newConstructorAccessor(this); setConstructorAccessor(tmp); } return tmp;}复制代码

继续走到方法。

public ConstructorAccessor newConstructorAccessor(Constructor<?> var1) { checkInitted(); Class var2 = var1.getDeclaringClass(); // 如果是抽象类，报错 if (Modifier.isAbstract(var2.getModifiers())) { return new InstantiationExceptionConstructorAccessorImpl((String)null); } // 如果 Class 类报错 else if (var2 == Class.class) { return new InstantiationExceptionConstructorAccessorImpl("Can not instantiate java.lang.Class"); } // 如果是 ConstructorAccessorImpl 的子类的话，返回 BootstrapConstructorAccessorImpl else if (Reflection.isSubclassOf(var2, ConstructorAccessorImpl.class)) { return new BootstrapConstructorAccessorImpl(var1); } // 判断 noInflation , 后面是判断不是匿名类 else if (noInflation && !ReflectUtil.isVMAnonymousClass(var1.getDeclaringClass())) { return (new MethodAccessorGenerator()).generateConstructor(var1.getDeclaringClass(), var1.getParameterTypes(), var1.getExceptionTypes(), var1.getModifiers()); } // 使用 NativeConstructorAccessorImpl 来生成实例 else { NativeConstructorAccessorImpl var3 = new NativeConstructorAccessorImpl(var1); DelegatingConstructorAccessorImpl var4 = new DelegatingConstructorAccessorImpl(var3); var3.setParent(var4); return var4; }}复制代码

具体逻辑，在上述代码中已经注释了。这里提一下。

在执行所有方法前会检查下是否执行过了方法，这个方法会把的值和从虚拟机的环境变量中读取出来并赋值。

当为而且不是匿名类时，就会使用方式。否则就是用的方式来生成。

默认为，所以我们先看native调用的方式。关注类。

class NativeConstructorAccessorImpl extends ConstructorAccessorImpl { private final Constructor<?> c; private DelegatingConstructorAccessorImpl parent; private int numInvocations; NativeConstructorAccessorImpl(Constructor<?> var1) { this.c = var1; } public Object newInstance(Object[] var1) throws InstantiationException, IllegalArgumentException, InvocationTargetException { if (++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.c.getDeclaringClass())) { ConstructorAccessorImpl var2 = (ConstructorAccessorImpl)(new MethodAccessorGenerator()).generateConstructor(this.c.getDeclaringClass(), this.c.getParameterTypes(), this.c.getExceptionTypes(), this.c.getModifiers()); this.parent.setDelegate(var2); } return newInstance0(this.c, var1); } void setParent(DelegatingConstructorAccessorImpl var1) { this.parent = var1; } private static native Object newInstance0(Constructor<?> var0, Object[] var1) throws InstantiationException, IllegalArgumentException, InvocationTargetException;}复制代码

我们可以看到中维护了一个计数器,在每次调用方法生成实例时，就会对计数器自增，当计数器超过的阈值，默认为15，就会使用替换 ,后面就会直接调用中的方法了。

我们先看看没到达阈值前，会调用native方法 ,这个方法定义在中，具体的流程我就不分析了，大致逻辑是操作堆栈执行方法。

然后我们再看看超过阈值后，执行的是生成构造器的方式。这种方式与方法中为的处理方式一样。所以可以解释为：java虚拟机在执行反射操作时，如果同一操作执行次数超过阈值，会从native生成实例的方式转变为java生成实例的方式。

的方法如下。

public ConstructorAccessor generateConstructor(Class<?> var1, Class<?>[] var2, Class<?>[] var3, int var4) { return (ConstructorAccessor)this.generate(var1, "<init>", var2, Void.TYPE, var3, var4, true, false, (Class)null);}复制代码

继续跟踪下去可以发现，反射调用构造方法实际上是动态编写字节码，并且在虚拟机中把编好的字节码加载成一个Class，这个Class实际上是类型的，然后调用这个动态类的方法。回看刚刚我们梳理的代码，可以看到第三个逻辑：

// 如果是 ConstructorAccessorImpl 的子类的话，返回 BootstrapConstructorAccessorImpl else if (Reflection.isSubclassOf(var2, ConstructorAccessorImpl.class)) { return new BootstrapConstructorAccessorImpl(var1);} 复制代码

最终执行的是的方法。

class BootstrapConstructorAccessorImpl extends ConstructorAccessorImpl { private final Constructor<?> constructor; BootstrapConstructorAccessorImpl(Constructor<?> var1) { this.constructor = var1; } public Object newInstance(Object[] var1) throws IllegalArgumentException, InvocationTargetException { try { return UnsafeFieldAccessorImpl.unsafe.allocateInstance(this.constructor.getDeclaringClass()); } catch (InstantiationException var3) { throw new InvocationTargetException(var3); } }}复制代码

最后是通过使用类分配了一个实例。

反射带来的问题

知识兔

到现在为止，我们已经把反射生成实例的所有流程都搞清楚了。回到文章开头的问题，我们现在反思下，反射性能低么？为什么？反射调用过程中会产生大量的临时对象，这些对象会占用内存，可能会导致频繁 gc，从而影响性能。反射调用方法时会从方法数组中遍历查找，并且会检查可见性等操作会耗时。反射在达到一定次数时，会动态编写字节码并加载到内存中，这个字节码没有经过编译器优化，也不能享受JIT优化。反射一般会涉及自动装箱/拆箱和类型转换，都会带来一定的资源开销。

在Android中，我们可以在某些情况下对反射进行优化。举个例子，EventBus 2.x 会在 register 方法运行时，遍历所有方法找到回调方法；而EventBus 3.x 则在编译期间，将所有回调方法的信息保存的自己定义的中，这样可以减少对运行时的性能影响。

想了解更多相关学习，敬请关注php培训栏目！

　　以上就是谈谈Java 反射的快慢的知识。速戳>>知识兔学习精品课！

雪花算法生成id的方法：首先新建一个id生成的类；然后新建一个调用生成id的单例工具；最后使用函数【GuuidUtil.getUUID()】直接调用即可。

【相关学习推荐：java基础】

雪花算法生成id的方法：

1、新建一个id生成的类 SnowFlake

/** * @Auther: lyl * @Date: 2019/11/21 17:49 * @Description: */public class SnowFlake { /** * 起始的时间戳 */ private final static long START_STMP = 31L; /** * 每一部分占用的位数 */ private final static long SEQUENCE_BIT = 12; //序列号占用的位数 private final static long MACHINE_BIT = 5; //机器标识占用的位数 private final static long DATACENTER_BIT = 5;//数据中心占用的位数 /** * 每一部分的最大值 */ private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT); private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT); private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT); /** * 每一部分向左的位移 */ private final static long MACHINE_LEFT = SEQUENCE_BIT; private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT; private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT; private long datacenterId; //数据中心 private long machineId; //机器标识 private long sequence = 0L; //序列号 private long lastStmp = -1L;//上一次时间戳 public SnowFlake(long datacenterId, long machineId) { if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) { throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0"); } if (machineId > MAX_MACHINE_NUM || machineId < 0) { throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0"); } this.datacenterId = datacenterId; this.machineId = machineId; } /** * 产生下一个ID * * @return */ public synchronized long nextId() { long currStmp = getNewstmp(); if (currStmp < lastStmp) { throw new RuntimeException("Clock moved backwards. Refusing to generate id"); } if (currStmp == lastStmp) { //相同毫秒内，序列号自增 sequence = (sequence + 1) & MAX_SEQUENCE; //同一毫秒的序列数已经达到最大 if (sequence == 0L) { currStmp = getNextMill(); } } else { //不同毫秒内，序列号置为0 sequence = 0L; } lastStmp = currStmp; return (currStmp - START_STMP) << TIMESTMP_LEFT //时间戳部分 | datacenterId << DATACENTER_LEFT //数据中心部分 | machineId << MACHINE_LEFT //机器标识部分 | sequence; //序列号部分 } private long getNextMill() { long mill = getNewstmp(); while (mill <= lastStmp) { mill = getNewstmp(); } return mill; } private long getNewstmp() { return System.currentTimeMillis(); } public static void main(String[] args) { SnowFlake snowFlake = new SnowFlake(2, 3); for (int i = 0; i < (1 << 12); i++) { System.out.println(snowFlake.nextId()); } }}

2、为防止多线程生成重复的id，这边新建了一个调用生成id的单例工具

其中machineId和datacenterId可以放在配置文件中

import java.util.concurrent.CountDownLatch;/** * @Auther: lyl * @Date: 2019/11/21 18:15 * @Description: */public class GuuidUtil { private static long machineId = 0; private static long datacenterId = 0; /** * 单例模式创建学法算法对象 * */ private enum SnowFlakeSingleton{ Singleton; private SnowFlake snowFlake; SnowFlakeSingleton(){ snowFlake = new SnowFlake(datacenterId,machineId); } public SnowFlake getInstance(){ return snowFlake; } } public static long getUUID(){ return SnowFlakeSingleton.Singleton.getInstance().nextId(); } public static void main(String[] args) { CountDownLatch latch = new CountDownLatch(); long start = System.currentTimeMillis(); for (int i = 0; i < ; i++) { new Runnable() { @Override public void run() { System.out.println(GuuidUtil.getUUID()); latch.countDown(); } }.run(); } try { System.out.println("主线程"+Thread.currentThread().getName()+"等待子线程执行完成..."); latch.await();//阻塞当前线程，直到计数器的值为0 System.out.println("主线程"+Thread.currentThread().getName()+"开始执行..."); } catch (InterruptedException e) { e.printStackTrace(); } System.out.print("雪花算法用时： "); System.out.println(System.currentTimeMillis() - start); }}

最后直接调用：；就可以直接生成id

想了解更多编程学习，敬请关注php培训栏目！

　　以上就是雪花算法如何生成id的知识。速戳>>知识兔学习精品课！

c和java的区别是：1、Java有面向对象OO成分在里面，而C是完全面向过程的；2、Java跨平台，既不同的操作系统都可以通过JVM来解释Java程序，而C、C++、C#则是与平台相关的，有些指令只在某些操作系统中才能执行。

【相关学习推荐：java基础】

c和java的区别是：

Java和C都是指令式语言（Imperative Language），不同的是Java有面向对象（OO）成分在里面，而C是完全面向过程的，C的高级版本C++、C#支持面向对象。

另外一个不同是，Java跨平台，既不同的操作系统都可以通过JVM来解释Java程序，而C、C++、C#则是与平台相关的，有些指令只在某些操作系统中才能执行。具体原因是，Java是解释型语言，所有代码都会翻译成统一的、与系统无关的bytecode，然后放到JVM上运行；而C是编译式语言，代码要先通过编译器转换成与系统相关的中间代码，然后才能运行。

再一个不同是，Java不支持系统调用，既无法与操作系统进行交互，这是由它跨平台的特点决定的，

而C则可以调用系统中的指令，如fork()。这也就是为什么Java中只有线程（Thread）概念而没有进程（Process）概念，而C两者均有。

再者，Java无法对内存进行控制，而C则可以通过指针对内存进行人为分配。

还有一点，Java有Gabbage Collection机制，可以自动回收不再使用的空间，而C则要用函数释放空间。

总的来说，Java比较容易上手，学得快，但对于了解编程语言来说帮助不如C大。

相关学习推荐：C语言教程视频

　　以上就是c和java的区别是什么的知识。速戳>>知识兔学习精品课！

java awt中文乱码的解决办法：首先在项目右键选择Run Configuration；然后选择Arguments标签，在VM arguments框中输入【-Dfile.encoding=GB】即可。

java awt中文乱码的解决办法：

是eclipse的运行设置有问题，可以做如下设置：

1.项目右键，选择Run Configuration：

2.选择Arguments标签，在下面的VM arguments:框中输入：-Dfile.encoding=GB

之后，中文就可以正常显示了。在此建议尽量用swing来编写java图形界面。

相关学习推荐：java基础教程

　　以上就是java awt中文乱码怎么办的知识。速戳>>知识兔学习精品课！

java中使用相对路径读取文件的方法：1、使用文件【File file = new File(“src/test.txt”)】方法；2、使用类的相对路径；3、使用当前线程的类加载器；4、读取web工程下的文件。

【相关学习推荐：java基础教程】

java中使用相对路径读取文件的方法：

一、简单粗暴的 File file = new File(“src/test.txt”);

@Test /** * 这种方法 “” 空代表的是这个Java项目 TestSomeTechnology 由于实际项目在打包后没有src目录所以这种方法不常用 */ public void testMethod1() throws IOException{ File file = new File("src/test.txt"); BufferedReader br = new BufferedReader(new FileReader(file)); String len = null; while ((len=br.readLine())!=null){ System.out.println(len); } }

二、使用类的相对路径

TestRelativePath.class.getResource(“/test.txt”).getFile()

@Test /** * 使用类的相对路径 * 这种方法 “/” 代表的是bin。 src文件夹和resources 文件夹下的的东西都会被加载到bin下面因为这两个文件被配置为了source */ public void testMethod2() throws IOException{ File file = new File(TestRelativePath.class.getResource("/test.txt").getFile()); BufferedReader br = new BufferedReader(new FileReader(file)); String len = null; while ((len=br.readLine())!=null){ System.out.println(len); } }

三、使用当前线程的类加载器

Thread.currentThread().getContextClassLoader().getResource(“test.txt”).getFile()

@Test /** * 这种是通过当前线程的类加载器 * 这种方法 “ ” 空代表的是bin 。于是就直接填写test，文件夹下的的东西都会被加载到bin下面，因为这两个文件被配置为了source */ public void testMethod3() throws IOException{ File file = new File(Thread.currentThread().getContextClassLoader().getResource("test.txt").getFile()); BufferedReader br = new BufferedReader(new FileReader(file)); String len = null; if ((len=br.readLine())!=null){ System.out.println(len); } }

四、读取web工程下的文件使用getRealPath()读取

目录如下：

读取 index.jsp

@WebServlet(name = "TestServlet",urlPatterns = "/TestServlet")public class TestServlet extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {doGet(request,response); } /** * web工程的根目录是 webRoot，使用 “/” 代表webroot webroot下面有index.jsp文件 */ protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { File file = new File(getServletContext().getRealPath("/index.jsp")); BufferedReader br = new BufferedReader(new FileReader(file)); String len = null; while ((len=br.readLine())!=null){ System.out.println(len); } }}

读取 test.txt文件

不过如果想读取test.txt 的话我们可用用上面的方式

File file = new File(Thread.currentThread().getContextClassLoader().getResource("test.txt").getFile());

也可以使用

不过由于是以 webroot为根目录我们需要从classes里面读：idea的classes等价于esclipse的classpath 。classes说明：

代码：

File file = new File(getServletContext().getRealPath("/WEB-INF/classes/test.txt"));

getResourceAsStream()方法详解

getResourceAsStream()用法与getResouce()方法一样的，用getResource()取得File文件后，再new FileInputStream(file) 与 getResourceAsStream() 的效果一样。。

两个代码效果一样

InputStream inputStream1 = new FileInputStream(new File(Thread.currentThread().getContextClassLoader().getResource("test.txt").getFile()));InputStream inputStream2 = Thread.currentThread().getContextClassLoader().getResourceAsStream("test.txt");

相关学习推荐：java基础教程

　　以上就是java获取时间与系统时间不一致怎么办的知识。速戳>>知识兔学习精品课！

java计算两个时间是否相等的方法：首先引入hutool的jar包，并创建时间字符串时间；然后判断这两个时间是否一致，代码为【DateUtil.isSameTime(startTime, endTime)】；最后运行结果即可。

【相关学习推荐：java基础教程】

java计算两个时间是否相等的方法：

1、在你的工程项目中你需要引入hutool的jar包

2、接着创建一个时间字符串时间

3、然后我们还需要一个时间，再创建一个时间

4、判断这两个时间是否一致

5、运行程序检查结果，其实我们知道这两个时间是不一致的

　　以上就是java如何计算两个时间是否相等的知识。速戳>>知识兔学习精品课！

android开发的三大框架是：1、XUtil框架，主要有数据库模块、注解模块、网络模块、图片缓存模块；2、volley框架；3、ImageLoader框架。

1、XUtil框架

项目地址：https://github.com/wyouflf/xUtils

主要有四大模块：

(1) 数据库模块：Android中的orm框架，一行代码就可以进行增删改查；支持事务，默认关闭；可通过注解自定义表名，列名，外键，唯一性约束，NOT NULL约束，CHECK约束等（需要混淆的时候请注解表名和列名）；支持绑定外键，保存实体时外键关联实体自动保存或更新；自动加载外键关联实体，支持延时加载；

支持链式表达查询，更直观的查询语义，参考下面的介绍或sample中的例子。

(2) 注解模块：android中的ioc框架，完全注解方式就可以进行UI，资源和事件绑定；新的事件绑定方式，使用混淆工具混淆后仍可正常工作；目前支持常用的20种事件绑定，参见ViewCommonEventListener类和包com.lidroid.xutils.view.annotation.event。 (3) 网络模块：支持同步，异步方式的请求；支持大文件上传，上传大文件不会oom；支持GET，POST，PUT，MOVE，COPY，DELETE，HEAD，OPTIONS，TRACE，CONNECT请求；下载支持301/302重定向，支持设置是否根据Content-Disposition重命名下载的文件；返回文本内容的请求(默认只启用了GET请求)支持缓存，可设置默认过期时间和针对当前请求的过期时间。 (4) 图片缓存模块：加载bitmap的时候无需考虑bitmap加载过程中出现的oom和android容器快速滑动时候出现的图片错位等现象；支持加载网络图片和本地图片；内存管理使用lru算法，更好的管理bitmap内存；

可配置线程加载线程数量，缓存大小，缓存路径，加载显示动画等...

2、volley

项目地址：https://github.com/smanikandan14/Volley-demo(1) JSON，图像等的异步下载；(2) 网络请求的排序（scheduling）(3) 网络请求的优先级处理(4) 缓存(5) 多级别取消请求(6) 和Activity和生命周期的联动（Activity结束时同时取消所有网络请求）

3、ImageLoader框架

知识兔

支持多线程图片加载

提供丰富的细节配置，比如线程池大小，HTPP请求项，内存和磁盘缓存，图片显示时的参数配置等等；

提供双缓存

支持加载过程的监听；

提供图片的个性化显示配置接口；

　　以上就是android开发的三大框架是什么？的知识。速戳>>知识兔学习精品课！

java三大特性：1、封装，是指隐藏对象的属性和实现细节，仅对外提供公共访问方式；2、继承，从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力；3、多态，一个方法可以有多种实现版本，即“一种定义，多种实现”。

相关推荐：java入门教程

　　以上就是mybatis一级缓存和二级缓存的区别是什么的知识。速戳>>知识兔学习精品课！

java去掉html标签的方法：1、通过纯正则方法去掉html标签；2、使用“javax.swing.text.html.HTMLEditorKit”去掉html标签；3、通过使用Jsoup框架去掉html标签等等。

本文操作环境：windows7系统、Java8.0&&HTML5版，DELL G3电脑

Java去掉html标签的各种姿势

一、背景

知识兔

业务开发中可能需要将html的标签全部去掉，本文将多种方法综合在这里，供大家参考。

二、方法

知识兔

2.1 纯正则方法

import java.util.regex.Matcher; import java.util.regex.Pattern; public class HTMLSpirit{ public static String delHTMLTag(String htmlStr){ String regEx_script="<script[^>]*?>[\s\S]*?<\/script>"; //定义script的正则表达式 String regEx_style="<style[^>]*?>[\s\S]*?<\/style>"; //定义style的正则表达式 String regEx_html="<[^>]+>"; //定义HTML标签的正则表达式 Pattern p_script=Pattern.compile(regEx_script,Pattern.CASE_INSENSITIVE); Matcher m_script=p_script.matcher(htmlStr); htmlStr=m_script.replaceAll(""); //过滤script标签 Pattern p_style=Pattern.compile(regEx_style,Pattern.CASE_INSENSITIVE); Matcher m_style=p_style.matcher(htmlStr); htmlStr=m_style.replaceAll(""); //过滤style标签 Pattern p_html=Pattern.compile(regEx_html,Pattern.CASE_INSENSITIVE); Matcher m_html=p_html.matcher(htmlStr); htmlStr=m_html.replaceAll(""); //过滤html标签 return htmlStr.trim(); //返回文本字符串 } }

2.2 使用 javax.swing.text.html.HTMLEditorKit

知识兔

import java.io.IOException;import java.io.FileReader;import java.io.Reader;import java.util.List;import java.util.ArrayList;import javax.swing.text.html.parser.ParserDelegator;import javax.swing.text.html.HTMLEditorKit.ParserCallback;import javax.swing.text.html.HTML.Tag;import javax.swing.text.MutableAttributeSet;public class HTMLUtils { private HTMLUtils() {} public static List<String> extractText(Reader reader) throws IOException { final ArrayList<String> list = new ArrayList<String>(); ParserDelegator parserDelegator = new ParserDelegator(); ParserCallback parserCallback = new ParserCallback() { public void handleText(final char[] data, final int pos) { list.add(new String(data)); } public void handleStartTag(Tag tag, MutableAttributeSet attribute, int pos) { } public void handleEndTag(Tag t, final int pos) { } public void handleSimpleTag(Tag t, MutableAttributeSet a, final int pos) { } public void handleComment(final char[] data, final int pos) { } public void handleError(final java.lang.String errMsg, final int pos) { } }; parserDelegator.parse(reader, parserCallback, true); return list; } public final static void main(String[] args) throws Exception{ FileReader reader = new FileReader("java-new.html"); List<String> lines = HTMLUtils.extractText(reader); for (String line : lines) { System.out.println(line); } }}

【推荐：java视频教程】

2.3 使用Jsoup框架

知识兔

import java.io.IOException;import java.io.FileReader;import java.io.Reader;import java.io.BufferedReader;import org.jsoup.Jsoup;public class HTMLUtils { private HTMLUtils() {} public static String extractText(Reader reader) throws IOException { StringBuilder sb = new StringBuilder(); BufferedReader br = new BufferedReader(reader); String line; while ( (line=br.readLine()) != null) { sb.append(line); } String textOnly = Jsoup.parse(sb.toString()).text(); return textOnly; } public final static void main(String[] args) throws Exception{ FileReader reader = new FileReader ("C:/RealHowTo/topics/java-language.html"); System.out.println(HTMLUtils.extractText(reader)); }

2.4 使用Apache Tika

mport java.io.FileInputStream;import java.io.InputStream;import org.apache.tika.metadata.Metadata;import org.apache.tika.parser.AutoDetectParser;import org.apache.tika.parser.ParseContext;import org.apache.tika.parser.Parser;import org.apache.tika.sax.BodyContentHandler;import org.xml.sax.ContentHandler;public class ParseHTMLWithTika { public static void main(String args[]) throws Exception { InputStream is = null; try { is = new FileInputStream("C:/Temp/java-x.html"); WriteOutContentHandler contenthandler = new WriteOutContentHandler(); Metadata metadata = new Metadata(); Parser parser = new AutoDetectParser(); parser.parse(is, contenthandler, metadata, new ParseContext()); System.out.println(contenthandler.toString()); } catch (Exception e) { e.printStackTrace(); } finally { if (is != null) is.close(); } }}

注意这里经过本人实验有个小坑，WriteOutContentHandler参数是限制的字符数，这个如果不设置默认是1万，超过会报异常。

具体的jar包请自行到中央仓库里搜索依赖配置

https://search.maven.org/ 和 https://mvnrepository.com/

三、提供一个工具类

知识兔

可以将资源路径的文本类型文件（如json/html）读取成字符串

public class ResourceUtil { /** * 根据当前类路径，获取资源文件夹对应文件的所有字符串 * * @param currentClass 如 this.class * @param resourcePath 如 /data/json/xxx.json （相对于resources文件夹） */ public static String resource2String(Class currentClass, String resourcePath) throws IOException { return IOUtils.toString(new FileReader(new File(currentClass.getResource(resourcePath).getFile()))); }}

四、总结

知识兔

这里提供了多种去除html标签的方式，建议先测试好再实际使用。

测试时读取资源文件可以使用第三节提供的工具类。

如果正则表达式无法满足你的需求，自己进一步优化即可。

如果其他方式仍然有特殊情况没有考虑到，可以自己先用正则去除这种特殊情况。

总之这里只是一种参考，提供了多种解决方案。

　　以上就是java怎么去掉html标签的知识。速戳>>知识兔学习精品课！

本篇文章给大家详细介绍一下Java实现贪吃蛇小游戏的方法。有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。

1. 程序结构

知识兔

程序结构图如图：

2. 程序设计思路

知识兔

2.1 Data类

作用：连接statics文件夹，将静态资源包中的图片转化为图标方便在面板上绘制。实现：使用class.getResource(String path)方法。

代码如下：

package com.snake;import javax.swing.*;import java.net.URL;public class Data { //贪吃蛇头部 public static URL upUrl = Data.class.getResource("/statics/up.png"); public static ImageIcon up = new ImageIcon(upUrl); public static URL downUrl = Data.class.getResource("/statics/down.png"); public static ImageIcon down = new ImageIcon(downUrl); public static URL leftUrl = Data.class.getResource("/statics/left.png"); public static ImageIcon left = new ImageIcon(leftUrl); public static URL rightUrl = Data.class.getResource("/statics/right.png"); public static ImageIcon right = new ImageIcon(rightUrl); //贪食蛇身体 public static URL bodyUrl = Data.class.getResource("/statics/body.png"); public static ImageIcon body = new ImageIcon(bodyUrl); //食物 public static URL foodUrl = Data.class.getResource("/statics/food.png"); public static ImageIcon food = new ImageIcon(foodUrl);}

2.2 StartGame类

作用：创建游戏窗口，在窗口中添加一个游戏面板。实现：使用JFrame类创建游戏窗口，利用其add()方法添加一个GamePanel类实例化对象。

代码如下：

package com.snake;import javax.swing.*;import java.awt.*;public class StartGame { public static void main(String[] args){ //建立游戏窗口 JFrame frame = new JFrame("Java-贪吃蛇小游戏");//标题 frame.setSize(900,720);//窗口大小 frame.setLocationRelativeTo(null);//窗口显示屏幕中间 frame.setResizable(false);//固定窗口大小 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置窗体关闭事件 frame.add(new GamePanel());//添加游戏内容 frame.setVisible(true);//设置窗体可见 }}

2.3 GamePanel类

作用：实现游戏的动态页面。实现：（1）init()方法：初始化小蛇位置；（2）eat()方法：用随机种子随机食物的位置，并进行判定，食物位置不能和小蛇位置重合；（3）继承JPanel类，重写paintComponent(Graphics g)方法，在方法中绘制标题栏、小蛇的位置（根据direction小蛇头部方向变量绘制小蛇头部）、小蛇身体、积分栏、游戏提醒项与失败判断项；（4）实现KeyListener 接口中的keyPressed(KeyEvent e)方法，获取键盘输入，根据键盘输入对游戏状态或者小蛇头部方向direction变量进行更改；（5）实现ActionListener接口中的actionPerformed(ActionEvent e)方法，根据游戏状态和direction变量进行小蛇移动操作（注意禁用直接回头操作），进行吃食物判定和死亡判定。使用Timer计时器让游戏动态变化，用repaint()方法实时更新界面。代码如下：

package com.snake;import javax.swing.*;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyEvent;import java.awt.event.KeyListener;import java.util.Random;public class GamePanel extends JPanel implements KeyListener, ActionListener { int[] snakeX = new int[500];//贪吃蛇横坐标 int[] snakeY = new int[500];//贪吃蛇纵坐标 int foodX;//食物横坐标 int foodY;//食物蛇纵坐标 int length;//贪吃蛇的长度 String direction;//贪吃蛇头方向 int score;//积分 Random r = new Random(); Timer timer = new Timer(100,this); boolean isStart; boolean isFail; //构造函数 public GamePanel(){ init(); this.setFocusable(true); this.addKeyListener(this); timer.start(); } private void init(){ length=3; snakeX[0]=100;snakeY[0]=100; snakeX[1]=75;snakeY[1]=100; snakeX[2]=50;snakeY[2]=100; direction = "R"; eat(foodX,foodY); isStart = false; isFail = false; score = 0; } private void eat(int x,int y){ x= 25 + 25*r.nextInt(34); y= 75 + 25*r.nextInt(24); for (int i = 0; i < length; i++) { if(snakeX[i]==x&&snakeY[i]==y){ x = 25 + 25*r.nextInt(34); y = 75 + 25*r.nextInt(24); } } foodX = x;foodY = y; } protected void paintComponent(Graphics g) { super.paintComponent(g); this.setBackground(Color.white);//设置背景板为白色 //画标题 g.setColor(Color.GREEN); g.setFont(new Font("幼圆",Font.BOLD,50)); g.drawString("贪吃蛇游戏",300,60); //绘制游戏区域 g.setColor(Color.GRAY); g.fillRect(25,75,850,600); //画贪吃蛇头部 if(direction=="R"){ Data.right.paintIcon(this,g,snakeX[0],snakeY[0]); } else if(direction=="L"){ Data.left.paintIcon(this,g,snakeX[0],snakeY[0]); } if(direction=="U"){ Data.up.paintIcon(this,g,snakeX[0],snakeY[0]); } else if(direction=="D"){ Data.down.paintIcon(this,g,snakeX[0],snakeY[0]); } //画身体 for (int i = 1; i < length ; i++) { Data.body.paintIcon(this,g,snakeX[i],snakeY[i]); } //画食物 Data.food.paintIcon(this,g,foodX,foodY); //绘制积分栏 g.setColor(Color.BLACK); g.setFont(new Font("幼圆",Font.BOLD,20)); g.drawString("长度："+length,730,30); g.drawString("得分："+score,730,60); //游戏开始提醒 if(isStart==false){ g.setColor(Color.BLACK); g.setFont(new Font("幼圆",Font.BOLD,40)); g.drawString("按空格键开始游戏",300,300); } //失败判断 if(isFail){ g.setColor(Color.RED); g.setFont(new Font("幼圆",Font.BOLD,40)); g.drawString("游戏失败，按空格键重新开始",300,300); } } @Override public void keyPressed(KeyEvent e) { int keyCode = e.getKeyCode();//获取按下的按键 //判断空格 if(keyCode==KeyEvent.VK_SPACE){ if(isFail){ isFail = false; init(); } else{ isStart = !isStart; } repaint(); } //判断方向 if(keyCode==KeyEvent.VK_LEFT&&direction!="R"){ direction = "L"; } else if(keyCode==KeyEvent.VK_RIGHT&&direction!="L"){ direction = "R"; } else if(keyCode==KeyEvent.VK_UP&&direction!="D"){ direction = "U"; } else if(keyCode==KeyEvent.VK_DOWN&&direction!="U"){ direction = "D"; } } @Override public void keyReleased(KeyEvent e) { } @Override public void keyTyped(KeyEvent e) { } @Override public void actionPerformed(ActionEvent e) { //判断游戏状态 if(isStart&&!isFail){ //移动身体 for (int i = length-1; i > 0 ; i--) { snakeX[i] = snakeX[i-1]; snakeY[i] = snakeY[i-1]; } //移动头部 if(direction=="R"){ snakeX[0] += 25; if(snakeX[0]>850){ snakeX[0] = 25; } } else if(direction=="L"){ snakeX[0] -= 25; if(snakeX[0]<25){ snakeX[0] = 850; } } else if(direction=="U"){ snakeY[0] -= 25; if(snakeY[0]<75){ snakeY[0] = 650; } } else if(direction=="D"){ snakeY[0] += 25; if(snakeY[0]>650){ snakeY[0] = 75; } } //吃食物 if(snakeX[0]==foodX&&snakeY[0]==foodY){ length++; score += 10; eat(foodX,foodY); } //死亡判定 for (int i = 1; i < length; i++) { if(snakeX[0]==snakeX[i]&&snakeY[0]==snakeY[i]){ isFail=true; } } repaint(); } timer.start(); }}

3. 游戏展示

知识兔

相关推荐：java入门教程

　　以上就是怎么更改eclipse的字体大小的知识。速戳>>知识兔学习精品课！

数据类型描述占用字节取值范围默认值int整型，用于存储整数4个字节-~byteJava中最小的数据类型1个字节-128~1270short短整型2个字节-~long长整型8个字节-2^63~2^63-10Lfloat浮点型，用于存储带小数点的数字4个字节/0.0fdouble双精度浮点型，用于存储带有小数点的数字8个字节/0.0dchar字符型，用于存储单个字符2个字节0~空boolean布尔类型，用于判断真或假1个字节仅有两个值，即true、falsefalse

static是什么意思？c语言中static的用法？static关键字的作用是什么？相信很多人都会有这样的疑问，下面我们来总结一下static。

{$}

一：static是什么意思

static是一种计算机高级语言，我们经常在c++和java中看到，static经常以关键词和函数的形式出现，并且在其他高级语言中也是会出现static，当然在不同的语言下，作用也是不一样的。

二：static关键字的作用是什么

1.java中

在java中，我们想定义一个类成员，并且使用要独立于其他任何对象，在一般情况下，类成员必须要通过其他类的对象访问，很多时候我们可以不需要引进实例，就能被自己使用，只要在声明前面加上关键字，就可以创建一个成员，在其他类没有创建之前访问。我们可以通过引用静态变量。

{$}

2.在C语言中

c语言中，static函数被分为两种函数，内部函数和外部函数，其中内部函数就称为静态函数，当一个程序有很多个源文件组成的时候，c语言就能根据其他源文件调用，就不能使用同一个程序去调用，只要我们在函数前面加一个关键字就可以了，如下：

static 函数类型函数名（函数参数表）{……}

{$}

使用内部函数的好处有很多，针对不同的人编写不同的函数，不需要担心定义的函数和其他的函数名重复。外部函数如果发现没有出现关键词，就表示函数是外部函数。

以上就是static关键字的作用是什么的全部介绍，如果你想了解更多有关Java教程，请关注小兔网。

　　以上就是static关键字的作用是什么的知识。速戳>>知识兔学习精品课！

线程与进程的主要区别是：（同一进程中的）线程在共享的内存空间中运行，而进程在不同的内存空间中运行；线程使用wait()，notify()，notifyAll()等方法直接与其他线程（同一进程）通信，而进程需要使用“IPC”来与其他进程通信。

{$}

什么是进程？

正在运行中的应用程序，通常称为进程。每个进程都有自己独立的地址空间(内存空间)，每当用户启动一个进程时，操作系统就会为该进程分配一个独立的内存空间，让应用程序在这个独立的内存空间中运行。

什么是线程？

线程是一个轻量级的子进程，是最小的处理单元；是一个单独的执行路径。可以说：线程是进程的子集（部分）。

线程是独立的。如果在一个线程中发生异常，则不会影响其他线程。它使用共享内存区域。

进程和线程的关系：

{$}

如上图所示，操作系统中可以拥有多个进程，一个进程里可以拥有多个线程，线程在进程内执行。

进程和线程的区别：

1、容易创建新线程。但是，创建新进程需要重复父进程。

2、线程可以控制同一进程的其他线程。进程无法控制兄弟进程，只能控制其子进程。

3、进程拥有自己的内存空间。线程使用进程的内存空间，且要和该进程的其他线程共享这个空间；而不是在进程中给每个线程单独划分一点空间。

4、（同一进程中的）线程在共享内存空间中运行，而进程在不同的内存空间中运行。

5、线程可以使用wait（），notify（），notifyAll（）等方法直接与其他线程（同一进程）通信；而，进程需要使用“进程间通信”（IPC）来与操作系统中的其他进程通信。

{$}

说明：

IPC，即进程间通信，特指操作系统提供的允许进程管理共享数据的一种机制。

总结：以上就是本篇文的全部内容，希望能对大家的学习有所帮助。

　　以上就是java中线程与进程的区别是什么的知识。速戳>>知识兔学习精品课！

众所周知，移动互联网为用户带来便利，为相关公司带来商机。在这个新的发展领域，App软件开发可能会给行业的市场份额进行重新洗牌。

{$}

开发一个完整app需要掌握哪些知识：1、前期需求规划与信息——你需要制定出一个完整的需求文档，功能文档，流程图，时序图。2、交互设计、UI设计——设计出基本且完善的原型图和app基础的交互设计效果，之后再根据这些设计出完整的UI界面并学会切图，一些需要做自适应的素材图片需要做点9patch。这里还需要你懂得px，pt和dp之间的换算，屏幕密度的换算和相互之间的系数，以便你的app能完美适应不同分辨率设备。其中交互设计需要你懂得很多人机操作的技巧经验，掌握Axure等交互工具的使用，UI设计需要你掌握Photoshop和Illustrator等操作。3、使用ADT之类的开发环境进行app软件开发，你最基本的也得掌握java语言，熟悉android环境和机制。4、如果不是单机版的app，需要用到服务器，那你还得掌握WebService相关知识和开发语言，常用的有ASP.Net，PHP，JSP等。5、熟悉并能开发数据库。6、某些功能需要做算法，这还需要一定得专业知识，尤其是数学基础。7、熟悉API接口开发，这里包括你自行开发API的能力以及调用第三方API的经验。8、熟悉TCP/IP，socket等网络协议和相关知识。9、熟练掌握App发布的流程，真机调试技巧，证书，打包，上架。 App开发其实不一定适合一个人搞，太费劲，除非是一个单机版的小应用，或者利用现成的app开发简单的第三方应用，否则还是让一个团队来完成各自擅长的领域。

推荐课程：Java教程。

开发app软件的三种方案

第一种：自建开发团队开发

一般来说，开发团队需要大约4-6名成员，分别是产品经理（很多时间产品经理是老板），UI设计师，Android前端开发工程师，iOS前端开发工程师等，测试等每个人负责不同的部分。

自建团队的优势在于控制项目的进度（还有一种情况，老板没有顾虑，需求变化，但项目周期无限延长），但如果团队比较新，团队成员流动快，缺乏经验，然后需要磨合，导致团队成本增加。

第二种：软件公司开发

一般是正规公司，整个过程将非常规范和系统化。一些公司是专门从事私人转包的大型工作室。需要注意的是，公司需要可靠，办公场所在办公楼，拥有更多的专业技术人员。

在选择开发公司时，最好进行实地考察，了解技术实力，并查看真实的开发案例。选择一个与您的心相关的公司。在项目期间及时与项目管理团队沟通。选择App开发公司不仅可以专注于开发团队，还可以评估产品的具体实力，设计等相关优势。

但是外包开发的成本比较高，通常20万起步，普通中小企业根本承担不起。

第三种：自己免编程制作

私人开发包括独立发展的创业者、学生、教师、技术人员等。这通常是利用自己的业余时间来开发项目。，过去因为App的技术门槛，个人制作App很难实现。

随着技术的进步，现在，不需任何编程开发技术，不需要找专业的外包公司开发，自己就能够制作手机APP了。而且成本可以节约90%左右。

这就是荣获中国（深圳）科技创投创新大赛一等奖的“应用公园”APP在线制作平台。让不懂编程的人的，也可以拼图式制作手机APP。应用公园平台汇聚了上百个开发好的常见APP功能，这些开好的功能模块，你可自由组合，拼图式制作手机App了，成本可节省90%以上。

而且，应用公园平台已经有开发完善的上百套垂直领域的原生App模板，可以直接使用，最快让你10分钟就能完成App的制作。

可能大家都知道，移动互联网为用户带来便利的同时，也为相关企业带来了商机。在这一新的领域大军发展进程中，可能让App软件开发行业市场占有率重新洗牌。

　　以上就是怎么开发app软件的知识。速戳>>知识兔学习精品课！

什么是java？java是什么？下面我们来总结一下。

{$}

java是什么？

java是一个静态编程语言，具有强大的多线程特征，目前java不仅采用c++语言的优点，还去掉了一些多继承指针，等复杂的概念，我们可以使用Java可以编写很多应用程序。

java语言特性？

java语言具有简单性，并且是一种面向对象语言，java并没有什么结构，java对象都是一些数组和一些串，而且java语言编译生成字节码，可以有效的传输到各个平台，并且能保证一定的安全性。

java的工作原理是什么？

java的工作原理是有四个部分组成，当我们编辑并且运行一个java文件的时候，必须有四个部分组成，首先是有java语言编程，其次就是java文件格式，利用java虚拟机，运行文件，编译成对应字节码，使用Java应用程序接口完成api的调用。

以上就是对什么是java的全部介绍，如果你想了解更多有关Java教程，请关注小兔网。

　　以上就是java是什么的知识。速戳>>知识兔学习精品课！

jsp引入css的方法：1、在link标签中使用href属性引入css文件路径；2、使用内部样式表引入css；3、内联样式引入css。

{$}

本文操作环境：windows7系统、CSS3版、Dell G3电脑。

JSP页面引入CSS样式有三种方法，且其优先级不同。具体如下：外部样式，内部样式，内联样式。优先级依次增高！

jsp可以在link标签中使用href属性引入css文件路径。

首先把写好的css样式表内容存为*.css格式。如style.css

在页面中引入这个css 样式文件。用如下的方式引入。

此处的href="https://zhishitu.com/ke" css文件的jsp页面在同一目录）

rel 属性规定当前文档与被链接文档之间的关系，在该例子中rel属性指示被链接的文档是一个样式表。

在jsp中另外两种使用css的方法：

内部样式

当单个文档需要特殊的样式时，就应该使用内部样式表。可以使用<style>标签在文档头部定义内部样式表。

以类选择器进行样式的添加。

内联样式

由于要将表现和内容混杂在一起，内联样式会损失掉样式表的许多优势。请慎用这种方法，例如当样式仅需要在一个元素上应用一次时。要使用内联样式，你需要在相关的标签内使用样式（style）属性。Style属性可以包含任何CSS属性。

更多详细的HTML/CSS知识，请访问CSS视频教程栏目！

　　以上就是jsp怎么引入css的知识。速戳>>知识兔学习精品课！

html和jsp的区别：1、运行机制不同；2、用途不同；3、JSP是一个特殊的HTML，相当于在HTML中嵌入了Java代码；4、HTML强调浏览器中信息外观等，JSP可以从服务器调用内置功能；5、HTML在本地计算机上运行时加载速度更快。

{$}

本文操作环境：windows7系统、HTML5版、Dell G3电脑。

什么是JSP？

JSP代表JavaServer Pages；它主要用于开发动态网页，文件的扩展名为.jsp。JSP技术允许快速开发并易于维护所述信息丰富的动态网页。JSP网页基于HTML，XML或其他文档类型。他们还需要兼容的Web服务器和servlet容器，例如Apache Tomcat或Jetty，才能运行。

什么是HTML？

HTML代表超文本标记语言。它是众所周知的用于开发网页的标记语言，有助于构建网页结构。它已存在很长时间，常用于网页设计。XML或可扩展标记语言定义了一组规则，用于以人类和计算机都可读取的格式编码文档。

JSP和HTML的关系

JSP允许在HTML文件中插入Java代码

JSP和HTML的区别

1、运行机制不同，HTML是运行在客户端，是一种标记语言，由浏览器解释执行；JSP运行在服务器端，需要web容器提供运行环境。

HTML是客户端技术，提供了一种描述文档中基于文本的信息结构的方法。JSP是服务器端技术，提供了一个动态接口，用于不断更改数据并动态调用服务器操作。

2、用途不同，HTML侧重于静态数据展示，JSP侧重于和服务器交互，主要用动态网页开发。

3、JSP是一个特殊的HTML，相当于在HTML中嵌入了Java代码。

4、HTML页面强调浏览器中信息的外观，语义和布局；有助于创建Web页面结构。JSP页面可以从服务器调用内置功能，有助于开发动态Web应用程序。

5、HTML在本地计算机上运行时加载速度更快。JSP需要一些时间来加载，因为它必须与Web Server进行交互。

总结

JSP和HTML之间的主要区别在于JSP是一种创建动态Web应用程序的技术，而HTML是用于创建Web页面结构的标准标记语言。简而言之，JSP文件是一个带有Java代码的HTML文件。

更多详细的HTML/CSS知识，请访问HTML视频教程栏目！

　　以上就是html和jsp的区别是什么的知识。速戳>>知识兔学习精品课！

html代码改成jsp代码的方法：1、直接修改Html文件，添加相关代码；2、将html中【】标签中的内容替换jsp页面中【】内容即可。

{$}

本教程操作环境：windows7系统、html5版，DELL G3电脑。

html代码改成jsp代码的方法：

一、直接修改Html文件：

直接在原testPage.html页面最顶端添加代码：

<%@ page language="java" contentType="text/html; charset=GB" pageEncoding="GB"%>

修改后缀名为jsp即可。

二、新建jsp文件：

将html中<html></html>标签中的内容替换jsp页面中<html></html>内容即可。

注：jsp页面中的第一行：

<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>

改为：

<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>

{$}

扩展资料：

在的HTML转换为XHTML注意以下几点：

一、在每个页面的首部都加上文档类型的说明。

如：《!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"》

当然可以选择其他类型的。

二、标记和name 要都用小写。

可以自己编写一个替换程序，将你的HTML文档中的所有的标记都换为小写字母，还有name属性也要变为小写。

三、所有的属性值都要用引号引起来。

四、单独的标签。

如：《hr》 , 《br》 and 《img》，都要在后面加/来结束。在这里不建议使用诸如：《img》和《/img》形式的方式，直接在其后面加/就可以了，如《br /》。

五、打开W3C DTD 的官方网站：http://validator.w3.org/check/referer，验证时一般错误可能会出现在你的标签嵌套里。也可以用官方网站提供的转换工具tidy来实现转换：http://www.w3.org/People/Raggett/tidy/，

六、直接打开下面的页面可以直接输入网址来验证我们的程序了：http://validator.w3.org/check?uri=http%3A%2F%2Fmoban.7880.com%2F

相关推荐：java入门教程

　　以上就是java面试——红黑树的知识。速戳>>知识兔学习精品课！

{$}

我们先来介绍下Arraylist的知识：

（学习视频分享：java教学视频）

Arraylist：底层是基于动态数组，根据下表随机访问数组元素的效率高，向数组尾部添加元素的效率高；

但是，删除数组中的数据以及向数组中间添加数据效率低，因为需要移动数组。例如最坏的情况是删除第一个数组元素，则需要将第2至第n个数组元素各向前移动一位。而之所以称为动态数组，是因为Arraylist在数组元素超过其容量大，Arraylist可以进行扩容（针对JDK1.8 数组扩容后的容量是扩容前的1.5倍），Arraylist源码中最大的数组容量是Integer.MAX_VALUE-8，对于空出的8位，目前解释是：

①存储Headerwords；

②避免一些机器内存溢出，减少出错几率，所以少分配；

③最大还是能支持到Integer.MAX_VALUE（当Integer.MAX_VALUE-8依旧无法满足需求时）。

以下是Arraylist部分源码：Arraylist扩容：

{$}

（更多面试题分享：java面试题及答案）

Arraylist添加数据：（向数组尾部添加）

{$}

向数组的指定位置添加数组：

{$}

可以看到，只要ArrayList的当前容足够大，add()操作向数组的尾部的效率非常高的，当向数组指定位置添加数据时，会进行大量的数组移动复制操作。而数组复制时，最终将调用System.arraycopy()方法，因此add()操作的效率还是相当高的。尽管这样当向指定位置添加数据时也还是比Linkedlist慢，后者添加数据只需要改变指针指向即可。Arraylist删除数组也需要移动数组，效率较慢。

Linkedlist基于链表的动态数组，数据添加删除效率高，只需要改变指针指向即可，但是访问数据的平均效率低，需要对链表进行遍历。Arraylist get数据的源码：（根据下标访问，效率高）

{$}

Linkedlist访问数据的源码：（node()函数遍历链表）

{$}

总结：

1、对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。

对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

2、各自效率问题：

{$}

相关推荐：java入门教程

　　以上就是java面试之Arraylist和Linkedlist的区别的知识。速戳>>知识兔学习精品课！

{$}

首先我们来看下阿里和顺丰面试题目。

阿里面试题：对HTTP协议了解多少，HTTP和HTTPS有什么区别，HTTPS的安全性是怎么实现的

顺丰面试题：http解释一下

（学习视频分享：java视频教程）

详细解答如下：

一、HTTP简介

HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写。HTTP协议工作于客户端-服务端架构为上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。Web服务器根据接收到的请求后，向客户端发送响应信息。二、HTTP协议特点无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。三、HTTP之状态码 1xx：指示信息–表示请求已接收，继续处理 2xx：成功–表示请求已被成功接收、理解、接受 3xx：重定向–要完成请求必须进行更进一步的操作 4xx：客户端错误–请求有语法错误或请求无法实现 5xx：服务器端错误–服务器未能实现合法的请求常见的状态码：

200 OK //客户端请求成功400 Bad Request //客户端请求有语法错误，不能被服务器所理解401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用 403 Forbidden //服务器收到请求，但是拒绝提供服务404 Not Found //请求资源不存在，eg：输入了错误的URL500 Internal Server Error //服务器发生不可预期的错误503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常

四、HTTP工作原理

HTTP协议定义Web客户端如何从Web服务器请求Web页面，以及服务器如何把Web页面传送给客户端。HTTP协议采用了请求/响应模型。客户端向服务器发送一个请求报文，请求报文包含请求的方法、URL、协议版本、请求头部和请求数据。服务器以一个状态行作为响应，响应的内容包括协议的版本、成功或者错误代码、服务器信息、响应头部和响应数据。以下是 HTTP 请求/响应的步骤： 1、客户端连接到Web服务器一个HTTP客户端，通常是浏览器，与Web服务器的HTTP端口（默认为80）建立一个TCP套接字连接。例如，http://www.baidu.con。 2、发送HTTP请求通过TCP套接字，客户端向Web服务器发送一个文本的请求报文，一个请求报文由请求行、请求头部、空行和请求数据4部分组成。 3、服务器接受请求并返回HTTP响应 Web服务器解析请求，定位请求资源。服务器将资源复本写到TCP套接字，由客户端读取。一个响应由状态行、响应头部、空行和响应数据4部分组成。 4、释放连接TCP连接若connection 模式为close，则服务器主动关闭TCP连接，客户端被动关闭连接，释放TCP连接;若connection 模式为keepalive，则该连接会保持一段时间，在该时间内可以继续接收请求; 5、客户端浏览器解析HTML内容客户端浏览器首先解析状态行，查看表明请求是否成功的状态代码。然后解析每一个响应头，响应头告知以下为若干字节的HTML文档和文档的字符集。客户端浏览器读取响应数据HTML，根据HTML的语法对其进行格式化，并在浏览器窗口中显示。例如：在浏览器地址栏键入URL，按下回车之后会经历以下流程： 1、浏览器向 DNS 服务器请求解析该 URL 中的域名所对应的 IP 地址; 2、解析出 IP 地址后，根据该 IP 地址和默认端口 80，和服务器建立TCP连接; 3、浏览器发出读取文件(URL 中域名后面部分对应的文件)的HTTP 请求，该请求报文作为 TCP 三次握手的第三个报文的数据发送给服务器; 4、服务器对浏览器请求作出响应，并把对应的 html 文本发送给浏览器; 5、释放 TCP连接; 6、浏览器将该 html 文本并显示内容;

(更多相关面试题请访问：java面试题及答案)

五、HTTP和HTTPS有什么区别 HTTPS：是以安全为目标的HTTP通道，简单讲是HTTP的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。 HTTPS协议的主要作用可以分为两种：一种是建立一个信息安全通道，来保证数据传输的安全；另一种就是确认网站的真实性。 HTTPS和HTTP的区别主要如下： 1、https协议需要到ca申请证书，一般免费证书较少，因而需要一定费用。 2、http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。 3、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。 4、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。六、HTTPS的安全性是怎么实现的

{$}

（1）客户使用https的URL访问Web服务器，要求与Web服务器建立SSL连接。（2）Web服务器收到客户端请求后，会将网站的证书信息（证书中包含公钥）传送一份给客户端。（3）客户端的浏览器与Web服务器开始协商SSL连接的安全等级，也就是信息加密的等级。（4）客户端的浏览器根据双方同意的安全等级，建立会话密钥，然后利用网站的公钥将会话密钥加密，并传送给网站。（5）Web服务器利用自己的私钥解密出会话密钥。（6）Web服务器利用会话密钥加密与客户端之间的通信。

{$}

相关推荐：java入门教程

　　以上就是java面试之HTTP和HTTPS协议的知识。速戳>>知识兔学习精品课！

{$}

面试题：

你对java中的锁有所了解么？锁有哪几种？它们有什么区别？你来说一下。

（学习视频分享：java视频教程）

解答：

大致可以分为这几点：锁是什么，有什么用，有哪几种锁，锁的区别。

一：锁是什么，有什么用？

锁主要用来实现资源共享的同步。只有获取到了锁才能访问该同步代码，否则等待其他线程使用结束释放锁。

二：有哪几种锁？

这里主要针对：synchronize和Lock（因为面试就是问这两个）。

synchronize：可以放在方法前面；也可以放在代码块前面，但需要指定上锁的对象。通常和wait，notify，notifyAll一块使用。wait：释放占有的对象锁，释放CPU。 sleep：则是释放CPU，但是不释放占有的对象锁。

notify：唤醒等待队列中的一个线程，使其获得锁进行访问。

notifyAll：唤醒等待队列中等待该对象锁的全部线程，让其竞争去获得锁。

Lock：拥有synchronize相同的语义，但是添加一些其他特性，如中断锁等候和定时锁等候，所以可以使用lock代替synchronize。提供的方法有：

（更多相关面试题推荐：java面试题及答案）

lock()：以阻塞式获取锁，没有获取到一直等待，不会被中断。

tryLock(): 获取一下，获取到就返回true，没获取到就返回false。

tryLock(long timeout,TimeUnit unit):获取到返回true，没获取到等待给定的时间，还没获取到就返回false。

lockInterruptibly() : 与lock类似，但是没有获取锁会进入到休眠状态，直到获得锁或者当前线程被别的线程中断。

三：两者的区别？

性能不一致：资源竞争激励的情况下，lock性能会比synchronize好，竞争不激励的情况下，synchronize比lock性能好。

锁机制不一样：synchronize是在JVM层面实现的，系统会监控锁的释放与否。lock是代码实现的，需要手动释放，在finally块中释放。可以采用非阻塞的方式获取锁。

用法不一样：synchronize可以用在代码块上，方法上。lock通过代码实现，有更精确的线程语义。

相关推荐：java入门教程

　　以上就是java面试——锁的知识。速戳>>知识兔学习精品课！

{$}

首先向大家介绍下什么是循环依赖。

（学习视频分享：java视频教程）

所谓循环依赖就是A依赖B，同时B又依赖A，两者之间的依赖关系形成了一个圆环，一般是由于不正确的编码所导致。Spring只能解决属性循环依赖问题，不能解决构造函数循环依赖问题，因为这个问题无解。

接下来我们首先写一个Demo来演示Spring是如何处理属性循环依赖问题的。

Talk is cheap. Show me the code

第一步：定义一个类ComponentA，其有一个私有属性componentB。

package com.tech.ioc;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;/** * @author 君战 * **/@Componentpublic class ComponentA {@Autowiredprivate ComponentB componentB;public void say(){componentB.say();}}

第二步：定义一个类ComponentB，其依赖ComponentA。并定义一个say方法便于打印数据。

package com.tech.ioc;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;/** * @author 君战 * **/@Componentpublic class ComponentB {@Autowiredprivate ComponentA componentA;public void say(){System.out.println("componentA field " + componentA);System.out.println(this.getClass().getName() + " -----> say()");}}

第三步：重点，编写一个类-SimpleContainer，模仿Spring底层处理循环依赖。如果理解这个代码，再去看Spring处理循环依赖的逻辑就会很简单。

package com.tech.ioc;import java.beans.Introspector;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.util.HashMap;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;/** * 演示Spring中循环依赖是如何处理的，只是个简版，真实的Spring依赖处理远比这个复杂。 * 但大体思路都相同。另外这个Demo很多情况都未考虑，例如线程安全问题，仅供参考。 * @author 君战 * * **/public class SimpleContainer {/*** * 用于存放完全初始化好的Bean，Bean处于就绪状态 * 这个Map定义和Spring中一级缓存命名一致 * */private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();/*** * 用于存放刚创建出来的Bean，其属性还没有处理，因此存放在该缓存中的Bean还不可用。 * 这个Map定义和Spring中三级缓存命名一致 * */private final Map<String, Object> singletonFactories = new HashMap<>(16);public static void main(String[] args) {SimpleContainer container = new SimpleContainer();ComponentA componentA = container.getBean(ComponentA.class);componentA.say();}public <T> T getBean(Class<T> beanClass) {String beanName = this.getBeanName(beanClass);// 首先根据beanName从缓存中获取Bean实例Object bean = this.getSingleton(beanName);if (bean == null) {// 如果未获取到Bean实例，则创建Bean实例return createBean(beanClass, beanName);}return (T) bean;}/*** * 从一级缓存和二级缓存中根据beanName来获取Bean实例，可能为空 * */private Object getSingleton(String beanName) {// 首先尝试从一级缓存中获取Object instance = singletonObjects.get(beanName);if (instance == null) { // Spring 之所以能解决循环依赖问题，也是靠着这个三级缓存--singletonFactoriesinstance = singletonFactories.get(beanName);}return instance;}/*** * 创建指定Class的实例，返回完全状态的Bean(属性可用) * * */private <T> T createBean(Class<T> beanClass, String beanName) {try {Constructor<T> constructor = beanClass.getDeclaredConstructor();T instance = constructor.newInstance();// 先将刚创建好的实例存放到三级缓存中，如果没有这一步，Spring 也无法解决三级缓存singletonFactories.put(beanName, instance);Field[] fields = beanClass.getDeclaredFields();for (Field field : fields) {Class<?> fieldType = field.getType();field.setAccessible(true); // 精髓是这里又调用了getBean方法，例如正在处理ComponentA.componentB属性，// 执行到这里时就会去实例化ComponentB。因为在getBean方法首先去查缓存，// 而一级缓存和三级缓存中没有ComponentB实例数据，所以又会调用到当前方法，// 而在处理ComponentB.componentA属性时，又去调用getBean方法去缓存中查找，// 因为在前面我们将ComponentA实例放入到了三级缓存，因此可以找到。// 所以ComponentB的实例化结束，方法出栈，返回到实例化ComponentA的方法栈中，// 这时ComponentB已经初始化完成，因此ComponentA.componentB属性赋值成功！field.set(instance, this.getBean(fieldType));}// 最后再将初始化好的Bean设置到一级缓存中。singletonObjects.put(beanName, instance);return instance;} catch (Exception e) {e.printStackTrace();}throw new IllegalArgumentException();}/** * 将类名小写作为beanName，Spring底层实现和这个差不多，也是使用javaBeans的 * {@linkplain Introspector#decapitalize(String)} **/private String getBeanName(Class<?> clazz) {String clazzName = clazz.getName();int index = clazzName.lastIndexOf(".");String className = clazzName.substring(index);return Introspector.decapitalize(className);}}

如果各位同学已经阅读并理解上面的代码，那么接下来我们就进行真实的Spring处理循环依赖问题源码分析，相信再阅读起来就会很容易。

底层源码分析

分析从AbstractBeanFactory的doGetBean方法着手。可以看到在该方法首先调用transformedBeanName(其实就是处理BeanName问题)，和我们自己写的getBeanName方法作用是一样的，但Spring考虑的远比这个复杂，因为有FactoryBean、别名问题。

// AbstractBeanFactory#doGetBeanprotected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {String beanName = transformedBeanName(name);Object bean;// ！！！重点是这里，首先从缓存中beanName来获取对应的Bean。Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {// 执行到这里说明缓存中存在指定beanName的Bean实例，getObjectForBeanInstance是用来处理获取到的Bean是FactoryBean问题bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);else {try {// 删除与本次分析无关代码..https://xiaotua.com// 如果是单例Bean，则通过调用createBean方法进行创建if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);} catch (BeansException ex) {destroySingleton(beanName);throw ex;}});}catch (BeansException ex) {cleanupAfterBeanCreationFailure(beanName);throw ex;}}return (T) bean;}

getSingleton方法存在重载方法，这里调用的是重载的getSingleton方法，注意这里传递的boolean参数值为true，因为该值决定了是否允许曝光早期Bean。

// DefaultSingletonBeanRegistry#getSingletonpublic Object getSingleton(String beanName) {return getSingleton(beanName, true);}

// DefaultSingletonBeanRegistry#getSingletonprotected Object getSingleton(String beanName, boolean allowEarlyReference) {// 首先从一级缓存中获取Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 如果一级缓存中未获取到，再从二级缓存中获取singletonObject = this.earlySingletonObjects.get(beanName);// 如果未从二级缓存中获取到并且allowEarlyReference值为true(前面传的为true)if (singletonObject == null && allowEarlyReference) {synchronized (this.singletonObjects) { //Double Check singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null) {// 最后尝试去三级缓存中获取ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();// 保存到二级缓存this.earlySingletonObjects.put(beanName, singletonObject);// 从三级缓存中移除this.singletonFactories.remove(beanName);}}}}}}return singletonObject;}

（更多面试题请访问：java面试题及答案）

ok，看完Spring是如何从缓存中获取Bean实例后，那再看看creatBean方法是如何创建Bean的

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// 删除与本次分析无关的代码...try {// createBean方法底层是通过调用doCreateBean来完成Bean创建的。Object beanInstance = doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace("Finished creating instance of bean '" + beanName + "'");}return beanInstance;} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {throw ex;} catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);}}

// AbstractAutowireCapableBeanFactory#doCreateBeanprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {// 创建Bean实例instanceWrapper = createBeanInstance(beanName, mbd, args);}Object bean = instanceWrapper.getWrappedInstance();// 如果允许当前Bean早期曝光。只要Bean是单例的并且allowCircularReferences 属性为true(默认为true)boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {// 这里调用了addSingletonFactory方法将刚创建好的Bean保存到了三级缓存中。addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// 删除与本次分析无关的代码.....Object exposedObject = bean;try {// Bean属性填充populateBean(beanName, mbd, instanceWrapper);// 初始化Bean，熟知的Aware接口、InitializingBean接口.....都是在这里调用exposedObject = initializeBean(beanName, exposedObject, mbd);} catch (Throwable ex) {}// 删除与本次分析无关的代码.....return exposedObject;}

先分析addSingletonFactory方法，因为在该方法中将Bean保存到了三级缓存中。

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");synchronized (this.singletonObjects) {// 如果一级缓存中不存在指定beanName的keyif (!this.singletonObjects.containsKey(beanName)) {// 将刚创建好的Bean实例保存到三级缓存中this.singletonFactories.put(beanName, singletonFactory);// 从二级缓存中移除。this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}}

处理Bean的依赖注入是由populateBean方法完成的，但整个执行链路太长了，这里就不展开讲了，只说下IoC容器在处理依赖时是如何一步一步调用到getBean方法的，这样就和我们自己写的处理字段注入的逻辑对上了。

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {// 删除与本次分析无关代码...PropertyDescriptor[] filteredPds = null;if (hasInstAwareBpps) {if (pvs == null) {pvs = mbd.getPropertyValues();}// 遍历所有已注册的BeanPostProcessor接口实现类，如果实现类是InstantiationAwareBeanPostProcessor接口类型的，调用其postProcessProperties方法。for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);// 删除与本次分析无关代码...pvs = pvsToUse;}}// 删除与本次分析无关代码...}}

在Spring 中，@Autowired注解是由AutowiredAnnotationBeanPostProcessor类处理，而@Resource注解是由CommonAnnotationBeanPostProcessor类处理，这两个类都实现了InstantiationAwareBeanPostProcessor接口，都是在覆写的postProcessProperties方法中完成了依赖注入。这里我们就分析@Autowired注解的处理。

// AutowiredAnnotationBeanPostProcessor#postProcessPropertiespublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {// 根据beanName以及bean的class去查找Bean的依赖元数据-InjectionMetadata InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);try {// 调用inject方法metadata.inject(bean, beanName, pvs);} catch (BeanCreationException ex) {throw ex;} catch (Throwable ex) {throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);}return pvs;}

在InjectionMetadata的inject方法中，获取当前Bean所有需要处理的依赖元素(InjectedElement)，这是一个集合，遍历该集合，调用每一个依赖注入元素的inject方法。

// InjectionMetadata#injectpublic void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {// 获取当前Bean所有的依赖注入元素(可能是方法，也可能是字段)Collection<InjectedElement> checkedElements = this.checkedElements;Collection<InjectedElement> elementsToIterate =(checkedElements != null ? checkedElements : this.injectedElements);if (!elementsToIterate.isEmpty()) {// 如果当前Bean的依赖注入项不为空，遍历该依赖注入元素for (InjectedElement element : elementsToIterate) {// 调用每一个依赖注入元素的inject方法。element.inject(target, beanName, pvs);}}}

在AutowiredAnnotationBeanPostProcessor类中定义了两个内部类-AutowiredFieldElement、AutowiredMethodElement继承自InjectedElement，它们分别对应字段注入和方法注入。

{$}

以大家常用的字段注入为例，在AutowiredFieldElement的inject方法中，首先判断当前字段是否已经被处理过，如果已经被处理过直接走缓存，否则调用BeanFactory的resolveDependency方法来处理依赖。

// AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#injectprotected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {Field field = (Field) this.member;Object value;if (this.cached) {// 如果当前字段已经被处理过，直接从缓存中获取value = resolvedCachedArgument(beanName, this.cachedFieldValue);} else {// 构建依赖描述符DependencyDescriptor desc = new DependencyDescriptor(field, this.required);desc.setContainingClass(bean.getClass());Set<String> autowiredBeanNames = new LinkedHashSet<>(1);Assert.state(beanFactory != null, "No BeanFactory available");TypeConverter typeConverter = beanFactory.getTypeConverter();try {// 调用BeanFactory的resolveDependency来解析依赖value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);} catch (BeansException ex) {throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);}// 删除与本次分析无关代码....}if (value != null) {// 通过反射来对属性进行赋值ReflectionUtils.makeAccessible(field);field.set(bean, value);}}}

在DefaultListableBeanFactory实现的resolveDependency方法，最终还是调用doResolveDependency方法来完成依赖解析的功能。在Spring源码中，如果存在do什么什么方法，那么该方法才是真正干活的方法。

// DefaultListableBeanFactory#resolveDependencypublic Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {// ...https://xiaotua.com// 如果在字段(方法)上添加了@Lazy注解，那么在这里将不会真正的去解析依赖Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);if (result == null) {// 如果未添加@Lazy注解，那么则调用doResolveDependency方法来解析依赖result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);}return result;}

// DefaultListableBeanFactory#doResolveDependencypublic Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {//.....try {// 根据名称以及类型查找合适的依赖Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);if (matchingBeans.isEmpty()) {// 如果未找到相关依赖if (isRequired(descriptor)) { // 如果该依赖是必须的(例如@Autowired的required属性)，直接抛出异常raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}return null;}String autowiredBeanName;Object instanceCandidate;// 如果查找到的依赖多于一个，例如某个接口存在多个实现类，并且多个实现类都注册到IoC容器中。if (matchingBeans.size() > 1) {// 决定使用哪一个实现类，@Primary等方式都是在这里完成autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);if (autowiredBeanName == null) {if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);} else { return null;}}instanceCandidate = matchingBeans.get(autowiredBeanName);} else {// We have exactly one match.Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();autowiredBeanName = entry.getKey();instanceCandidate = entry.getValue();}if (autowiredBeanNames != null) {autowiredBeanNames.add(autowiredBeanName);}// 如果查找到的依赖是某个类的Class(通常如此)，而不是实例，//调用描述符的方法来根据类型resolveCandidate方法来获取该类型的实例。if (instanceCandidate instanceof Class) {instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);}//...}

在依赖描述符的resolveCandidate方法中，是通过调用BeanFactory 的getBean方法来完成所依赖Bean实例的获取。

// DependencyDescriptor#resolveCandidatepublic Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)throws BeansException {return beanFactory.getBean(beanName);}

而在getBean方法实现中，依然是通过调用doGetBean方法来完成。这也和我们自己写的依赖处理基本一致，只不过我们自己写的比较简单，而Spring要考虑和处理的场景复杂，因此代码比较繁杂，但大体思路都是一样的。

// AbstractBeanFactory#getBeanpublic Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false);}

重点是前面我们写的处理循环依赖的Demo，如果理解那个代码，再看Spring的循环依赖处理，就会发现很简单。

总结：

循环依赖就是指两个Bean之间存在相互引用关系，例如A依赖B，B又依赖A，但Spring只能解决属性循环依赖，不能解决构造函数循环依赖，这种场景也无法解决。

Spring解决循环依赖的关键就是在处理Bean的属性依赖时，先将Bean存到三级缓存中，当存在循环依赖时，从三级缓存中获取到相关Bean，然后从三级缓存中移除，存入到二级缓存中，最后初始化完毕后存入到一级缓存中。

相关推荐：java入门教程

　　以上就是java面试题：你知道什么是循环依赖么？Spring是如何解决循环依赖的？的知识。速戳>>知识兔学习精品课！

{$}

我们先来看下题目内容：

（学习视频分享：java视频教程）

public class TestSync2 implements Runnable { int b = 100; synchronized void m1() throws InterruptedException { b = 1000; Thread.sleep(500); //6 System.out.println("b=" + b); } synchronized void m2() throws InterruptedException { Thread.sleep(250); //5 b = 2000; } public static void main(String[] args) throws InterruptedException { TestSync2 tt = new TestSync2(); Thread t = new Thread(tt); //1 t.start(); //2 tt.m2(); //3 System.out.println("main thread b=" + tt.b); //4 } @Override public void run() { try { m1(); } catch (InterruptedException e) { e.printStackTrace(); } }}

该程序的输出结果？

程序输出结果

main thread b=2000b=1000或main thread b=1000b=1000

考察知识点

synchronize实例锁。

并发下的内存可见性。

（更多相关面试题推荐：java面试题及答案）

在java中，多线程的程序最难理解、调试，很多时候执行结果并不像我们想象的那样执行。所以在java多线程特别难，依稀记得大学的时候考c语言二级的时候，里面的题目是什么++和很多其他优先级的符合在一起问最后的输出结果，这类题目就想考一些运行符优先级和结合性问题。那个背背就行了，但是java多线程还是需要好好理解才行，靠背是不行的。

下面开始简单分析：

该题目涉及到2个线程（主线程main、子线程）、关键词涉及到synchronized、Thread.sleep。synchronized关键词还是比较复杂的（可能有时候没有理解到位所以上面题目会有点误区），他的作用就是实现线程的同步（实现线程同步有很多方法，它只是一种后续文章会说其他的，需要好好研究大神Doug Lea的一些实现），它的工作就是对需要同步的代码加锁，使得每一次只有一个线程可以进入同步块（其实是一种悲观策略）从而保证线程只记得安全性。

一般关键词synchronized的用法

指定加锁对象:对给定对象加锁，进入同步代码前需要活的给定对象的锁。直接作用于实例方法:相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。直接作用于静态方法:相当于对当前类加锁，进入同步代码前要获得当前类的锁。

上面的代码，synchronized用法其实就属于第二种情况。直接作用于实例方法:相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

可能存在的误区

由于对synchronized理解的不到为，由于很多时候，我们多线程都是操作一个synchronized的方法，当2个线程调用2个不同synchronized的方法的时候，认为是没有关系的，这种想法是存在误区的。直接作用于实例方法:相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。如果一个调用synchronized方法。另外一个调用普通方法是没有关系的，2个是不存在等待关系的。

这些对于后面的分析很有作用。

Thread.sleep

使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常，对于后面的分析很有作用。一些细节可以参考我的系统学习java高并发系列二。

分析流程：

java 都是从main方法执行的，上面说了有2个线程，但是这里就算修改线程优先级也没用，优先级是在2个程序都还没有执行的时候才有先后，现在这个代码一执行，主线程main已经执行了。对于属性变量 int b =100由于使用了synchronized也不会存在可见性问题（也没有必要在说使用volatile申明），当执行1步骤的时候（Thread t = new Thread(tt); //1）线程是new状态，还没有开始工作。

当执行2步骤的时候（t.start(); //2）当调用start方法，这个线程才正真被启动，进入runnable状态，runnable状态表示可以执行，一切准备就绪了，但是并不表示一定在cpu上面执行，有没有真正执行取决服务cpu的调度。在这里当执行3步骤必定是先获得锁（由于start需要调用native方法，并且在用完成之后在一切准备就绪了，但是并不表示一定在cpu上面执行，有没有真正执行取决服务cpu的调度，之后才会调用run方法，执行m1方法）。

这里其实2个synchronized方法里面的Thread.sheep其实要不要是无所谓的，估计是就为混淆增加难度。3步骤执行的时候其实很快子线程也准备好了，但是由于synchronized的存在，并且是作用同一对象，所以子线程就只有必须等待了。由于main方法里面执行顺序是顺序执行的，所以必须是步骤3执行完成之后才可以到4步骤，而由于3步骤执行完成，子线程就可以执行m1了。

这里就存在一个多线程谁先获取到问题，如果4步骤先获取那么main thread b=2000，如果子线程m1获取到可能就b已经赋值成1000或者还没有来得及赋值4步骤就输出了可能结果就是main thread b=1000或者main thread b=2000，在这里如果把6步骤去掉那么b=执行在前和main thread b=在前就不确定了。但是由于6步骤存在，所以不管怎么都是main thread b=在前面，那么等于1000还是2000看情况，之后b=1000是一定固定的了。

多线程一些建议

线程也很珍贵，所以建议使用线程池，线程池用的很多，后续准备分享下，特别重要，需要做到心中有数。给线程起名字，当线上cpu高的时候，需要用到高级jstack，如果有名称就方便很多。多线程特别需要注意线程安全问题，也需要了解jdk那些是线程安全不安全，那样使用的时候不会出现莫名其妙问题。

还有一些技巧后续文章分享在慢慢提，多线程特别重要，也特别难，希望大家也多多花心思在上面。

多线程的一些调试技巧

由于断点，所有线程经过断点的时候，都需要停下，导致这个点不停的断住，很难受，eclispe里面有条件断点，当满足条件的时候就可以停下来，那么这样就方便了。

相关推荐：java入门教程

　　以上就是听说这是很难的一道java面试题？的知识。速戳>>知识兔学习精品课！

{$}

大家都知道一个完整的面试流程一定离不开自我介绍，自我介绍的优劣甚至决定了面试结果的好坏。那么你知道一个好的自我介绍是怎样的么？

（学习视频分享：java视频教程）

要回答这个问题，首先搞清楚为什么面试官要请你做自我介绍？面试官通过自我介绍想考察被面试者什么？只有了解面试官的目的，被面试者才能做好自我介绍。

面试官通过被面试者自我介绍要考察以下五方面内容：

第一，考察自我介绍内容和递交简历内容是否相冲突？如果简历是真实的，口述自我介绍就不会有明显出入。如果简历有假，自我介绍阶段一般就会漏马脚。如被面试者反问：“我的经历在简历里都写了”，面试官会认为这人个色，印象分一下子降为负数。

第二，考察被面试者基本的逻辑思维能力、语言表达能力，总结提炼概括能力。

第三，考察被面试者是否聚焦，是否简练和精干，现场的感知能力与把控能力。

第四，考察被面试者初步的自我认知能力和价值取向。因为被面试者要叙述职业切换关键节点处的原因，尤其要考察最近职业变动的原因。

第五，考察被面试者是否听明白了面试官的话以及时间的掌控能力。有时面试官给出的问题是“请您用3到5分钟做一自我介绍”，被面试者有时一介绍就超过10分钟，甚至20分钟，逼得面试官不得不多次提醒引导。

所以说，自我介绍是被面试者在纸面之外最能够呈现能力的一个地方。一般情况下，也是被面试者在整个面试过程中惟一一次主动展示自我的机会。如果还有一次，那就是面试官最后一个问题：“您还有什么问我的？”但这个问题通常只是面试官认为被面试者基本靠谱了，才会留下这个问题。

自我介绍和简历有何区别？

面试和简历还有两个重要区别：第一，面试是一个双向互动的过程，简历是单方向呈现。有些人可能工作经验很丰富，专业能力很突出，但是面试的经验不足，所以面对面试官叙述吞吞吐吐，抓不住要点。

第二，简历介绍应是倒叙为好，但面试正相反。当你面向面试官时，应按照时间的顺序从前往后讲，先讲你上大学的教育经历，之后从你参加工作，一直讲到现在，因为面试官要听到你整个成长的经历。否则，面试官会有一种很错乱的感觉。

（更多相关面试题推荐：java面试题及答案）

自我介绍有哪些要领？

一、时间把控。首先把握住时间。面试时自我介绍一般在3～5分钟结束，最多不超过10分钟。另外，时间分配上也要把握好。假若5分钟做自我介绍，1 分钟要做完自然情况介绍，包括教育经历；最近三到五年工作介绍要占到3分钟；其余的经历用1分钟。如果最近两年没做什么事，可以把自认为自己最有价值的一段经历介绍两分钟。

二、内容把控。1.做过什么。介绍个人履历。把自己曾经做过的事情说清楚，对应时间节点的工作单位、工作地点、工作岗位、担任职务、工作内容等，尤其是对最近几年做过的事情要重点来说。较早之前的工作经验，或者学习的经验可以一带而过，要把握“重点突出”的原则。

2.做成过什么。介绍个人业绩。把自己在不同阶段做成的有代表性的事情介绍清楚，注意两点：一是与应聘岗位需要的能力相关的业绩多介绍，不相关的一笔带过或不介绍，因为面试官关注的是对用人单位有用的业绩；二要注意介绍你个人的业绩而不是团队业绩，要把自己最精彩的一两段业绩加以重点呈现，因为用人单位要招聘的是你，而不是你过去的团队。否则，不仅无益而且只是成本，因为必然挤占其他重要的展示自己与互相交流的时间。

3.特长是什么。注意介绍自己最擅长的一定要与应聘的岗位密切相关，主要是围绕专业特长来介绍。除专业特长以外的特长，如果特别突出可以介绍，但要点到为止。

三、要有清晰的职业逻辑关系

自我介绍要有清晰的职业发展逻辑关系。职业有三期：学习期、成长期、成熟期。职场学习期和成长期，简单介绍，但不能省略，因为学习期标志着你做事的方法，成长期代表着专业提升和管理提升的方式。重点讲成熟期，成熟期能否做成事情，做成了什么事情，在什么环境下做成的，都代表着一个职场人的智慧和职业成熟度。而这三期的职业转换要有明确的逻辑关系。

四、要围绕岗位胜任能力模型来介绍

自我介绍要围绕岗位胜任力模型展开。80%要围绕与应聘岗位所需要的专业胜任能力模型展开；20%围绕与应聘岗位所需的行为风格模型来介绍。面试官只关注你与岗位匹配度有关的事情，尤其是你最近三到五年。早期干的事情若与岗位匹配度相关，即在同一专业领域里干，也可以介绍。如果五年前干的另外一件事与岗位专业度无关，不要介绍，最多是简单描述一下当时专业转换的背景和动机即可。在中国目前这种迅速变化的市场环境条件下，三年就是一突变，你介绍最近三到五年干的事情及所在单位的文化氛围，才与你应聘岗位有比较大的相关性。

自我介绍有哪些禁忌？

1、忌讳主动介绍个人爱好。面试时不要介绍个人爱好，除非面试官主动问。有被面试者虽然工作多年了，往往在做自我介绍时，仍兴致盎然地介绍个人爱好，如：登山、打球、听音乐等等，不仅白白浪费时间，还让面试官感觉你成熟度不够。注意，个人爱好不等于个人特长。

2.忌讳头重脚轻。上来把自己刚参加工作那一段经历讲得非常详细，讲得眉飞色舞，以至于忽略了时间，忽然发现时间很紧了，只好把近年的事情一代而过，结果面试官对你的把握还停留在你刚参加工作那一段经历里，对你的能力会产生错误的判断，同时会认为你时间概念不强。曾有一位被面试者，我连续提醒和引导，1小时还没有做完自我介绍。还有一位老总都工作20年了，自我介绍了30分钟，还没有走出大学毕业后前两年在西北沙漠里奔波。

3.忌讳过于简单，没有内容。这倒很爽快，结果1分钟把工作的经历全部说完，没有下文了，只介绍干了什么，没介绍干成了什么和自己的专业特长，全等着面试官发问。而面试官除了你简单的经历什么也没听着，不知该从何问起。这就等于你放弃了一次主动展示自己的机会，等面试官发问你就得被动应付。面试官也会认为你过于轻率，或沟通表达能力不强。

4.忌讳介绍背景而不介绍自己。把自己企业介绍了很多，对自己的介绍很少。甚至有的已经是国内知名品牌和国际知名品牌企业，还把企业的发展历程兴致勃勃地介绍了10分钟。这样面试官会认为你智商有问题，或不知道自己干什么来的。

5.忌讳把岗位职责当个人业绩来呈现。比如是市场部总监，结果你把整个市场部的职责逐条介绍了一遍，占了很多时间。你应该介绍自己在担任市场部总监这段时间内，自己所做出的个人努力，采取的工作方法，动用了什么资源，最终取得的实实在在的业绩。出现这种情况，往往是面试经验不丰富造成的，通过专业的猎头顾问，会帮助你避免这种低级错误。

6.忌讳说满和说谎。在做自我介绍时，全部事实不一定都说尽，但说出来的一定是事实，一定不要说谎，不要把自己吹嘘得天花乱坠，无所不能。说得太完美了，面试官也不会相信，轻则会认为你自我认知能力不够，重则会认为你职业操守有问题。坦然面对我们过往工作经历中的一些曲折，也是一种职业品质和潇洒。

7.忌讳言谈举止非职业化。人在职场就要职业化。言谈举止不要太随意，不要用很世俗、江湖、随意的语言来介绍自己，应该用近乎书面的语言来表达。举止端庄即可，不要摇头晃脑、表情过于丰富，眼光尽量直视面试官。

如何介绍自己的职业切换？

出色的面试表现，如同锦上添花。

要添花，首先要织锦。整个面试中，如果你把5分钟自我介绍做到位了，锦就织好了，剩下的就是添花。如果这块锦没有织好，你后面所有添花都是乱插。所以5分钟自我介绍，占整个面试80%的比重。因为5分钟的自我介绍是个开放的问题，能否介绍好完全在自己。

锦织的及格线是锦没有漏洞。把锦织好的标志是添花的时候有地方添，把要添花的地方都预留和设计好了，面试官只能顺着你设计好即将添花的地方，一处一处与你交流，照着你5分钟的自我介绍来问。问一处，你添一朵花，而花你早就准备好了。等面试官把问题问完了，你的锦上添花也就完成了。

如何把锦织得没有漏洞？有一个重要的关键，就是你5分钟自我介绍时，你每一个职业节点的切换都合情、合理、合法。职业切换体现在两方面：第一，从A 单位跳到B单位，这是一种职业切换，这个切换要合情、合理、合法。第二，同一个单位之内的岗位变动和职务升迁也叫职业切换，职务的升迁变化也要合情、合理、合法。合情，是顺其自然、大家都认可接受的理由；合理，是合乎逻辑；合法，是不能违反有关政策和法律，包括企业制度。每一次职务、岗位、单位变化都符合三合，这锦就叫织好了。

反之，自我介绍完成后，如果面试官感觉到有哪怕一处不合，一定会展开质疑性追问。如果你能三两句把问题说圆了还可以；如果不能，面试官就会步步紧逼，就有可能变成10分钟以上的攻防战斗。遇到这种情况，锦一般就会被攻破，面试也就失败了。即使锦没有被攻破，如果你对面试官的质疑性追问忍耐不了，情绪失控，你同样彻底完了。就算以上两种都规避了，但时间也提前消耗完了，面试同样失败。

相关推荐：java入门教程

　　以上就是java面试该如何做好自我介绍的知识。速戳>>知识兔学习精品课！

{$}

面试时间：

2020年12月19号我在BOSS直聘上投了个人简历，由于当晚要加班，因此约了下周一晚上进行视频面试。一面过后的第二天hr打电话和我沟通了二面时间，约定下周一下午进行现场面试，二面三面一起进行。

（学习视频分享：java视频教程）

一面

{$}

（更多相关面试题推荐：java面试及答案）

二面

{$}

三面

{$}

感受

面试官都比较随和且有耐心，总体来说面试感觉比较轻松愉快；考虑到我的工作年限仅一年多，所以面试主要以基础为主，没太关注项目细节。最后问了最快入职时间和薪资要求就结束了面试，估计是凉了。

相关推荐：java入门教程

　　以上就是小米公司java面试过程分享的知识。速戳>>知识兔学习精品课！

{$}

面试官：说一下java的泛型机制是怎样的。

（学习视频分享：java视频教程）

精简版回答

Java在开发时，通过使用菱形语法< >，使一个类、接口或者方法具有接受泛指的一群类作为参数，泛指的类最终由尖括号里的规则所限定，泛指类通常用大写字母表示，一般用字母T，后期经过Java编译器编译，泛型将被擦除，根据具体使用的类，替换泛型，生成class字节码，所以泛型是对Jvm透明的。

豪华版回答

泛型于JDK1.5正式引入

Java引入泛型背景

Java集合是允许放入多种类型的,例如

List list=new ArrayList(); list.add("String"); list.add(1024);

这在JDK1.5之前是常见的使用方式，即便放在今天的JDK下，也是允许的，那么类似于这种集合的使用方式，就会带来一些问题，就是集合中究竟放了哪些类型，恐怕只有创建集合的人才知道，其他调用者，根本无法确定，这样在大型项目里，极易出现问题，调用者强转集合里的某个对象，一旦类型错误，就会报错，这种错在当时编译阶段是无法发现的，只有运行时才被发现，为了解决类似问题，JDK引入了泛型。

泛型类型

引入泛型后，从而可以在编译阶段，检查类型是否符合要求，很大程度上，杜绝了盲目的类型转换。泛型主要工作在编译器，编译后，JVM运行时，是无法感知泛型的。泛型分为普通泛型和通配泛型。

1.普通泛型

这类泛型顾名思义，就是支持调用时传入任意类型，但是调用时，等号左右俩边泛型必须一致。JDK1.7右侧菱形可以省略。

class Test<T>{...} //声明时Test<Integer> test = new Test<Integer>(); //调用时Test<Integer> test = new Test(); //1.7调用时

3.界限泛型

<?>//无界泛型，任意类型都匹配<T extends ClassA>//有界泛型 - 继承自某父类<T extends InterfaceB>//有界泛型 - 实现某接口<T extends ClassA & InterfaceB & InterfaceC ... >//有界泛型 - 多重边界<T super ClassC>//有界泛型 - 指定类父类

泛型擦除

刚才说到，泛型只在写代码时和编译时起作用，而Jvm加载class运行时是无感透明的，是因为编译器编译时将泛型擦除了，简单不严谨的说就是：把类或方法上的那个<>尖括号干掉了，根据尖括号里的规则换成具体的类，所以Jvm运行时根本不知道这段代码里之前有过泛型，这样做是为了兼容，前面说到泛型是JDK1.5才引入的，这样，即便引入泛型，现有的Jvm也不需要大改，只需要改一下编译器即可，对于这种编译器能感知的语法，而虚拟机无法感知的，人们把这种语法称作语法糖(suger)，编译器经过脱糖(Desuger) 后，拿到干货，交给虚拟机去执行。

（图文教程推荐：java入门教程）

泛型擦除机制

//Pair的泛型public class Pair<T> { private T mFirst; private T mSecond; public T getmFirst() { return mFirst; } public void setmFirst(T mFirst) { this.mFirst = mFirst; } public T getmSecond() { return mSecond; } public void setmSecond(T mSecond) { this.mSecond = mSecond; }}//Pair的原始类型//无论何时定义一个泛型类型，都会自动提供一个相应的原始类型public class Pair { private Object mFirst; private Object mSecond; public Object getFirst() { return mFirst; } public void setFirst(Object mFirst) { this.mFirst = mFirst; } public Object getSecond() { return mSecond; } public void setmSecond(Object mSecond) { this.mSecond = mSecond; }}//如果调用Pair<T extends String>编译擦除后得到如下=class Pair{ private String mFirst; private String mSecond; ...}

当泛型作为方法的入参时，擦除后换成通配泛型的下界，例如add方法

public static void insertElements(List<? super A> list){ //Add进来的都是层级“小于等于”A的，也就是下界 list.add(new A()); list.add(new B()); list.add(new C());}

当泛型作为方法的回参时，擦除后换成通配泛型的上界，例如get方法

public void processElements(List<? extends A> elements){ //for循环挨个get list 里的数据，都当做A，也就是都当做上界 for(A a : elements){ System.out.println(a.getValue()); }}

对于泛型的类型擦除说再多，看再多博客，不如官方定义准确，放一段Oracle官方对于类型擦除的文档

Type ErasureGenerics were introduced to the Java language to provide tighter type checks at compile time and to support generic programming. To implement generics, the Java compiler applies type erasure to:Replace all type parameters in generic types with their bounds or Object if the type parameters are unbounded. The produced bytecode, therefore, contains only ordinary classes, interfaces, and methods.Insert type casts if necessary to preserve type safety.Generate bridge methods to preserve polymorphism in extended generic types.Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead.

更多面试题请点击：java面试题及答案

　　以上就是说说java的泛型机制是怎样的的知识。速戳>>知识兔学习精品课！

{$}

阿里面试官问题：

谈谈你对java中的深克隆和浅克隆的理解

回答：

（说明：本文针对深克隆和浅克隆的区别和实现方式？这一问题）

Talk is cheap#

最近不止一次遇见深浅克隆（深复制，浅复制）的问题，除了印象中有个clone方法外一脸懵逼！！！克隆（复制）在Java中是一种常见的操作，目的是快速获取一个对象副本。克隆分为深克隆和浅克隆。

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

总之深浅克隆都会在堆中新分配一块区域，区别在于对象属性引用的对象是否需要进行克隆（递归性的）。

Show you my picture#

pos:当前对象的地址；

son:son属性所指向的地址；

name:对象的name属性。

{$}

（相关推荐：java入门教程）

Show you my code#

case1:

public class Son implements Serializable , Cloneable{ private String name; private Son son; public Son() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public Son getSon() { return son; } public void setSon(Son son) { this.son = son; } @Override public String toString() { return super.toString(); } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); }}

测试

public static void main(String[] args) throws Exception{// 创建父亲(LiLiu)，儿子(LiWu)，孙子（LiLiu）并关联Son father = new Son();father.setName("LiSi");Son son = new Son();son.setName("LiWu");Son grandSon = new Son();grandSon.setName("LiLiu");father.setSon(son);son.setSon(grandSon);// 调用clone方法Son fatherCopy = (Son) father.clone();boolean flag1 = fatherCopy==father;boolean flag2 = fatherCopy.getSon() == son;boolean flag3 = fatherCopy.getSon().getSon() == grandSon;// 比较克隆后的地址System.out.println(flag1);// falseSystem.out.println(flag2);// trueSystem.out.println(flag3);// true// 比较Nameflag1= fatherCopy.getName()==father.getName();flag2 = fatherCopy.getSon().getName() == son.getName();flag3 = fatherCopy.getSon().getSon().getName() == grandSon.getName();System.out.println(flag1);// trueSystem.out.println(flag2);// trueSystem.out.println(flag3);// true//将对象写到流里 ByteArrayOutputStream byteOut=new ByteArrayOutputStream(); ObjectOutputStream objOut=new ObjectOutputStream(byteOut); objOut.writeObject(father);//从流里读出来 ByteArrayInputStream byteIn=new ByteArrayInputStream(byteOut.toByteArray()); ObjectInputStream objInput=new ObjectInputStream(byteIn); fatherCopy = (Son) objInput.readObject();flag1= fatherCopy==father;flag2 = fatherCopy.getSon() == son;flag3 = fatherCopy.getSon().getSon() == grandSon;System.out.println(flag1);// falseSystem.out.println(flag2);// falseSystem.out.println(flag3);// false// 比较Nameflag1= fatherCopy.getName()==father.getName();flag2 = fatherCopy.getSon().getName() == son.getName();flag3 = fatherCopy.getSon().getSon().getName() == grandSon.getName();System.out.println(flag1);// falseSystem.out.println(flag2);// falseSystem.out.println(flag3);// false}

从上文代码及运行结果不难看出，如果对象实现Cloneable并重写clone方法不进行任何操作时,调用clone是进行的浅克隆。而使用对象流将对象写入流然后再读出是进行的深克隆。

思考：既然实现Cloneable接口并重写clone接口只能进行浅克隆。但是如果类的引用类型属性（以及属性的引用类型属性）都进行浅克隆，直到没有引用类型属性或者引用类型属性为null时，整体上就形成了深克隆。既对象的引用类型属性和属性的应用类型属性都实现Coloneable，重写clone方法并在clone方法中进行调用。

protected Object clone() throws CloneNotSupportedException { Son result = (Son) super.clone();if (son != null) {result.son = (Son) son.clone();} return result;}

个人认为，在选择深克隆方法时，应根据对象的复杂程度，如引用类型属性是否有多层引用类型属性关系。如果对象只有一层或者两层引用类型的属性，选择思考中所提到的方法较为方便，反之则使用对象流。

更多相关面试题请访问：java面试题及答案

　　以上就是谈谈你对java中的深克隆和浅克隆的理解的知识。速戳>>知识兔学习精品课！

{$}

下面是近来面试中经常被问到的10个问题，现在整理分享出来，以供参考。

1、用10分来评估你自己——你在Java方面有多好?

如果您对自己或对Java的熟练程度不太确定，那么这是一个非常棘手的问题。如果你是Java专家，你应该放低一点。在这之后，你可能会根据你所承认的水平得到问题。因此，例如，如果您说了10，但不能回答一个相当困难的问题，那么这将是一个缺点。

2、解释Java 7和Java 8的区别。

老实说，有很多不同之处。在这里，如果你能列出最重要的，就足够了。您应该解释Java 8中的新特性。有关完整列表，请访问原始网站:Java 8 JDK。

你应该知道的最重要的一点是:

Lambda表达式，一个新的语言特性，已经在这个版本中引入。Lambda表达式允许您将功能视为方法参数或代码视为数据。Lambda表达式允许您更紧凑地表达单方法接口的实例(称为函数接口)。

Method references（方法引用）为已经有名称的方法提供了易于阅读的lambda表达式。

Default methods（默认方法）允许将新功能添加到库的接口中，并确保与为这些接口的旧版本编写的代码的二进制兼容性。

Repeating annotations提供了将相同注释类型多次应用于相同声明或类型使用的能力。

Type annotations 类型注释提供了在使用类型的任何地方应用注释的能力，而不仅仅是在声明中。与可插入类型系统一起使用时，该特性支持改进的代码类型检查。

3、您知道集合类型有哪些?

在这里你应该知道最重要的一点:

ArrayList

LinkedList

HashMap

HashSet

在此之后，您可能会遇到一些问题，比如什么时候应该使用这个特定的集合类型，与其他类型相比有什么好处，它如何存储数据，以及幕后的数据结构是如何工作的。

在这里，最好的方法是尽可能多地了解这些集合类型，因为各种问题几乎是取之不尽的。

4. Object 类有哪些方法?

这是一个很常见的问题，用来确定你对基本知识的熟悉程度。这些是每个对象都有的方法:

Object类，属于java.lang包，位于类层次结构树的顶部。每个类都是对象类的直接或间接的后代。您使用或编写的每个类都继承对象的实例方法。您不需要使用任何这些方法，但是，如果您选择这样做，您可能需要使用特定于类的代码覆盖它们。

从本节讨论的Object继承的方法有:创建并返回此对象的副本。标识其他对象是否“等于”这个对象。当垃圾收集确定没有对对象的引用时，垃圾收集器在对象上调用。返回对象的运行时类。返回对象的hashcode返回对象的字符串表示形式。

Object的notify、notifyAll和wait方法都在同步程序中独立运行线程的活动中起着作用，这将在后面讨论，在这里不会讨论。

有五种方法:

5、为什么String对象在Java中是不可变的?

1、因为字符串在Java中是不可变的，才能有String pool。通过这种方式，Java运行时节省了大量Java堆空间，因为不同的字符串变量可以引用池中的相同字符串变量。如果String不是不可变的，那么String interning就不可能实现，因为如果任何变量改变了值，它就会反映在其他变量中。

（更多相关面试题推荐：java面试题及答案）

2、如果字符串不是不可变的，那么它将对应用程序造成严重的安全威胁。例如，数据库用户名和密码作为字符串传递，以获得数据库连接、套接字编程主机和作为字符串传递的端口详细信息。因为String是不可变的，所以它的值不能更改。否则，任何黑客都可能更改引用值，从而导致应用程序中的安全问题。

3、由于String是不可变的，所以它对于多线程是安全的，并且单个字符串实例可以在不同的线程之间共享。为了线程安全，避免使用同步;字符串是隐式线程安全的。

4、字符串在Java类加载器中使用，不可变性提供了正确的类被类加载器加载的安全性。例如，考虑一个您试图加载java.sql的实例。连接类，但引用的值被更改为myhacking。连接类，可以对数据库执行不需要的操作。

5、因为String是不可变的，所以它的hashcode会在创建时缓存，不需要再次计算。这使它成为映射中键的一个很好的候选对象，而且它的处理速度比其他HashMap键对象快。这就是为什么String是HashMap键最常用的对象。

6、Final、Finally和Finalize的区别是什么?

这个问题是我最喜欢的。

final 关键字在几个上下文中用于定义一个只能分配一次的实体。

Java finally块是用来执行重要代码的块，例如关闭连接、流等。无论是否处理异常，Java finally块总是被执行。Java finally块跟随try或catch块。

Finalize是 GarbageCollector（垃圾收集器）在删除/销毁对象之前调用的方法，对象有资格进行垃圾收集以执行清理活动。

7、diamond的问题是什么?

diamond问题反映了为什么不允许在Java中进行多次继承。如果有两个类具有具有特定方法的共享超类，那么它将在两个子类中被重写。然后，如果您决定从这两个子类继承，那么如果您想调用该方法，语言无法决定您想调用哪个方法

{$}

我们把这个问题称为钻石问题。它的名字来自上面的图片，它描述了警告。

8、你怎么能让一个类不可变的?

我认为这是一个相当困难的问题。你需要对你的类做一些修改，以实现不变性:

1、将类声明为final，这样它就不能扩展了。

2、使所有字段都是私有的，这样就不允许直接访问。

3、不要为变量提供setter方法

4、让所有可变字段成为final，这样它的值只能被赋值一次。

5、通过执行深度复制的构造函数初始化所有字段。

6、在getter方法中执行对象克隆，以返回副本，而不是返回实际的对象引用。

9、单例Singleton什么意思?

singleton是一个类，它只允许自己的一个实例被创建，并提供对所创建实例的访问。它包含静态变量，这些静态变量可以容纳其自身的惟一和私有实例。当用户希望将类的实例化限制为一个对象时，可以使用它。当需要单个对象来协调跨系统的操作时，这通常是有帮助的。

10、什么是依赖注入?

这是您在Java EE或Spring工作时必须知道的第一个问题。控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。容器全权负责的组件的装配，它会把符合依赖关系的对象通过JavaBean属性或者构造函数传递给需要的对象。通过JavaBean属性注射依赖关系的做法称为设值方法注入(Setter Injection)；将依赖关系作为构造函数参数传入的做法称为构造器注入（Constructor Injection）

总结

知识兔

在本文中，我们讨论了10大Java面试问题，我认为，根据我的经验，这是当今最重要的问题。如果你知道这些，我相信你在招聘过程中会有很大的优势。

如果你在这个话题上有类似的经历，或者你有一些成功的故事，请在下面的评论中分享。

相关推荐：java面试题及答案

　　以上就是介绍一下java对象的组成的知识。速戳>>知识兔学习精品课！

{$}

我们先来介绍下锁池与等待池的概念。

首先来看下锁池的概念

所有需要竞争同步锁的线程都会放在锁池当中，比如当前对象的锁已经被其中一个线程得到，则其它线程需要在这个锁池进行等待，当前面的线程释放同步锁侯锁池中的线程去竞争同步锁，当某个线程得到后会进入就绪队列进行等待cpu资源分配。

接着来看看等待池的概念

当我们调用wait() 方法后，线程会放到等待池中，等待池的线程是不会去竞争同步锁。只有调用了notify() 或notifyAll() 后等待池的线程才会开始去竞争锁，notify() 是随机从等待池选出一个线程放到锁池，而notifyAll() 是将等待池的所有线程放到锁池当中。

sleep 是 Thread 类的静态本地方法，wait 则是Object的本地方法。

sleep 方法不会释放lock，但是wait 会释放，而且会加入到等待队列中。

sleep就是把cpu的执行资格和执行权释放出去，不再运行此线程，当定时事件结束再取回cpu资源，参与cpu的调度，获取到cpu资源后就可以继续运行了，而如果sleep时该线程有锁，那么sleep不会释放这个锁，而是把锁带着进入了冻结状态，也就是说其它需要这个锁的线程根本不可能获取到这个锁。也就是说无法执行程序，如果在睡眠期间其它线程调用了这个线程的interrupt方法，那么这个线程也会抛出interruptexception异常返回，这点和wait是一样的。

sleep方法不依赖于同步器synchronized，但是wait需要依赖synchronized关键字。

sleep不需要被唤醒（休眠之后退出阻塞），但是wait需要（不指定时间需要被别人中断）。

sleep一般用于当前线程休眠，或者轮询暂停操作，wait则多用于多线程之间的通信。

sleep会让出CPU执行时间且强制上下文切换，而wait则不一定，wait后可能还是有机会重新竞争到锁继续执行的。

yield() 执行后线程直接进入就绪状态，马上释放了cpu的执行权，但是依然保留了cpu的执行资格，所以由可能cpu下次进行线程调度还会让这个线程获取到执行权继续执行。

（学习视频分享：java视频教程）

join() 执行后线程进入阻塞状态，例如在线程B中调用线程A的join() ,那线程B会进入到阻塞队列，指导线程A结束或中断线程。

public static void main(String[] args) throws InterruptedException { Thread t1=new Thread(()->{ try { Thread.sleep(4000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("休眠sleep线程"); }); t1.start(); t1.join(); System.out.println("线程执行完成"); }

原文链接：https://blog.csdn.net/lxn/article/details/

相关推荐：java面试题及答案

　　以上就是面试官：请你说一下sleep()、wait()、join()和yield()的区别的知识。速戳>>知识兔学习精品课！

{$}

前言：

果不其然，在上次的面试中面试官又问了这样的问题：请你说下final关键字的具体含义，并详细讲解它的作用以及它与static的区别。为了让正在面试中的各位重视这个问题，特意将答案整理出来以供大家参考。

1、final关键字的含义

final表面意思就是不可更改的,恒量的意思；类似于C语言中的const关键字，指的是无法改变的量，这与静态标量static是有区别的，静态变量指的是只有一份存储空间，值是可以改变的。使用final一定原因是出于软件设计的角度，因为别人看到final这个关键字就知道是什么意思，达到心领神会的效果，但也正是由于这种"语义"的存在，在程序设计中要谨慎使用，以免误用。

在Java中final修饰的就是常量，而且变量名要大写；

Math类：public static final double E = 2.;public static final double PI = 3.;......java源码中好多变量都用final修饰

2、final的作用

final根据修饰位置的不同作用也不相同，针对三种情况：

（1）修饰变量，被final修饰的变量必须要初始化，赋初值后不能再重新赋值。

注意：局部变量不在我们讨论的范畴，因为局部变量本身就有作用范围，不使用private、public等词修饰。

（2）修饰方法，被final修饰的方法代表不能重写。

（3）修饰类，被final修饰的类，不能够被继承。

注意：final修饰的类，类中的所有成员方法都被隐式地指定为final方法。

2.1、final修饰变量

被final修饰的变量必须显示的初始化，初始化可以以三种方式：1）定义时初始化，2）在构造器中设置值，3）在非静态块中为final实例变量设置值。

final修饰变量指的是：这个变量被初始化后便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可变，即不能再指向其他的对象。

public class Test01{ final int x1= ; final int x2; final int x3; { x2 = ; } Public exe3(){ this.x3 = 3000; }}

如果final修饰的变量是对象类型，那么不可更改指的是该变量不可以再指向别的对象，但是对象的值时可以更改的，比如：

final Operate operate = new Operate() ;// operate有一个普通变量i初始化为10operate.i = 11;operate.i = 12;System.out.println(operate.i); //输出12上述是自定义类，即便是数组，List等集合类型，所保存的值也是可以更改的。

3、final和static的区别

static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变，看一下网上的一个例子：

public class Test { public static void main(String[] args) { MyClass myClass1 = new MyClass(); MyClass myClass2 = new MyClass(); System.out.println(myClass1.i); System.out.println(myClass1.j); System.out.println(myClass2.i); System.out.println(myClass2.j); }}class MyClass { public final double i = Math.random(); public static double j = Math.random();}//运行结果，两次打印，j的值都是一样的，j是static类型的属于类，因此两次值相同。i不是static的因此属于对象，但是i的值是不可变的。

（学习视频分享：java视频教程）

4、其他final相关的知识

（1）使用final关键字，如果编译器能够在编译阶段确定某变量的值，那么编译器就会把该变量当做编译期常量来使用。如果需要在运行时确定，那么编译器就不会优化相关代码。

public class Test { public static void main(String[] args) { String a = "hello2"; final String b = "hello"; String d = "hello"; String c = b + 2; String e = d + 2; System.out.println((a == c)); System.out.println((a == e)); }} //final类型，在编译阶段能够确定值。 //非final类型在编译阶段确定不了输出： true false public class Test { public static void main(String[] args) { String a = "hello2"; final String b = getHello(); String c = b + 2; System.out.println((a == c)); } public static String getHello() { return "hello"; }}//即便是final类型，编译阶段也确定不了值。输出false

（2）注意不要将final与finally、finalize()等搞混。

（3）将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。

（4）接口中的变量都是public static final 的。

相关推荐：java面试题及答案

原文链接：http://www.cnblogs.com/liun1994/p/.html

原文作者：随风浪子90

　　以上就是面试官：请详细说明final关键字的作用，以及它与static的区别的知识。速戳>>知识兔学习精品课！

{$}

本文为大家整理了几道国外的java面试题，听说也难倒了不少人。下面就让我们一起来看看这些面试题，看看他们到底有趣在哪里。

1、下面Java代码的输出是什么？

public class Test { public static void main(String[] args) { method(null); } public static void method(Object o) { System.out.println("Object method"); } public static void method(String s) { System.out.println("String method"); }}

答案：

将打印“String method”。首先，null 在 Java 中不是一个对象，在 Java 中我们可以将 null 赋给任何一个引用类型。而 Java 中的字符串是 Java.lang.String 类的对象。在这里，Java 编译器会选择使用最具体的参数类型来调用重载方法。而String类型比Object更为具体，所以会调用method(String s)方法。

2、下面Java代码的输出是什么？

public class Test{ public static void main(String[] args){ Integer num1 = 100; Integer num2 = 100; if(num1 == num2){ System.out.println("num1 == num2"); } else{ System.out.println("num1 != num2"); } }}

答案：

将打印“num1 == num2”。每当使用“ == ”比较两个不同的对象引用时，值总是“false”。但是在这里，由于 Integer 缓存，num1和 num2是自动装箱的。因此num1 == num2返回“true”。同时，整数缓存只会发生在-128到127之间的值。

3、垃圾收集是如何防止Java应用程序内存不足的？

答案：

Java 垃圾收集器不能防止 Java 应用程序耗尽内存。它只是在对象超出范围且不再需要时清除未使用的内存。因此，它不能保证防止Java应用程序不耗尽内存！

（学习视频分享：java视频教程）

4、Java 是「按引用传递」还是「按值传递」

答案：

Java总是“按值传递”。然而，当我们传递一个对象的值时，我们传递对它的引用，因为变量存储对象引用，而不是对象本身。但这不是“引用传递”，这可能会让初学者感到困惑。

5、下面的代码创建了多少个String对象

public class Test{ public static void main(String[] args){ String s = new String("Hello World"); }}

答案：

创建了2个String对象。一个在堆内存中，一个在方法区中的字符串常量池中。

6、下面的代码输出是什么

public class Test{ public static void main(String[] arr){ System.out.println(0.1*3 == 0.3); System.out.println(0.1*2 == 0.2); }}

答案：

第一句print输出false，第二句print输出true。因为浮点数的误差舍入导致，只有2的幂数可以用简单的二进制表示法精确表示。不对应于2次方的数字必须四舍五入以适应有限数量的位，因此，0.1*3是不等于0.3的。

7、有没有可能在 Java 中重写或重载静态方法？

答案：

重载（overload）静态 Java 方法是可能的，但是不可能重写（override）它们。你可以在子类中编写具有相同命名的另一个静态方法，但它不会重写超类方法。它在 Java 中被称为方法隐藏。

8、测试两个double值是否相等的最可靠的方法是什么？

答案：

Double.compare(d1, d2) == 0

9、如果 try 或 catch 块执行一个 return 语句，finally 块是否会被执行？

答案：

会执行。阻止 finally 块执行的唯一方法是使用System.exit()。

10、下面的代码输出是什么

public class Test{ public static void main(String[] args){ System.out.println("main method"); } public static void main(String args){ System.out.println("Overloaded main method"); } }

答案：

会打印“main method”。不会有错误或异常，因为 main 方法可以在 Java 中重载。必须从 main 方法内部调用它才能像其他方法一样执行。

相关推荐：java面试题及答案

　　以上就是你能答对这些棘手的java面试题么的知识。速戳>>知识兔学习精品课！

是的，一个源文件中有且只能有一个public类。因为每个编译单元（文件）都只能有一个public类，即每个编译单元都有单一的公共接口，用public类来表现；该接口可以按要求包含众多的支持包访问权限的类。

{$}

本教程操作环境：windows10系统、java8、Dell G3电脑。

问题：一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

答案：可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。一个文件中可以只有非public类，如果只有一个非public类，此类可以跟文件名不同。

为什么一个java源文件中只能有一个public类？

在java编程思想（第四版）一书中有这样3段话（6.4 类的访问权限）：

1.每个编译单元（文件）都只能有一个public类，这表示，每个编译单元都有单一的公共接口，用public类来表现。该接口可以按要求包含众多的支持包访问权限的类。如果在某个编译单元内有一个以上的public类，编译器就会给出错误信息。

2.public类的名称必须完全与含有该编译单元的文件名相同，包含大小写。如果不匹配，同样将得到编译错误。

3.虽然不是很常用，但编译单元内完全不带public类也是可能的。在这种情况下，可以随意对文件命名。

当java源文件不存在public类时，会出现什么情况？

{$}

此时程序编译通过，在相应路径下产生了三个.class文件。直接点击运行，程序是不能运行的，我们需要鼠标右键点击程序----->Run As----->Java Aplication----->选数据来源

{$}

个人总结：

一个编译单元（java文件）可以存在多个类，在编译时产生多个不同的.class文件，.class文件便是程序运行的数据来源。java将public类作为每个编译单元的数据接口，只能有一个，不然不能处理存在多个类的java文件。当一个编译单元（java文件）有多个非public类时，运行时需要对数据来源进行选择。

相关视频教程推荐：Java视频教程

　　以上就是一个java源文件中必须有public类吗?的知识。速戳>>知识兔学习精品课！

在java中，可以通过“数据类型标识符;”或“数据类型标识符=初始化值;”语句来定义变量；其中标识符也叫变量名称，由数字（0~9）、大小写字母、下划线、美元符号（$）、人民币符号（¥）以及所有在十六进制0xc0前的ASCII码组成。

{$}

本教程操作环境：windows7系统、java8版、DELL G3电脑。

定义/声明变量

对开发人员来说，变量是用来描述一条信息的别名，可以在程序代码中使用一个或多个变量。变量中可以存储各种类型的信息，如登录信息、版本名称、文件的大小、某个英文单词以及飞机票价格等。

在 java 中用户可以通过指定数据类型和标识符来声明变量，其基本语法如下所示：

DataType identifier;

或者

DataType identifier=value;

上述语法代码中涉及 3 个内容：DataType、 identifier 和 value，其具体说明如下：

DataType：变量类型，如 int、string、 char 和 double 等。

identifier：标识符，也叫变量名称。

value：声明变量时的值。

变量标识符的命名规范如下：

首字符必须是字母、下划线（―）、美元符号（$）或者人民币符号（¥）。

标识符由数字（0~9）、大写字母（A~Z）、小写字母（a~z）、下划线（―）、美元符号（$）、人民币符号（¥）以及所有在十六进制 0xc0 前的 ASCII 码组成。

不能把关键字、保留字作为标识符。

标识符的长度没有限制。

标识符区分大小写。

如下代码分别声明了 String、boolean 和 int 类型的变量。

String employee; // String 类型的变量boolean isSave; // boolean 类型的变量int create_at; // int 类型的变量

相关视频教程推荐：Java视频教程

　　以上就是java如何定义变量的知识。速戳>>知识兔学习精品课！

在java中，反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。Java反射机制的主要功能：1、在运行时判断任意一个对象所属的类；2、在运行时构造任意一个类的对象；3、在运行时调用任意一个对象的方法等。

{$}

本教程操作环境：windows7系统、java8版、DELL G3电脑。

什么是反射（Reflection ）？

知识兔

主要是指程序可以访问、检测和修改它本身状态或行为的一种能力

Java反射？

知识兔

在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法

Java反射机制主要提供了以下功能：

* 1.在运行时判断任意一个对象所属的类。

* 2.在运行时构造任意一个类的对象。

* 3.在运行时判断任意一个类所具有的成员变量和方法。

* 4.在运行时调用任意一个对象的方法。

Reflectio

知识兔

Reflection是Java被视为动态（或准动态）语言的一个关键性质。

这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息。

包括其modifiers（诸如public、static等）、 superclass（例如Object）、实现了的 interfaces （例如Serializable）、也包括其fields和methods的所有信息，并可于运行时改变fields内容或调用methods。

动态语言

知识兔

动态语言的定义“程序运行时，允许改变程序结构或者变量类型，这种语言称为动态语言”。

从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。

尽管在这样的定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关机制：Reflection。这个字的意思是：反射、映像、倒影，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。

换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

这种“看透”class的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。

Java Reflection API简介

知识兔

在JDK中，主要由以下类来实现Java反射机制，这些类（除了第一个）都位于java.lang.reflect包中

Class类：代表一个类，位于java.lang包下。

Field类：代表类的成员变量（成员变量也称为类的属性）。

Method类：代表类的方法。

Constructor类：代表类的构造方法。

Array类：提供了动态创建数组，以及访问数组的元素的静态方法。

Class对象

知识兔

要想使用反射，首先需要获得待操作的类所对应的Class对象。

Java中，无论生成某个类的多少个对象，这些对象都会对应于同一个Class对象。

这个Class对象是由JVM生成的，通过它能够获悉整个类的结构。

常用的获取Class对象的3种方式：

1.使用Class类的静态方法。例如:

Class.forName(“java.lang.String”);

2.使用类的.class语法。如:

String.class;

3.使用对象的getClass()方法。如：

String str = “aa”; Class

例程1：获取方法

例程DumpMethods类演示了Reflection API的基本作用，它读取命令行参数指定的类名，然后打印这个类所具有的方法信息。

import java.lang.reflect.Method; public class DumpMethods{ public static void main(String[] args) throws Exception //在方法后加上这句，异常就消失了 { //获得字符串所标识的类的class对象 Class<?> classType = Class.forName("java.lang.String");//在此处传入字符串指定类名，所以参数获取可以是一个运行期的行为，可以用args[0] //返回class对象所对应的类或接口中，所声明的所有方法的数组（包括私有方法） Method[] methods = classType.getDeclaredMethods(); //遍历输出所有方法声明 for(Method method : methods) { System.out.println(method); } } }

例程2：通过反射调用方法

通过反射调用方法。详情见代码及注释：

import java.lang.reflect.Method; public class InvokeTester{ public int add(int param1, int param2) { return param1 + param2; } public String echo(String message) { return "Hello: " + message; } public static void main(String[] args) throws Exception { // 以前的常规执行手段 InvokeTester tester = new InvokeTester(); System.out.println(tester.add(1, 2)); System.out.println(tester.echo("Tom")); System.out.println("---------------------------"); // 通过反射的方式 // 第一步，获取Class对象 // 前面用的方法是：Class.forName()方法获取 // 这里用第二种方法，类名.class Class<?> classType = InvokeTester.class; // 生成新的对象：用newInstance()方法 Object invokeTester = classType.newInstance(); System.out.println(invokeTester instanceof InvokeTester); // 输出true // 通过反射调用方法 // 首先需要获得与该方法对应的Method对象 Method addMethod = classType.getMethod("add", new Class[] { int.class, int.class }); // 第一个参数是方法名，第二个参数是这个方法所需要的参数的Class对象的数组 // 调用目标方法 Object result = addMethod.invoke(invokeTester, new Object[] { 1, 2 }); System.out.println(result); // 此时result是Integer类型 //调用第二个方法 Method echoMethod = classType.getDeclaredMethod("echo", new Class[]{String.class}); Object result2 = echoMethod.invoke(invokeTester, new Object[]{"Tom"}); System.out.println(result2); }}

生成对象

知识兔

若想通过类的不带参数的构造方法来生成对象，我们有两种方式：

1.先获得Class对象，然后通过该Class对象的newInstance()方法直接生成即可：

Class<?> classType = String.class; Object obj = classType.newInstance();

2.先获得Class对象，然后通过该对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()方法生成

（其中Customer是一个自定义的类，有一个无参数的构造方法，也有带参数的构造方法）：

Class<?> classType = Customer.class; // 获得Constructor对象,此处获取第一个无参数的构造方法的 Constructor cons = classType.getConstructor(new Class[] {}); // 通过构造方法来生成一个对象 Object obj = cons.newInstance(new Object[] {});

若想通过类的带参数的构造方法生成对象，只能使用下面这一种方式：

（Customer为一个自定义的类，有无参数的构造方法，也有一个带参数的构造方法，传入字符串和整型）

Class<?> classType = Customer.class; Constructor cons2 = classType.getConstructor(new Class[] {String.class, int.class}); Object obj2 = cons2.newInstance(new Object[] {"ZhangSan",20});

可以看出调用构造方法生成对象的方法和调用一般方法的类似，不同的是从Class对象获取Constructor对象时不需要指定名字，而获取Method对象时需要指定名字。

相关视频教程推荐：Java视频教程

　　以上就是java里什么是反射的知识。速戳>>知识兔学习精品课！

在java中，多态是同一个行为具有多个不同表现形式或形态的能力；多态就是同一个接口，使用不同的实例而执行不同操作。多态的优点：1、消除类型之间的耦合关系；2、可替换性；3、可扩充性；4、接口性；5、灵活性；6、简化性。

{$}

本教程操作环境：windows7系统、java8版、DELL G3电脑。

多态概述

知识兔

1、多态是继封装、继承之后，面向对象的第三大特性。

2、多态现实意义理解：

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

3、多态体现为父类引用变量可以指向子类对象。

4、前提条件：必须有子父类关系。

注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

5、多态的定义与使用格式

定义格式：

6、理解:

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。

7、多态的优点

消除类型之间的耦合关系

可替换性

可扩充性

接口性

灵活性

简化性

8、多态存在的三个必要条件

继承

重写

父类引用指向子类对象：

多态中成员的特点

知识兔

1、多态成员变量：编译运行看左边

Fu f=new Zi();System.out.println(f.num);//f是Fu中的值，只能取到父中的值

2、多态成员方法：编译看左边，运行看右边

Fu f1=new Zi();System.out.println(f1.show());//f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。

instanceof关键字

知识兔

作用：用来判断某个对象是否属于某种数据类型。

注意：返回类型为布尔类型

使用案例：

Fu f1=new Zi(); Fu f2=new Son(); if(f1 instanceof Zi){ System.out.println("f1是Zi的类型"); } else{ System.out.println("f1是Son的类型"); }

多态的转型

知识兔多态的转型分为向上转型和向下转型两种向上转型：多态本身就是向上转型过的过程

使用格式：父类类型变量名=new 子类类型();

适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型

使用格式：子类类型变量名=（子类类型）父类类型的变量；

适用场景：当要使用子类特有功能时。

多态案例：

知识兔

例1：（理解多态，可以重点看这个案例）

package day0524;public class demo04 { public static void main(String[] args) { People p=new Stu(); p.eat(); //调用特有的方法 Stu s=(Stu)p; s.study(); //((Stu) p).study(); }}class People{ public void eat(){ System.out.println("吃饭"); }}class Stu extends People{ @Override public void eat(){ System.out.println("吃水煮肉片"); } public void study(){ System.out.println("好好学习"); }}class Teachers extends People{ @Override public void eat(){ System.out.println("吃樱桃"); } public void teach(){ System.out.println("认真授课"); }}

例2：

请问题目运行结果是什么？

package day0524;public class demo1 { public static void main(String[] args) { A a=new A(); a.show(); B b=new B(); b.show(); }}class A{ public void show(){ show2(); } public void show2(){ System.out.println("A"); }}class B extends A{ public void show2(){ System.out.println("B"); }}class C extends B{ public void show(){ super.show(); } public void show2(){ System.out.println("C"); }}

答案：A B

相关视频教程推荐：Java视频教程

　　以上就是java多态如何理解的知识。速戳>>知识兔学习精品课！

Java的基本数据类型有8种，分别是：byte（位）、short（短整数）、int（整数）、long（长整数）、float（单精度）、double（双精度）、char（字符）和boolean（布尔值）。

{$}

本教程操作环境：windows7系统、java10版、DELL G3电脑。

关于Java的8种基本数据类型，其名称、位数、默认值、取值范围及示例如下表所示：

{$}

为了验证表格里的内容，在eclipse里运行验证代码如下：

package com.ce.test;

class Test {

static byte b;

static short s;

static int i;

static long l;

static float f;

static double d;

static char c;

static boolean bo;

public static void main(String[] args) {

System.out.println("byte的大小："+Byte.SIZE

+";默认值："+b

+";数据范围："+Byte.MIN_VALUE+" - "+Byte.MAX_VALUE);

System.out.println("short的大小："+Short.SIZE

+";默认值："+s

+";数据范围："+Short.MIN_VALUE+" - "+Short.MAX_VALUE);

System.out.println("int的大小："+Integer.SIZE

+";默认值："+i

+";数据范围："+Integer.MIN_VALUE+" - "+Integer.MAX_VALUE);

System.out.println("long的大小："+Long.SIZE

+";默认值："+l

+";数据范围："+Long.MIN_VALUE+" - "+Long.MAX_VALUE);

System.out.println("float的大小："+Float.SIZE

+";默认值："+f

+";数据范围："+Float.MIN_VALUE+" - "+Float.MAX_VALUE);

System.out.println("double的大小："+Double.SIZE

+";默认值："+d

+";数据范围："+Double.MIN_VALUE+" - "+Double.MAX_VALUE);

System.out.println("char的大小："+Character.SIZE

+";默认值："+c

+";数据范围："+Character.MIN_VALUE+" - "+Character.MAX_VALUE);

System.out.println("boolean的大小："+Byte.SIZE

+";默认值："+bo

+";数据范围："+Byte.MIN_VALUE+" - "+Byte.MAX_VALUE);

}

在控制台输出结果如下图所示：

{$}

此处为什么输出char的数据范围不是0 - 呢？

Java中的char类型由两个字节即十六位来表示，因为是无符号数，所以为2的16次方，数值范围就为：0 - 2^16-1；

相关视频教程推荐：Java视频教程

以上就是java基本数据类型有哪些的知识。速戳>>知识兔学习精品课！

java数据结构有：1、数组；2、链表，一种递归的数据结构；3、栈，按照“后进先出”、“先进后出”的原则来存储数据；4、队列；5、树，是由 n（n>0）个有限节点组成的一个具有层次关系的集合；6、堆；7、图；8、哈希表。

{$}

本教程操作环境：windows7系统、java8版、DELL G3电脑。

Java常见数据结构

{$}

这 8 种数据结构有什么区别呢？

①、数组

优点：

按照索引查询元素的速度很快；

按照索引遍历数组也很方便。

缺点：

数组的大小在创建后就确定了，无法扩容；

数组只能存储一种类型的数据；

添加、删除元素的操作很耗时间，因为要移动其他元素。

②、链表

《算法（第 4 版）》一书中是这样定义链表的：

链表是一种递归的数据结构，它或者为空（null），或者是指向一个结点（node）的引用，该节点还有一个元素和一个指向另一条链表的引用。

Java 的 LinkedList 类可以很形象地通过代码的形式来表示一个链表的结构：

public class LinkedList<E> { transient Node<E> first; transient Node<E> last; private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }}

这是一种双向链表，当前元素 item 既有 prev 又有 next，不过 first 的 prev 为 null，last 的 next 为 null。如果是单向链表的话，就只有 next，没有 prev。

{$}

由于不必按照顺序的方式存储，链表在插入、删除的时候可以达到 O(1) 的时间复杂度（只需要重新指向引用即可，不需要像数组那样移动其他元素）。除此之外，链表还克服了数组必须预先知道数据大小的缺点，从而可以实现灵活的内存动态管理。

优点：

不需要初始化容量；

可以添加任意元素；

插入和删除的时候只需要更新引用。

缺点：

含有大量的引用，占用的内存空间大；

查找元素需要遍历整个链表，耗时。

③、栈

栈就好像水桶一样，底部是密封的，顶部是开口，水可以进可以出。用过水桶的小伙伴应该明白这样一个道理：先进去的水在桶的底部，后进去的水在桶的顶部；后进去的水先被倒出来，先进去的水后被倒出来。

同理，栈按照“后进先出”、“先进后出”的原则来存储数据，先插入的数据被压入栈底，后插入的数据在栈顶，读出数据的时候，从栈顶开始依次读出。

{$}

④、队列

队列就好像一段水管一样，两端都是开口的，水从一端进去，然后从另外一端出来。先进去的水先出来，后进去的水后出来。

和水管有些不同的是，队列会对两端进行定义，一端叫队头，另外一端就叫队尾。队头只允许删除操作（出队），队尾只允许插入操作（入队）。

{$}

⑤、树

树是一种典型的非线性结构，它是由 n（n>0）个有限节点组成的一个具有层次关系的集合。

{$}

之所以叫“树”，是因为这种数据结构看起来就像是一个倒挂的树，只不过根在上，叶在下。树形数据结构有以下这些特点：

每个节点都只有有限个子节点或无子节点；

没有父节点的节点称为根节点；

每一个非根节点有且只有一个父节点；

除了根节点外，每个子节点可以分为多个不相交的子树。

下图展示了树的一些术语：

{$}

基于二叉查找树的特点，它相比较于其他数据结构的优势就在于查找、插入的时间复杂度较低，为 O(logn)。假如我们要从上图中查找 5 个元素，先从根节点 7 开始找，5 必定在 7 的左侧，找到 4，那 5 必定在 4 的右侧，找到 6，那 5 必定在 6 的左侧，找到了。

理想情况下，通过 BST 查找节点，所需要检查的节点数可以减半。

平衡二叉树：当且仅当任何节点的两棵子树的高度差不大于 1 的二叉树。由前苏联的数学家 Adelse-Velskil 和 Landis 在 1962 年提出的高度平衡的二叉树，根据科学家的英文名也称为 AVL 树。

平衡二叉树本质上也是一颗二叉查找树，不过为了限制左右子树的高度差，避免出现倾斜树等偏向于线性结构演化的情况，所以对二叉搜索树中每个节点的左右子树作了限制，左右子树的高度差称之为平衡因子，树中每个节点的平衡因子绝对值不大于 1。

平衡二叉树的难点在于，当删除或者增加节点的情况下，如何通过左旋或者右旋的方式来保持左右平衡。

Java 中最常见的平衡二叉树就是红黑树，节点是红色或者黑色，通过颜色的约束来维持着二叉树的平衡：

1）每个节点都只能是红色或者黑色

2）根节点是黑色

3）每个叶节点（NIL 节点，空节点）是黑色的。

4）如果一个节点是红色的，则它两个子节点都是黑色的。也就是说在一条路径上不能出现相邻的两个红色节点。

5）从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

{$}

⑥、堆

堆可以被看做是一棵树的数组对象，具有以下特点：

堆中某个节点的值总是不大于或不小于其父节点的值；

堆总是一棵完全二叉树。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

{$}

在线性结构中，数据元素之间满足唯一的线性关系，每个数据元素（除第一个和最后一个外）均有唯一的“前驱”和“后继”；

在树形结构中，数据元素之间有着明显的层次关系，并且每个数据元素只与上一层中的一个元素（父节点）及下一层的多个元素（子节点）相关；

而在图形结构中，节点之间的关系是任意的，图中任意两个数据元素之间都有可能相关。

⑧、哈希表

哈希表（Hash Table），也叫散列表，是一种可以通过关键码值（key-value）直接访问的数据结构，它最大的特点就是可以快速实现查找、插入和删除。

数组的最大特点就是查找容易，插入和删除困难；而链表正好相反，查找困难，而插入和删除容易。哈希表很完美地结合了两者的优点， Java 的 HashMap 在此基础上还加入了树的优点。

{$}

哈希函数在哈希表中起着⾮常关键的作⽤，它可以把任意长度的输入变换成固定长度的输出，该输出就是哈希值。哈希函数使得一个数据序列的访问过程变得更加迅速有效，通过哈希函数，数据元素能够被很快的进行定位。

若关键字为 k，则其值存放在的存储位置上。由此，不需要遍历就可以直接取得 k 对应的值。

对于任意两个不同的数据块，其哈希值相同的可能性极小，也就是说，对于一个给定的数据块，找到和它哈希值相同的数据块极为困难。再者，对于一个数据块，哪怕只改动它的一个比特位，其哈希值的改动也会非常的大——这正是 Hash 存在的价值！

尽管可能性极小，但仍然会发生，如果哈希冲突了，Java 的 HashMap 会在数组的同一个位置上增加链表，如果链表的长度大于 8，将会转化成红黑树进行处理——这就是所谓的拉链法（数组+链表）。

更多编程相关知识，请访问：编程视频！！

　　以上就是java常用数据结构有哪些的知识。速戳>>知识兔学习精品课！

方法：1、在桌面中新建一个包含程序代码的java文件；2、打开cmd，执行“cd Desktop”命令进入桌面；3、执行“Java 文件名.java”命令进行编译；4、执行“java 文件名”命令即可运行java程序。

{$}

本教程操作环境：windows7系统、java10版、DELL G3电脑。

要运行java程序，我们必须先写一个java程序，由于这里说的仅仅是java程序的运行，所以我就已一个简单的程序来入手了哦！

1、打开自己的记事本，录入下面的代码：

import java.util.*;public class HelloWorld{ public static void main(String[] args){ System.out.println("HelloWorld"); }}

{$}

选择文件---->另存为

文件名称：HelloWorld.java

文件类型：所有文件

【在这里要记住自己文件的保存位置哦】

{$}

为了方便起见，我将自己的第一个java程序保存在了桌面。

2、打开附件--->命令提示符

键入【cd Desktop】按下【回车键】

【这步是为了进入桌面，也就是你保存文件的位置】

{$}

3、键入【javac HelloWorld.java】

【这步是编译自己的java程序】

{$}

4、键入【java HelloWorld】

【这步是为了运行自己的java程序】

然后就能看到运行结果了！

{$}

相关推荐：java入门教程

　　以上就是java向mysql数据库批量插入大量数据的知识。速戳>>知识兔学习精品课！

{$}

区别对比如下：

我们知道Java中的线程是通过Java.lang.Thread来实现的，那么我们就可以通过实例化Thread一个对象来创建一个线程，然后再调用start()启动，但是Thread的一个特定的方法run()也可以启动线程，那么这两个方法有什么区别呢？

线程状态

在Java当中，线程通常有五种状态：创建、运行、阻塞、等待、终止NEW------------------->新建状态，没有调用start()之前的状态RUNNABLE---------->运行状态，（running执行中，ready就绪（等待cpu时间片））BLOCKED------------>阻塞状态，WAITING-------------->等待状态，没有明确的等待结束时间，调用wait()TIMED_WAITING—>超时等待状态，有明确的等待时间，如：sleep（xxx）TERMINATED-------->终止状态

多线程原理：

我们一般使用thread new一个线程，然后调用start方法启动，线程就会处于运行状态中ready，等待CPU调度，然后再执行线程里面的run()方法，使用start方法才真正实现了多线程运行，因为这个时候不用等待我们的run方法执行完成就可以继续执行下面的代码，这才叫多线程。

如果直接使用thread执行run方法会怎么样呢？

因为run方法是thread里面的一个普通的方法，如果直接调用run()方法，这个时候它会运行在主线程中的，因为程序中只有主线程一个线程，如果有两个线程，都是直接调用run()方法，那么他们的执行顺序一定是按顺序执行的，并没有实现多线程的目的。

免费学习视频分享：java视频教程

代码对比

public class ThreadDemo5 { public static final boolean flag=false; public static void main(String[] args) { Thread t1=new Thread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); } }); t1.start(); }}

调用start()方法，线程名是默认的

{$}

调用run()，线程名是main

{$}

相关推荐：java入门教程

　　以上就是java线程中start方法与run方法的区别是什么的知识。速戳>>知识兔学习精品课！

本篇文章给大家介绍一下编码规范与静态代码检查插件的使用方法。有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。

{$}

Alibaba Java Coding Guidelines

首先介绍的是阿里巴巴的编码规约，相信大家对这个都比较熟悉了。安装方式是在

settings->plugins里面搜索Alibaba Java Coding Guidelines->install->重启Idea

这个插件侧重于代码的缺陷，详细的编码规范在《阿里开发手册》已经定义，大家有兴趣的可以看看。

如果要检查整个项目所有文件的话，可以关闭窗口中的类，然后按快捷键，或者如下图操作也是可以的。

{$}

检查的结果如图所示：

{$}

如果要对单个的文件进行检查的话，可以在类上右键，选中Alibaba Coding Guidelines Analyze

CheckStyle

知识兔

第二个要介绍的插件是CheckStyle插件。这个插件侧重于代码的格式检查。使用方式如下图：在checkstyle面板，点击检查按钮进行检查，也可以检查单个文件。

{$}{$}

如上图，可以看到都是一些缩进啥的编码规范，可以不用太关注。

Findbugs

知识兔

findBugs-idea的作用侧重于发现代码中可能存在的bug。它检查类或者JAR 文件，将字节码与一组缺陷模式（自带检测器）进行对比以发现可能的问题。执行Findbugs编码规约扫描PMD

(Programming Mistake Detector) 是一个开源的静态代码检查工具。PMD 支持多种语言，比如项目本身的 Java，Salesforce 相关的 Apex、VisualForce，还有 JavaScript、XML 等。PMD 对于各种语言都预设了一套代码规则，也支持开发自定义规则，可以使用 Java 类或者XPath。

选中一段代码，然后右键,这里有许多检查类型可以选择，有代码样式，设计等等。

{$}

SonarLint

知识兔

最后要介绍的是SonarLint插件，这个插件和Alibaba Java Coding Guidelines插件是实际项目中用到的比较多的两个插件。下面就详细介绍一下插件的安装和使用。

安装

settings->plugins里面搜索SonarLint>install->重启Idea

配置SonnarLint 检查地址：

settings->Tools->SonarLint->Settings 中增加sonarqube的地址

如下图配置了sonarqube的地址

{$}

使用SonarList

配置好SonarList之后，就是使用了，SonarLint既可以对所有文件进行检查，检查全部文件的方式是：点击。

{$}

又可以单个文件检查，单个文件就是在文件编辑区右键选中：

{$}

生成的报告如下：这里既有违规的问题(即潜在的Bugs & Vulnerabilities)。比如：NullPointerException，又有代码的坏味道（Code Smells）。一般而言Bug级别的问题需要我们处理，坏味道可以忽略。还有另外一个指标就是代码的重复率，即代码内部的重复代码。

{$}

各类插件的比较

检查侧重点不同工具分析对象侧重应用技术Alibaba Java Coding Guidelines源代码代码缺陷Inspection机制提供实时检测功能CheckStyle源文件格式缺陷缺陷模式匹配FindBugs字节码代码缺陷缺陷模式匹配，数据流分析PMD源代码代码缺陷缺陷模式匹配SonarList源代码代码缺陷缺陷模式匹配，多个维度处理

检查项不同工具目的检查项Alibaba Java Coding Guidelines扫描出所有潜在的代码隐患方法名参数名成员变量局部变量枚举类 try-catchCheckStyle检查Java源文件是否与代码规范相符Javadoc注释命名规范标题import语句体积大小空白FindBugs基于Bug Patterns 概念，查找javabytecode（.class文件）中的潜在bugNullPoint空指针检查，没有不合理关闭资源PMD检查Java源文件潜在问题未使用的本地变量空的catch块，未使用参数空 if语句，重复的import语句，未使用的私有方法可能是Singleton的类短/长变量及方法名字SonarList扫描出所有潜在的代码隐患方法名参数名成员变量局部变量枚举类 try-catch

相关免费学习推荐：java基础教程

　　以上就是如何使用编码规范与静态代码检查插件的知识。速戳>>知识兔学习精品课！

phpstudy 2016是目前网络上最优秀的一款php环境集成包，该集成包内内含Apache+Nginx+LightTPD+PHP+MySQL+phpMyAdmin+Zend Optimizer+Zend Loader，可以一次性安装，无须配置即可使用，是非常方便、好用的PHP调试环境。phpstudy 2016目前支持26种组合一键切换，php扩展管理超级方便，支持mysql备份还原导入导出，并且程序绿色小巧简易迷你仅有35M，有专门的控制面板，帮助用户可以更好的配置php环境。

phpstudy下载链接地址：images/2021/06/19/.html

{$}

对学习PHP的新手来说，WINDOWS下环境配置是一件很困难的事;对老手来说也是一件烦琐的事。因此无论你是新手还是老手，该程序包都是一个不错的选择。

注意事项：

1. 为了减少出错安装路径不得有汉字，如有防火墙开启，会提示是否信任httpd、mysqld运行，请选择全部允许。

2. 此为apache+php方案，需要Nginx+php方案的请到www.phpStudy.net下载phpfind，Lighttpd+PHP方案下载phpLight。

3. 重装系统后或相关服务丢失时，只需要点一下『运行模式-应用』即可。

4. 可通过菜单『卸载相关服务』进行卸载相关服务。

5. 在『启动』、『停止』、『重启』三个启停按钮上右键可以有选择地进行启停，左键将控制全部的启停。

6. 菜单『phpStudy 设置』可以进行php,apche,mysql的相关设置。菜单『站点域名设置』可以进行站点及域名的添加。

7. 本程序分为安装版和非安装版，无论是安装还是免安装，最后的效果完全一致。

8. 端口问题无法启动时，请使用菜单『强制启动端口』进行端口检测，尝试启动。

系统服务和非服务启动的区别：

系统服务启动：开机就会启动，适合经常使用或做服务器，无需手工启动，服务会随开机而启动，好处程序运行稳定。

非服务启动：需要手动启动一下，适合偶尔经常使用一下。在不使用的情况不会启动相关进程，从而节省电脑的资源。

　　以上就是下载安装phpstudy2016的知识。速戳>>知识兔学习精品课！

本文主要和大家分享phpstudy本地配置域名访问的方法，希望能帮助到大家。

{$}

一. hosts配置：

1.用编辑器打开hosts文件，位置：C:WindowsSystem32driversetc目录下

示例：

在hosts文件的最后添加如下代码：

127.0.0.1 www.tp5.com

{$}

二. apache配置：

1.编辑httpd.conf文件，开启虚拟主机，位置：在apache的安装目录，即phpstudy安装目录下的phpStudyApacheconf，找到Includeconf/extra/httpd-vhosts.conf，去掉前面的#

{$}

2. 进入开启的虚拟主机文件httpd-vhosts.conf进行域名配置，位置：phpStudyApacheconfextra目录下

配置规则：

<VirtualHost *:80> 该邮件地址已受到反垃圾邮件插件保护。要显示它需要在浏览器中启用 JavaScript。 DocumentRoot"D:/phpStudy/WWW/要配置域名的项目名" ServerName 配置的域名 ErrorLog"logs/dummy-host2.example.com-error.log" CustomLog"logs/dummy-host2.example.com-access.log" common</VirtualHost>

{$}

若想在Apache的配置中隐藏入口文件index.php，即使访问地址：localhost/h5.test.cn/index.php/test/index 简化成 localhost/h5.test.cn/test/index，也可以通过域名配置实现，即如下：

<VirtualHost *:80> DocumentRoot"D:/phpStudy/WWW/h5.test.cn" ServerNamelocal.h5.test.cn<IfModuledir_module>DirectoryIndexindex.php </IfModule></VirtualHost>

以上配置都完成后，切记要重启服务器。

注意：这个时候出现一个问题，就是用localhost访问本地其他项目就出现访问不了，这么多项目，不想每个都去配置一个虚拟域名，既能域名访问，又能localhost就好了，在网上找到了解决办法：

用上面的方法添加一个名为localhost的域名绑定到www目录，然后在httpd.conf文件中注释掉ServerName localhost这一行，重启apache，就都可以访问了。

Goland 2020最新激活码-Golang

goland 激活_激活码大全

【GoLand教程】GoLand 启用版本控制

GoLand 2023.2.1中文破解版最新激活可用完美兼容M1

GoLand 2023：为Go开发者打造的智能IDE mac／win版

goland2022激活码，可以激活全部goland版本

GoLand 2022 for Mac(最好用的GO语言编程软件)v2022.1.3中文激活版

激活Golang

关于在deepin安装goland开发工具以及go环境配置问题

goland2019.2破解方法

Goland利器：使用Goland自带的test工具来编写有效的测试文件

mac os安装GO语言编程软件GoLand 2022 for Mac中文激活版

免费goland服务器激活地址

goland2021.3版本激活【mac版】激活到5000年！

Go 开发IDE全览：GoLand VS VSCode全面解析

Goland最新版激活成功，可以写代码了

使用goland搭建helloworld项目

GoLand激活工具

GoLand 2022.01.4激活码(JetBrains全家桶)

搭建 PyCharm GoLand 激活服务器

golang激活码

Goland 2020最新激活码-Golang

goland 激活_激活码大全

【GoLand教程】GoLand 启用版本控制

GoLand 2023.2.1中文破解版 最新激活可用 完美兼容M1

GoLand 2023：为Go开发者打造的智能IDE mac／win版

goland2022激活码，可以激活全部goland版本

GoLand 2022 for Mac(最好用的GO语言编程软件)v2022.1.3中文激活版

激活Golang

关于在deepin安装goland开发工具以及go环境配置问题

goland2019.2破解方法

Goland利器：使用Goland自带的test工具来编写有效的测试文件

mac os安装GO语言编程软件GoLand 2022 for Mac中文激活版

免费goland服务器激活地址

goland2021.3版本激活【mac版】激活到5000年！

Go 开发IDE全览：GoLand VS VSCode全面解析

Goland最新版激活成功，可以写代码了

使用goland搭建helloworld项目

GoLand激活工具

GoLand 2022.01.4激活码(JetBrains全家桶)

搭建 PyCharm GoLand 激活服务器

golang激活码

GoLand 2023.2.1中文破解版最新激活可用完美兼容M1