... 文件切片下载 @ClassName DownLoadController @Author 康世行 @Date 20:58 2023/2/22 @Version 1.0/@Controller@Slf4jpublic class DownLoadController {private final static String utf8 = "utf-8";@RequestMapping("/down")public void downLoadFile(HttpServletRequest request, HttpServletResponse response) throws IOException {// 设置编码格式response.setCharacterEncoding(utf8);//获取文件路径String fileName=request.getParameter("fileName");String drive=request.getParameter("drive");//参数校验log.info(fileName,drive);//完整路径(路径拼接待优化-前端传输优化-后端从新格式化 )String pathAll=drive+":\\"+fileName;log.info("pathAll{}",pathAll);Optional<String> pathFlag = Optional.ofNullable(pathAll);File file=null;if (pathFlag.isPresent()){//根据文件名，读取file流file = new File(pathAll);log.info("文件路径是{}",pathAll);if (!file.exists()){log.warn("文件不存在");return;} }else {//请输入文件名log.warn("请输入文件名！");return;}InputStream is = null;OutputStream os = null;try {//分片下载long fSize = file.length();//获取长度response.setContentType("application/x-download");String file_Name = URLEncoder.encode(file.getName(),"UTF-8");response.addHeader("Content-Disposition","attachment;filename="+fileName);//根据前端传来的Range 判断支不支持分片下载response.setHeader("Accept-Range","bytes");//获取文件大小//response.setHeader("fSize",String.valueOf(fSize));response.setHeader("fName",file_Name);//定义断点long pos = 0,last = fSize-1,sum = 0;//判断前端需不需要分片下载if (null != request.getHeader("Range")){response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);String numRange = request.getHeader("Range").replaceAll("bytes=","");String[] strRange = numRange.split("-");if (strRange.length == 2){pos = Long.parseLong(strRange[0].trim());last = Long.parseLong(strRange[1].trim());//若结束字节超出文件大小取文件大小if (last>fSize-1){last = fSize-1;} }else {//若只给一个长度开始位置一直到结束pos = Long.parseLong(numRange.replaceAll("-","").trim());} }long rangeLenght = last-pos+1;String contentRange = new StringBuffer("bytes").append(pos).append("-").append(last).append("/").append(fSize).toString();response.setHeader("Content-Range",contentRange);// response.setHeader("Content-Lenght",String.valueOf(rangeLenght));os = new BufferedOutputStream(response.getOutputStream());is = new BufferedInputStream(new FileInputStream(file));is.skip(pos);//跳过已读的文件(重点，跳过之前已经读过的文件)byte[] buffer = new byte[1024];int lenght = 0;//相等证明读完while (sum < rangeLenght){lenght = is.read(buffer,0, (rangeLenght-sum)<=buffer.length? (int) (rangeLenght - sum) :buffer.length);sum = sum+lenght;os.write(buffer,0,lenght);}log.info("下载完成");}finally {if (is!= null){is.close();}if (os!=null){os.close();} }} } 启动成功 Vue <html xmlns:th="http://www.thymeleaf.org"><head><meta charset="utf-8"/><title>狂神说Java-ES仿京东实战</title><link rel="stylesheet" th:href="@{/css/style.css}"/></head><body class="pg"><div class="page" id="app"><div id="mallPage" class=" mallist tmall- page-not-market "><div id="header" class=" header-list-app"><div class="headerLayout"><div class="headerCon "><h1 id="mallLogo"><img th:src="@{/images/jdlogo.png}" alt=""></h1><div class="header-extra"><div id="mallSearch" class="mall-search"><form name="searchTop" class="mallSearch-form clearfix"><fieldset><legend>天猫搜索</legend><div class="mallSearch-input clearfix"><div class="s-combobox" id="s-combobox-685"><div class="s-combobox-input-wrap"><input v-model="keyword" type="text" autocomplete="off" value="java" id="mq"class="s-combobox-input" aria-haspopup="true"></div></div><button type="submit" @click.prevent="searchKey" id="searchbtn">搜索</button></div></fieldset></form><ul class="relKeyTop"><li><a>狂神说Java</a></li><li><a>狂神说前端</a></li><li><a>狂神说Linux</a></li><li><a>狂神说大数据</a></li><li><a>狂神聊理财</a></li></ul></div></div></div></div></div><el-button @click="download" id="download">下载</el-button><el-button @click="stop">停止</el-button><el-button @click="start">开始</el-button>{ {fileFinalOffset} }{ {contentList} }<el-progress type="circle" :percentage="percentage"></el-progress></div><script th:src="@{/js/axios.min.js}"></script><script th:src="@{/js/vue.min.js}"></script><link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css"><script src="https://unpkg.com/element-ui/lib/index.js"></script><script>new Vue({ el: 'app',data: {keyword: '', //搜索关键字results: [] ,//搜索结果percentage: 0, // 下载进度filesCurrentPage:0,//文件开始偏移量fileFinalOffset:0, //文件最后偏移量stopRecursiveTags:true, //停止递归标签，默认是true 继续进行递归contentList: [], // 文件流数组breakpointResumeTags:false, //断点续传标签，默认是false 不进行断点续传temp:[],fileMap:new Map(),timer:null, //定时器名称},methods: {//根据关键字搜索商品信息searchKey(){var keyword=this.keyword;axios.get('/search/JD/search/'+keyword+"/1/10").then(res=>{this.results=res.data;//绑定数据console.log(this.results)console.table(this.results)})},//停止下载stop(){//改变递归标签为falsethis.stopRecursiveTags=false;},//开始下载start(){//重置递归标签为true 最后进行合并this.stopRecursiveTags=true;//重置断点续传标签this.breakpointResumeTags=true;//重新调用下载方法this.download();},// 分段下载需要后端配合download() {// 下载地址const url = "/down?fileName="+this.keyword.trim()+"&drive=E";console.log(url)const chunkSize = 1024 1024 50; // 单个分段大小，这里测试用100Mlet filesTotalSize = chunkSize; // 安装包总大小，默认100Mlet filesPages = 1; // 总共分几段下载//计算百分比之前先清空上次的if(this.percentage==100){this.percentage=0;}let sentAxios = (num) => {let rande = chunkSize;//判断是否开启了断点续传(断点续传没法并行-需要上次请求的结果作为参数)if (this.breakpointResumeTags){rande = ${Number(this.fileFinalOffset)+1}-${num chunkSize + 1};}else {if (num) {rande = ${(num - 1) chunkSize + 2}-${num chunkSize + 1};} else {// 第一次0-1方便获取总数，计算下载进度，每段下载字节范围区间rande = "0-1";} }let headers = {range: rande,};axios({method: "get",url: url.trim(),async: true,data: {},headers: headers,responseType: "blob"}).then((response) => {if (response.status == 200 || response.status == 206) {//检查了下才发现，后端对文件流做了一层封装，所以将content指向response.data即可const content = response.data;//截取文件总长度和最后偏移量let result= response.headers["content-range"].split("/");// 获取文件总大小，方便计算下载百分比filesTotalSize =result[1];//获取最后一片文件位置，用于断点续传this.fileFinalOffset=result[0].split("-")[1]// 计算总共页数，向上取整filesPages = Math.ceil(filesTotalSize / chunkSize);// 文件流数组this.contentList.push(content);// 递归获取文件数据(判断是否要继续递归)if (this.filesCurrentPage < filesPages&&this.stopRecursiveTags==true) {this.filesCurrentPage++;//计算下载百分比当前下载的片数/总片数this.percentage=Number((this.contentList.length/filesPages)100).toFixed(2);sentAxios(this.filesCurrentPage);//结束递归return;}//递归标签为true 才进行下载if (this.stopRecursiveTags){// 文件名称const fileName =decodeURIComponent(response.headers["fname"]);//构造一个blob对象来处理数据const blob = new Blob(this.contentList);//对于<a>标签，只有 Firefox 和 Chrome（内核）支持 download 属性//IE10以上支持blob但是依然不支持downloadif ("download" in document.createElement("a")) {//支持a标签download的浏览器const link = document.createElement("a"); //创建a标签link.download = fileName; //a标签添加属性link.style.display = "none";link.href = URL.createObjectURL(blob);document.body.appendChild(link);link.click(); //执行下载URL.revokeObjectURL(link.href); //释放urldocument.body.removeChild(link); //释放标签} else {//其他浏览器navigator.msSaveBlob(blob, fileName);} }} else {//调用暂停方法，记录当前下载位置console.log("下载失败")} }).catch(function (error) {console.log(error);});};// 第一次获取数据方便获取总数sentAxios(this.filesCurrentPage);this.$message({message: '文件开始下载！',type: 'success'});} }})</script></body></html> 本篇文章为转载内容。原文链接：https://blog.csdn.net/kangshihang1998/article/details/129407214。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-01-19 08:12:45

546

转载

转载文章

[转载]系统安全以及应用

...到另一个用户，但前提条件是必须知道用户登录密码。对于生产环境中的Linux服务器，每多一个人知道特权密码，安全风险就多一分。于是就多了一种折中的办法，使用sudo命令提升执行权限，不过需要由管理员预先进行授权，指定用户使用某些命令： 2. su命令的用途以及用法：用途：以其他用户身份（如root）执行授权命令用法：sudo 授权命令 3.配置su的授权（加入wheel组）（pam_wheel认证模块：）：进入授权命令：1.visudo 或者 vim /etc/sudoers语法格式：1.用户主机名=命令程序列表2.用户主机名=（用户）命令程序列表-l：列出用户在主机上可用的和被禁止的命令;一般配置好/etc/sudoers后，要用这个命令来查看和测试是不是配置正确的;-v：验证用户的时间戳;如果用户运行sudo后，输入用户的密码后，在短时间内可以不用输入口令来直接进行sudo操作;用-v可以跟踪最新的时间戳;-u：指定以以某个用户执行特定操作;-k：删除时间戳，下一个sudo命令要求用求提供密码; 1.首先创建3个组 2.vim /etc/pam.d/su把第六行注释去掉保存退出 1. 以上两行是默认状态(即开启第一行，注释第二行)，这种状态下是允许所有用户间使用su命令进行切换的 2.两行都注释也是运行所有用户都能使用su命令，但root下使用su切换到其他普通用户需要输入密码: 3.如果第–行不注释，则root 使用su切换普通用户就不需要输入密码( pam_ rootok. so模块的主要作用是使uid为0的用户，即root用户能够直接通过认证而不用输入密码。) 4.如果开启第二行，表示只有root用户和wheel1组内的用户才可以使用su命令。 5.如果注释第一行，开启第二行，表示只有whee1组内的用户才能使用su命令，root用户也被禁用su命令。 3.将liunan加入到wheel之后，hehe就有了使用su命令的权限 4.使用pam_wheel认证后，没有在wheel里的用户都不能再用su 5.whoami命令确定当前用户是谁 4.配置/etc/sudoers文件(授权用户较多的时候使用)： visudo单个授权visudo 或者 vim /etc/sudoers记录格式：user MACHINE=COMMANDS可以使用通配符“ ”号任意值和“ ！”号进行取反操作。%组名代表一整个组权限生效后，输入密码后5分钟可以不用重新输入密码。例如：visudo命令下user kiro=(root)NOPASSWD:/usr/sbin/useradd,PASSWD:/usr/sbin/usermod代表 kiro主机里的user用户，可以无密码使用useradd命令，有密码使用usermod/etc/sudoers多个授权Host_Alias MYHOST= localhost 主机别名：主机名、IP、网络地址、其他主机别名!取反Host_Alias MAILSVRS=smtp,pop（主机名）User_Alias MYUSER = kiro，user1,lisi 用户别名：包含用户、用户组（%组名（使用引导))、还可以包含其他其他已经用户的别名User_Alias OPERATORS=zhangsan,tom,lisi（需要授权的用户）Cmnd_Alias MYCMD = /sbin/,/usr/bin/passwd 命令路劲、目录（此目录内的所有命令)、其他事先定义过的命令别名Cmnd_Alias PKGTOOLS=/bin/rpm,/usr/bin/yum（授权）MYUSER MYHOST = NOPASSWD : MYCMDDS 授权格式sudo -l 查询目前sudo操作查看sudo操作记录需启用Defaults logfile配置默认日志文件: /var/log/sudosudo -l 查看当前用户获得哪些sudo授权（启动日志文件后，sudo操作过程才会被记录） 1.首先用visudo 或者 vim /etc/sudoers进入，输入需要授权的命令 2.切换到taojian用户，因为设置了它不能使用创建用户的命令所以无法创建六.开关机安全控制 1.调整BIOS引导设置 1.将第一引导设备设为当前系统所在硬盘2.禁止从其他设备(光盘、U盘、网络)引导系统3.将安全级别设为setup，并设置管理员密码 2.GRUB限制 1.使用grub2-mkpasswd-pbkdf2生成密钥2.修改/etclgrub.d/00_header文件中，添加密码记录3.生成新的grub.cfg配置文件方法一：通常情况下在系统开机进入GRUB菜单时，按e键可以查看并修改GRUB引导参数，这对服务器是一个极大的威胁。可以为GRUB菜单设置一个密码，只有提供正确的密码才被允许修改引导参数。grub2-mkpasswd-pbkdf2 根据提示设置GRUB菜单的密码PBKDF2 hash of your password is grub.pbkd..... 省略部分内容为经过加密生成的密码字符串cp /boot/grub2/grub.cfg /boot/grub2/grub.cfg.bak 8cp /etc/grub.d/00_header /etc/grub.d/00_header.bak 9vim /etc/grub.d/00_headercat << EOFset superusers="root" 设置用户名为rootpassword_pbkdf2 root grub.pbkd2..... 设置密码，省略部分内容为经过加密生成的密码字符串EOF16grub2-mkconfig -o /boot/grub2/grub.cfg 生成新的grub.cfg文件重启系统进入GRUB菜单时，按e键将需要输入账号密码才能修改引导参数。方法二： 1.一步到位2.grub2-setpassword 七.终端以及登录控制 1.限制root只在安全终端登录安全终端配置文件在 /etc/securetty 2..禁止普通用户登录 1.建立/etc/nologin文件 2.删除nologin文件或重启后即恢复正常 vim /etc/securetty在端口前加号拒绝访问touch /etc/nologin 禁止普通用户登录rm -rf /etc/nologin 取消禁止八.系统弱口令检测 1.JOHN the Ripper，简称为JR 1.一款密码分析工具，支持字典式的暴力破解2.通过对shadow文件的口令分析，可以检测密码强度3.官网网站：http://www.openwall.com/john/ 2.安装弱口令账号 1.获得Linux/Unix服务器的shadow文件2.执行john程序，讲shadow文件作为参数 3.密码文件的暴力破解 1.准备好密码字典文件，默认为password.lst2.执行john程序，结合--wordlist=字典文件九.网络端口扫描 1.NMAP 1.—款强大的网络扫描、安全检测工具,支持ping扫描，多端口检测等多种技术。2.官方网站: http://nmap.orgl3.CentOS 7.3光盘中安装包,nmap-6.40-7.el7.x86_64.rpm 2.格式 NMAP [扫描类型] [选项] <扫描目标....> 安装NMAP软件包rpm -qa | grep nmapyum install -y nmapnmap命令常用的选项和扫描类型-p：指定扫描的端口。-n：禁用反向DNS 解析 (以加快扫描速度)。-sS：TCP的SYN扫描（半开扫描)，只向目标发出SYN数据包，如果收到SYN/ACK响应包就认为目标端口正在监听，并立即断开连接;否则认为目标端口并未开放。-sT：TCP连接扫描，这是完整的TCP扫描方式(默认扫描类型)，用来建立一个TCP连接，如果成功则认为目标端口正在监听服务，否则认为目标端口并未开放。-sF：TCP的FIN扫描，开放的端口会忽略这种数据包，关闭的端口会回应RST数据包。许多防火墙只对SYN数据包进行简单过滤，而忽略了其他形式的TCP attack 包。这种类型的扫描可间接检测防火墙的健壮性。-sU：UDP扫描，探测目标主机提供哪些UDP服务，UDP扫描的速度会比较慢。-sP：ICMP扫描，类似于ping检测，快速判断目标主机是否存活，不做其他扫描。-P0：跳过ping检测，这种方式认为所有的目标主机是存活的，当对方不响应ICMP请求时，使用这种方式可以避免因无法 ping通而放弃扫描。总结： 1.账号基本安全措施：系统账号处理、密码安全控制、命令历史清理、自动注销 2.用户切换与提权（su、sudo） 3.开关机安全控制（BIOS引导设置、禁止Ctrl+Alt+Del快捷键、GRUB菜单设置密码） 4.终端控制 5.弱口令检测——John the Ripper 6.端口扫描——namp 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_67474417/article/details/123982900。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-05-07 23:37:44

转载

转载文章

[转载]线性回归建模及模型诊断

...地平均收入 edu_class：教育等级，0、1、2、3 依次是小学、初中、高中、大学二、描述性分析首先可筛选Acc为1的数据，分别以avg_exp为因变量，其余变量为自变量进行数据探索，主要是发现自变量和因变量是否有线形关系。 raw_1 = raw[raw['Acc'] == 1] 2.1 连续自变量与连续因变量的相关性分析首先对连续变量和目标变量进行相关性分析，因变量avg_exp为连续变量，一般可以用相关系数来看其线形相关性。 cons_vasr = ['avg_exp', 'avg_exp_ln', 'Age', 'Income', 'dist_home_val', 'dist_avg_income', 'age2', 'high_avg']raw_1[cons_vasr].corr()vg']].corr() 结果如下，可以看到收入 Income 和当地人均收入 dist_avg_income这两个变量和avg_exp月均信用卡支出有较强的相关性，同时观察自变量间的相关性可发现人均收入 Income 和当地人均收入 dist_avg_income 之间也有较强的相关性，相关系数为0.99，说明接下来我们可以把这两个变量加入模型，但要注意可能会存在多重共线性。 2.2 二分类变量与连续变量的相关性分析分类变量和连续变量之间的相关性可以用t检验进行，接下来以是否自有住房 Ownrent 变量和月均收入之间进行相关性检验。首先查看Ownrent 不同取值的数量以及avg_exp均值分布情况如何： pd.pivot_table(raw_1, values = ['avg_exp'], index = ['Ownrent'], aggfunc = {'avg_exp': ['count', np.mean]}) 接着分别对 Ownrent 为0、1的 avg_exp 进行t检验： import scipy.stats as st 引入scipy.stats进行t检验创建变量Ownrent_0 = raw_1[raw_1['Ownrent'] == 0]['avg_exp'].valuesOwnrent_1 = raw_1[raw_1['Ownrent'] == 1]['avg_exp'].valuesst.ttest_ind(Ownrent_0, Ownrent_1, equal_var = True) p值为0.01 < 0.05，可以拒绝原假设，即认为是否自有住房和月均信用卡支出是相关的。 2.3 多分类变量与连续变量的相关性分析多分类变量和连续变量之间的相关性检验可以用多次t检验进行，但较为繁琐，用方差分析进行快速检验相关性，然后再运用多重检验查看具体是哪些处理之间存在差异。以教育水平edu_class为例进行分析，同理首先查看分布 raw_1.pivot_table(index = 'edu_class', values = ['avg_exp'], aggfunc={'avg_exp': ['count', np.mean]}) 可以看到不同教育水平之间消费水平有明显差异，接下来通过方差分析进行检验差异是否明显。 from statsmodels.stats.anova import anova_lm 引入anova_lm进行方差分析from ststsmodels.stats.formula import ols 引入ols进行线性回归建模lm = ols('avg_exp~C(edu_class)', data = raw_1).fit() C(edu_class) 将数值型的变量指定为分类型anova_lm(lm, typ = 2) 可以看到不同教育水平之间的月均消费支出之间的差异是显著的，继续用多重检验来看哪些处理之间是显著的。 from statsmodels.stats.multicomp import MultiComparison 引入MultiComparison进行tukey多重检验mc = MultiComparison(raw_1['avg_exp'],raw_1['edu_class'])tukey_result = mc.tukeyhsd(alpha = 0.5)print(tukey_result) 结果是每个处理之间因变量差异的显著性，最后一列reject都为True说明各组之间均存在显著差异。三、模型建立与诊断 3.1 一元线性回归及模型解读以Income为自变量，以avg_exp为因变量建立一元线形回归并对模型结果进行解释 lm_1 = ols('avg_exp ~ Income', data = raw_1).fit()print(lm_1.summary()) 首先从第一部分可以看到R^2为0.454，整个模型的F检验p值小于0.05，说明模型通过显著性检验。其次模型结果的第二块也表明自变量和截距也通过显著性检验。最后一部分主要是对残差进行检验，左侧Omnibus、Prob(Omnibus)主要是对偏度Skew和峰度Kurtosis进行检验，正态分布的偏度为0，峰度为3，模型的Prob(Omnibus)值为0.156大于0.05，说明不能拒绝残差符合正态分布。右侧Durbin-Watson主要是对残差的自相关性进行检（改检验可表示为，为残差之间的相关系数），Durbin-Watson的取值范围是0-4，越接近2说明残差不存在自相关性，越接近0说明存在正相关，越接近4说明存在负相关性。右侧Jarque-Bera (JB)、Prob(JB)是对残差正态性检验，可以用来判断残差是否符合正态分布，本案例中Prob(JB)值为0.173 > 0.05，基不能拒绝残差服从正态分布。右侧Cond. No.是多重共线性检验，该值越大，共线性越严重。整体上看模型虽然拟合效果没那么好，但是显著性通过了检验。接下来看一下模型具体的系数，Income的系数为97.7说明模型收入越高信用卡消费越高，是符合业务预期的。 3.2 残差可视化分析接下来对残差进一步进行可视化分析，主要看残差是否满足以下几个假定，并尝试通过对自变量、因变量进行调整来优化模型。首先来回顾一下残差需要满足的几个假定： a.残差的要服从均值为0，方差为的正态分布； b.残差之间要相互独立 c.残差和自变量没有相关性（1）通过残差图进行模型优化模型avg_exp ~ Income的自变量与残差分布图、残差qq图、模型拟合情况图即自变量与因变量及其预测值的图像 lm_1 = ols('avg_exp ~ Income', data = raw_1).fit() 建模raw_1['resid_1'] = lm_1.resid 模型残差raw_1['resid_1_rank'] = raw_1['resid_1'].rank(ascending = False, pct = True) 计算残差的百分位数raw_1['pred_1'] = lm_1.predict() 添加预测值plt.figure(figsize = (20, 6)) 自变量与残差分布图ax1 = plt.subplot(131)ax1.scatter('Income', 'resid', data = raw_1)ax1.set_title('Income & resid') 残差的qq图ax2 = plt.subplot(132)stats.probplot(raw_1['resid_1_rank'], dist = 'norm', plot = ax2) 模型拟合情况图，自变量与因变量以及模型预测值ax3 = plt.subplot(133)ax3.scatter('Income', 'avg_exp', data = raw_1)ax3.plot('Income', 'pred_1', data = raw_1, color = 'red')ax3.legend()ax3.text(12, 1920, 'pred func R^2: %.2f'% lm_1.rsquared)ax3.set_title('Income & avg_exp') 从第一个自变量和残差散点图可以看出，残差基本符合对称分布，但随着自变量增大，残差也在变大，存在方差不齐的情况。第二个图残差的qq图可以看出，残差近似正态分布。第三个图可以看模型的拟合效果并不是很好，R^2只有0.45。对avg_exp取对数，能够改善预测值越大残差越大的情况，但由于只对因变量取对数导致模型不好解释，对自变量Income同时取对数，代码和以上类似，只是改变因变量和自变量形式而已，以下是残差图，可以看到残差的异方差现象被有效的抑制，并且R^2也得到了提高。（2）通过残差图发现强影响点仔细观察以上图像结果，左下侧有两个较为异常的数据，对模型的拟和效果有较大的影响，对于这种影响较大的可将其进行删除并重新建模：计算学生化残差raw_1['resid_t'] = (raw_1['resid_2'] - raw_1['resid_2'].mean())/raw_1['resid_2'].std() raw_1[abs(raw_1['resid_t']) > 2] 将残差大于2的筛选出来将强影响点删除后，得到的结果如下，模型结果更稳定。 3.3 多元线性回归上一篇文章有说到多重共线性会对模型产生致命的影响，用方差膨胀因子来处理的话会非常繁琐。通过正则化处理如Lasso回归，能够产生某些严格等于0的系数，从而达到变量筛选的目的。接下来以Lasso为例，首先用LassoCV来找到最优的alpha。由于statsmodels中的ols的fit_regularized方法没有很好的实现，所以用sklearn中linear_model模块来进行建模 from sklearn.preprocessing import StandardScaler sklearn进行线性回归前必须要进行标准化from sklearn.linear_model import LassoCV Lasso的交叉验证方法con_xcols = ['Age', 'Income', 'dist_home_val', 'dist_avg_income']scaler = StandardScaler()X = scaler.fit_transform(raw_1[con_xcols])y = raw_1['avg_exp_ln']lasso_alphas = np.logspace(-3, 0, 100, base = 10)lcv = LassoCV(alphas = lasso_alphas, cv = 10)lcv.fit(X, y)print('best alpha %.4f' % lcv.alpha_)print('the r-square %.4f' % lcv.score(X, y)) 接下来画出不同alpha下的岭迹图，来看alpha值对系数的影响 from sklearn.linear_model import Lassocoefs = []lasso = Lasso()for i in lasso_alphas:lasso.set_params(alpha = i)lasso.fit(X, y)coefs.append(lasso.coef_)ax = plt.gca()ax.plot(lasso_alphas, coefs)ax.set_xscale('log')ax.set_xlabel('$\\alpha$')ax.set_ylabel('coefs value') 从图中可以看到随着alpha的增大，系数不断在减小，有些系数会优先收缩为0，再继续增大时所欲系数都会为0，通过该特性从而达到变量筛选的目的。将LassoCV得到的系数打印出来，可以看到用户月均信用卡支出和当地小区均价、当地人均收入成正比，当地人均收入水平的影响更大。以上就是线形回归在应用时的注意事项。本篇文章为转载内容。原文链接：https://blog.csdn.net/baidu_26137595/article/details/123766191。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-11-23 15:52:56

106

转载

Kafka

Kafka命名规范与组织结构剖析及实战演练

...s; public class KafkaProducerExample { public static void main(String[] args) { Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); KafkaProducer producer = new KafkaProducer<>(props); for (int i = 0; i < 10; i++) { producer.send(new ProducerRecord<>("login_logs", "key" + i, "value" + i)); } producer.close(); } } 这段代码会向login_logs主题发送10条消息，每条消息都有一个唯一的键和值。 --- 5. 总结 Kafka的魅力在于细节好了，到这里咱们的Kafka之旅就告一段落了。通过这篇文章，我希望大家能更好地理解Kafka的命名规范和组织结构。Kafka为啥这么牛？因为它在设计的时候真是把每个小细节都琢磨得特别透。就像给主题起名字吧，分个区啦，还有消费者组怎么配合干活儿，这些地方都能看出人家确实是下了一番功夫的，真不是随便凑合出来的！当然，Kafka的学习之路还有很多内容需要探索，比如监控、调优、安全等等。其实我觉得啊，只要你把命名的规矩弄明白了，东西该怎么放也心里有数了，那你就算是走上正轨啦，成功嘛，它就已经在向你招手啦！加油吧，朋友们！ --- 希望这篇文章对你有所帮助，如果有任何疑问，欢迎随时交流哦！

2025-04-05 15:38:52

彩虹之上

转载文章

[转载]JVM G1源码分析（一）——卡表和位图

...则认为发生了引用。 class CardTable: public CHeapObj<mtGC> {friend class VMStructs;public:typedef uint8_t CardValue;// All code generators assume that the size of a card table entry is one byte.// They need to be updated to reflect any change to this.// This code can typically be found by searching for the byte_map_base() method.STATIC_ASSERT(sizeof(CardValue) == 1);protected:// The declaration order of these const fields is important; see the// constructor before changing.const MemRegion _whole_heap; // the region covered by the card tableconst size_t _page_size; // page size used when mapping _byte_mapsize_t _byte_map_size; // in bytesCardValue _byte_map; // the card marking arrayCardValue _byte_map_base;// Some barrier sets create tables whose elements correspond to parts of// the heap; the CardTableBarrierSet is an example. Such barrier sets will// normally reserve space for such tables, and commit parts of the table// "covering" parts of the heap that are committed. At most one covered// region per generation is needed.static constexpr int max_covered_regions = 2;// The covered regions should be in address order.MemRegion _covered[max_covered_regions];// The last card is a guard card; never committed.MemRegion _guard_region;inline size_t compute_byte_map_size(size_t num_bytes);enum CardValues {clean_card = (CardValue)-1,dirty_card = 0,CT_MR_BS_last_reserved = 1};// a word's worth (row) of clean card valuesstatic const intptr_t clean_card_row = (intptr_t)(-1);// CardTable entry sizestatic uint _card_shift;static uint _card_size;static uint _card_size_in_words;size_t last_valid_index() const {return cards_required(_whole_heap.word_size()) - 1;}private:void initialize_covered_region(void region0_start, void region1_start);MemRegion committed_for(const MemRegion mr) const;public:CardTable(MemRegion whole_heap);virtual ~CardTable() = default;void initialize(void region0_start, void region1_start);// Barrier set functions.// Initialization utilities; covered_words is the size of the covered region// in, um, words.inline size_t cards_required(size_t covered_words) const {assert(is_aligned(covered_words, _card_size_in_words), "precondition");return covered_words / _card_size_in_words;}// Dirty the bytes corresponding to "mr" (not all of which must be// covered.)void dirty_MemRegion(MemRegion mr);// Clear (to clean_card) the bytes entirely contained within "mr" (not// all of which must be covered.)void clear_MemRegion(MemRegion mr);// Return true if "p" is at the start of a card.bool is_card_aligned(HeapWord p) {CardValue pcard = byte_for(p);return (addr_for(pcard) == p);}// Mapping from address to card marking array entryCardValue byte_for(const void p) const {assert(_whole_heap.contains(p),"Attempt to access p = " PTR_FORMAT " out of bounds of "" card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()));CardValue result = &_byte_map_base[uintptr_t(p) >> _card_shift];assert(result >= _byte_map && result < _byte_map + _byte_map_size,"out of bounds accessor for card marking array");return result;}// The card table byte one after the card marking array// entry for argument address. Typically used for higher bounds// for loops iterating through the card table.CardValue byte_after(const void p) const {return byte_for(p) + 1;}void invalidate(MemRegion mr);// Provide read-only access to the card table array.const CardValue byte_for_const(const void p) const {return byte_for(p);}const CardValue byte_after_const(const void p) const {return byte_after(p);}// Mapping from card marking array entry to address of first wordHeapWord addr_for(const CardValue p) const {assert(p >= _byte_map && p < _byte_map + _byte_map_size,"out of bounds access to card marking array. p: " PTR_FORMAT" _byte_map: " PTR_FORMAT " _byte_map + _byte_map_size: " PTR_FORMAT,p2i(p), p2i(_byte_map), p2i(_byte_map + _byte_map_size));// As _byte_map_base may be "negative" (the card table has been allocated before// the heap in memory), do not use pointer_delta() to avoid the assertion failure.size_t delta = p - _byte_map_base;HeapWord result = (HeapWord) (delta << _card_shift);assert(_whole_heap.contains(result),"Returning result = " PTR_FORMAT " out of bounds of "" card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",p2i(result), p2i(_whole_heap.start()), p2i(_whole_heap.end()));return result;}// Mapping from address to card marking array index.size_t index_for(void p) {assert(_whole_heap.contains(p),"Attempt to access p = " PTR_FORMAT " out of bounds of "" card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()));return byte_for(p) - _byte_map;}CardValue byte_for_index(const size_t card_index) const {return _byte_map + card_index;}// Resize one of the regions covered by the remembered set.void resize_covered_region(MemRegion new_region);// Card-table-RemSet-specific things.static uintx ct_max_alignment_constraint();static uint card_shift() {return _card_shift;}static uint card_size() {return _card_size;}static uint card_size_in_words() {return _card_size_in_words;}static constexpr CardValue clean_card_val() { return clean_card; }static constexpr CardValue dirty_card_val() { return dirty_card; }static intptr_t clean_card_row_val() { return clean_card_row; }// Initialize card sizestatic void initialize_card_size();// Card marking array base (adjusted for heap low boundary)// This would be the 0th element of _byte_map, if the heap started at 0x0.// But since the heap starts at some higher address, this points to somewhere// before the beginning of the actual _byte_map.CardValue byte_map_base() const { return _byte_map_base; }virtual bool is_in_young(const void p) const = 0;}; class G1CardTable : public CardTable {friend class VMStructs;friend class G1CardTableChangedListener;G1CardTableChangedListener _listener;public:enum G1CardValues {g1_young_gen = CT_MR_BS_last_reserved << 1,// During evacuation we use the card table to consolidate the cards we need to// scan for roots onto the card table from the various sources. Further it is// used to record already completely scanned cards to avoid re-scanning them// when incrementally evacuating the old gen regions of a collection set.// This means that already scanned cards should be preserved.//// The merge at the start of each evacuation round simply sets cards to dirty// that are clean; scanned cards are set to 0x1.//// This means that the LSB determines what to do with the card during evacuation// given the following possible values://// 11111111 - clean, do not scan// 00000001 - already scanned, do not scan// 00000000 - dirty, needs to be scanned.//g1_card_already_scanned = 0x1};static const size_t WordAllClean = SIZE_MAX;static const size_t WordAllDirty = 0;STATIC_ASSERT(BitsPerByte == 8);static const size_t WordAlreadyScanned = (SIZE_MAX / 255) g1_card_already_scanned;G1CardTable(MemRegion whole_heap): CardTable(whole_heap), _listener() {_listener.set_card_table(this);}static CardValue g1_young_card_val() { return g1_young_gen; }static CardValue g1_scanned_card_val() { return g1_card_already_scanned; }void verify_g1_young_region(MemRegion mr) PRODUCT_RETURN;void g1_mark_as_young(const MemRegion& mr);size_t index_for_cardvalue(CardValue const p) const {return pointer_delta(p, _byte_map, sizeof(CardValue));}// Mark the given card as Dirty if it is Clean. Returns whether the card was// Clean before this operation. This result may be inaccurate as it does not// perform the dirtying atomically.inline bool mark_clean_as_dirty(CardValue card);// Change Clean cards in a (large) area on the card table as Dirty, preserving// already scanned cards. Assumes that most cards in that area are Clean.inline void mark_range_dirty(size_t start_card_index, size_t num_cards);// Change the given range of dirty cards to "which". All of these cards must be Dirty.inline void change_dirty_cards_to(CardValue start_card, CardValue end_card, CardValue which);inline uint region_idx_for(CardValue p);static size_t compute_size(size_t mem_region_size_in_words) {size_t number_of_slots = (mem_region_size_in_words / _card_size_in_words);return ReservedSpace::allocation_align_size_up(number_of_slots);}// Returns how many bytes of the heap a single byte of the Card Table corresponds to.static size_t heap_map_factor() { return _card_size; }void initialize(G1RegionToSpaceMapper mapper);bool is_in_young(const void p) const override;}; 以位为粒度的位图能准确描述每一个字的引用关系，但是一个位通常包含的信息太少，只能描述2个状态：引用还是未引用。实际应用中JVM在垃圾回收的时候需要更多的状态，如果增加至一个字节来描述状态，则位图需要256KB的空间，这个数字太大，开销占了25%。所以一个可能的做法位图不再描述一个字，而是一个区域，JVM选择512字节为单位，即用一个字节描述512字节的引用关系。选择一个区域除了空间利用率的问题之外，实际上还有现实的意义。我们知道Java对象实际上不是一个字能描述的（有一个参数可以控制对象最小对齐的大小，默认是8字节，实际上Java在JVM中还有一些附加信息，所以对齐后最小的Java对象是16字节），很多Java对象可能是几十个字节或者几百个字节，所以用一个字节描述一个区域是有意义的。但是我没有找到512的来源，为什么512效果最好？没有相应的数据来支持这个数字，而且这个值不可以配置，不能修改，但是有理由相信512字节的区域是为了节约内存额外开销。按照这个值，1MB的内存只需要2KB的额外空间就能描述引用关系。这又带来另一个问题，就是512字节里面的内存可能被引用多次，所以这是一个粗略的关系描述，那么在使用的时候需要遍历这512字节。再举一个例子，假设有两个对象B、C都在这512字节的区域内。为了方便处理，记录对象引用关系的时候，都使用对象的起始位置，然后用这个地址和512对齐，因此B和C对象的卡表指针都指向这一个卡表的位置。那么对于引用处理也有可有两种处理方法：·处理的时候会以堆分区为处理单位，遍历整个堆分区，在遍历的时候，每次都会以对象大小为步长，结合卡表，如果该卡表中对应的位置被设置，则说明对象和其他分区的对象发生了引用。具体内容在后文中介绍Refine的时候还会详细介绍。·处理的时候借助于额外的数据结构，找到真正对象的位置，而不需要从头开始遍历。在后文的并发标记处理时就使用了这种方法，用于找到第一个对象的起始位置。在G1除了512字节粒度的卡表之外，还有bitMap，例如使用bitMap可以描述一个分区对另外一个分区的引用情况。在JVM中bitMap使用非常多，例如还可以描述内存的分配情况。在G1除了512字节粒度的卡表之外，还有bitMap，例如使用bitMap可以描述一个分区对另外一个分区的引用情况。在JVM中bitMap使用非常多，例如还可以描述内存的分配情况。G1在混合收集算法中用到了并发标记。在并发标记的时候使用了bitMap来描述对象的分配情况。例如1MB的分区可以用16KB（16KB×ObjectAlignmentInBytes×8=1MB）来描述，即16KB额外的空间。其中ObjectAlignmentInBytes是8字节，指的是对象对齐，第二个8是指一个字节有8位。即每一个位可以描述64位。例如一个对象长度对齐之后为24字节，理论上它占用3个位来描述这个24字节已被使用了，实际上并不需要，在标记的时候只需要标记这3个位中的第一个位，再结合堆分区对象的大小信息就能准确找出。其最主要的目的是为了效率，标记一个位和标记3个位相比能节约不少时间，如果对象很大，则更划算。这些都是源码的实现细节，大家在阅读源码时需要细细斟酌。本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_16500963/article/details/132133125。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-12-16 20:37:50

246

转载

转载文章

[转载]python 类的定制_Python基础：20类的定制

...认值一：简单定制 classRoundFloatManual(object):def __init__(self, val):assert isinstance(val, float), "Value must be a float!"self.value= round(val, 2)>>> rfm =RoundFloatManual(42) Traceback (mostrecent call last): File"", line 1, in? File"roundFloat2.py", line 5, in __init__assertisinstance(val, float), \ AssertionError: Value must be a float!>>> rfm =RoundFloatManual(4.2)>>>rfm >>> printrfm 它因输入非法而异常，但如果输入正确时，就没有任何输出了。在解释器中，我们得到一些信息，却不是我们想要的。print(使用str())和真正的字符串对象表示(使用repr())都没能显示更多有关我们对象的信息。这就需要实现__str__()和__repr__()二者之一，或者两者都实现。加入下面的方法： def __str__(self):return str(self.value) 现在我们得到下面的： >>> rfm = RoundFloatManual(5.590464)>>>rfm >>> printrfm5.59 >>> rfm = RoundFloatManual(5.5964)>>> printrfm5.6 但是在解释器中转储(dump)对象时，仍然显示的是默认对象符号，要修复它，只需要覆盖__repr__()。可以让__repr__()和__str__()具有相同的代码，但最好的方案是：__repr__ = __str__ 在带参数5.5964的第二个例子中，我们看到它舍入值刚好为5.6，但我们还是想显示带两位小数的数。可以这样修改： def __str__(self):return '%.2f' % self.value 这里就同时具备str()和repr()的输出了： >>> rfm =RoundFloatManual(5.5964)>>>rfm5.60 >>>printrfm5.60 所有代码如下： classRoundFloatManual(object):def __init__(self,val):assert isinstance(val, float), "Valuemust be a float!"self.value= round(val, 2)def __str__(self):return '%.2f' %self.value__repr__ = __str__ 二：数值定制定义一个Time60，其中，将整数的小时和分钟作为输入传给构造器： classTime60(object):def __init__(self, hr, min): self.hr=hr self.min= min 1：显示需要在显示实例的时候，得到一个有意义的输出，那么就要覆盖__str__()(如果有必要的话,__repr__()也要覆盖)： def __str__(self):return '%d:%d' % (self.hr, self.min) 比如： >>> mon =Time60(10, 30)>>> tue =Time60(11, 15)>>> >>> printmon, tue10:30 11:15 2：加法 Python中的重载操作符很简单。像加号(+)，只需要重载__add__()方法，如果合适，还可以用__radd__()及__iadd__()。注意，实现__add__()的时候，必须认识到它返回另一个Time60对象，而不修改原mon或tue： def __add__(self, other):return self.__class__(self.hr + other.hr, self.min + other.min) 在类中，一般不直接调用类名，而是使用self 的__class__属性，即实例化self 的那个类，并调用它。调用self.__class__()与调用Time60()是一回事。但self.__class__()的方式更好。 >>> mon = Time60(10, 30)>>> tue = Time60(11, 15)>>> mon +tue >>> print mon +tue21:45 如果没有定义相对应的特殊方法，但是却使用了该方法对应的运算，则会引起一个TypeError异常： >>> mon -tue Traceback (mostrecent call last): File"", line 1, in? TypeError:unsupported operand type(s)for -: 'Time60' and 'Time60' 3：原位加法 __iadd__()，是用来支持像mon += tue 这样的操作符，并把正确的结果赋给mon。重载一个__i__()方法的唯一秘密是它必须返回self： def __iadd__(self, other): self.hr+=other.hr self.min+=other.minreturn self 下面是结果输出： >>> mon = Time60(10,30)>>> tue = Time60(11,15)>>>mon10:30 >>>id(mon)401872 >>> mon +=tue>>>id(mon)401872 >>>mon21:45 下面是Time60的类的完全定义： classTime60(object):'Time60 - track hours and minutes' def __init__(self,hr, min):'Time60 constructor - takes hours andminutes'self.hr=hr self.min=mindef __str__(self):'Time60 - string representation' return '%d:%d' %(self.hr, self.min)__repr__ = __str__ def __add__(self, other):'Time60 - overloading the additionoperator' return self.__class__(self.hr + other.hr,self.min +other.min)def __iadd__(self,other):'Time60 - overloading in-place addition'self.hr+=other.hr self.min+=other.minreturn self 4：升华在这个类中，还有很多需要优化和改良的地方。首先看下面的例子： >>> wed =Time60(12, 5)>>>wed12:5 正确的显示应该是：“12:05” >>> thu =Time60(10, 30)>>> fri =Time60(8, 45)>>> thu +fri18:75 正确的显示应该是：19:15 可以做出如下修改： def __str__(self):return '%02d:%02d'%(self.hr, self.min)__repr__ = __str__ def __add__(self, othertime): tmin= self.min +othertime.min thr= self.hr +othertime.hrreturn self.__class__(thr + tmin/60, tmin%60)def __iadd__(self, othertime): self.min+=othertime.min self.hr+=othertime.hr self.hr+= self.min/60self.min%= 60 return self 三：迭代器迭代器对象本身需要支持以下两种方法，它们组合在一起形成迭代器协议： iterator.__iter__() 返回迭代器对象本身。 iterator.next() 从容器中返回下一个元素。实现了__iter__()和next()方法的类就是一个迭代器。自定义迭代器的例子如下： RandSeq(Random Sequence)，传入一个初始序列，__init__()方法执行前述的赋值操作。__iter__()仅返回self，这就是如何将一个对象声明为迭代器的方式，最后，调用next()来得到迭代器中连续的值。这个迭代器唯一的亮点是它没有终点。代码如下： classRandSeq(object):def __init__(self, seq): self.data=seqdef __iter__(self):returnselfdefnext(self):return choice(self.data) 运行它，将会看到下面的输出： >>> from randseq importRandSeq>>> for eachItem in RandSeq(('rock', 'paper', 'scissors')): ...printeachItem ... scissors scissors rock paper paper scissors ...... 四：多类型定制现在创建另一个新类，NumStr，由一个数字-字符对组成，记为n和s，数值类型使用整型(integer)。用[n::s]来表示它，这两个数据元素构成一个整体。NumStr有下面的特征：初始化：类应当对数字和字符串进行初始化；如果其中一个(或两)没有初始化，则使用0和空字符串，也就是, n=0 且s=''作为默认。加法：定义加法操作符，功能是把数字加起来，把字符连在一起；比如，NumStr1=[n1::s1]且NumStr2＝[n2::s2]。则NumStr1+NumStr2 表示［n1+n2::s1+s2］，其中，＋代表数字相加及字符相连接。乘法：类似的，定义乘法操作符的功能为，数字相乘，字符累积相连，也就是，NumStr1NumStr2=[n1n::s1n]。 False 值：当数字的数值为 0 且字符串为空时，也就是当NumStr=[0::'']时，这个实体即有一个false值。比较：比较一对NumStr对象，比如，[n1::s1] vs. [n2::s2]，有九种不同的组合。对数字和字符串，按照标准的数值和字典顺序的进行比较。如果obj1< obj2，则cmp(obj1, obj2)的返回值是一个小于0 的整数，当obj1 > obj2 时，比较的返回值大于0，当两个对象有相同的值时，比较的返回值等于0。我们的类的解决方案是把这些值相加，然后返回结果。为了能够正确的比较对象，我们需要让__cmp__()在 (n1>n2) 且 (s1>s2)时，返回 1，在(n1s2),或相反)，返回0. 反之亦然。代码如下： classNumStr(object):def __init__(self, num=0, string=''): self.__num =num self.__string =stringdef __str__(self):return '[%d :: %r]' % (self.__num, self.__string)__repr__ = __str__ def __add__(self, other):ifisinstance(other, NumStr):return self.__class__(self.__num + other.__num, self.__string + other.__string)else:raise TypeError, 'Illegal argument type for built-in operation' def __mul__(self, num):ifisinstance(num, int):return self.__class__(self.__num num, self.__string num)else:raise TypeError, 'Illegal argument type for built-inoperation' def __nonzero__(self):return self.__num or len(self.__string)def __norm_cval(self, cmpres):returncmp(cmpres, 0)def __cmp__(self, other):return self.__norm_cval(cmp(self.__num, other.__num))+\ self.__norm_cval(cmp(self.__string,other.__string)) 执行一些例子： >>> a =NumStr(3, 'foo')>>> b =NumStr(3, 'goo')>>> c =NumStr(2, 'foo')>>> d =NumStr()>>> e =NumStr(string='boo')>>> f =NumStr(1)>>>a [3 :: 'foo']>>>b [3 :: 'goo']>>>c [2 :: 'foo']>>>d [0 ::'']>>>e [0 ::'boo']>>>f [1 :: '']>>> a True>>> b False>>> a ==a True>>> b 2[6 :: 'googoo']>>> a 3[9 :: 'foofoofoo']>>> b +e [3 :: 'gooboo']>>> e +b [3 :: 'boogoo']>>> if d: 'not false'...>>> if e: 'not false'...'not false' >>>cmp(a, b)-1 >>>cmp(a, c)1 >>>cmp(a, a) 0 如果在__str__中使用“%s”，将导致字符串没有引号： return '[%d :: %s]' % (self.__num, self.__string)>>> printa [3 :: foo] 第二个元素是一个字符串，如果用户看到由引号标记的字符串时，会更加直观。要做到这点，使用“repr()”表示法对代码进行转换，把“%s”替换成“%r”。这相当于调用repr()或者使用单反引号来给出字符串的可求值版本--可求值版本的确要有引号： >>> printa [3 :: 'foo'] __norm_cval()不是一个特殊方法。它是一个帮助我们重载__cmp__()的助手函数：唯一的目的就是把cmp()返回的正值转为1，负值转为-1。cmp()基于比较的结果，通常返回任意的正数或负数(或0)，但为了我们的目的，需要严格规定返回值为-1,0 和1。对整数调用cmp()及与 0 比较，结果即是我们所需要的，相当于如下代码片断： def __norm_cval(self, cmpres):if cmpres<0:return -1 elif cmpres>0:return 1 else:return 0 两个相似对象的实际比较是比较数字，比较字符串，然后返回这两个比较结果的和。本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_30849865/article/details/112989450。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-04-19 14:30:42

132

转载

转载文章

[转载]基于SSM的手表商城系统设计与实现

...//<div class="tab-pane active" id="nArrivals">// <div class="nArrivals owl-carousel" id="top1">$.each(data.rows, function (i, valmm) { html+='<div class="nArrivals owl-carousel" id="'+valmm.id+'">';$.ajax({url: "shangpin.action?list&page=0&rows=10",type: "POST",async: false,data: { fenlei:valmm.id },success: function (data) { $.each(data.rows, function (i, val) { html+='<div class="product-grid">'+'<div class="item">'+' <div class="product-thumb">'+' <div class="image product-imageblock"> <a href="home/details.jsp?ids='+val.id+'"> <img data-name="product_image" style="width:223px;height:285px;" src="<%=basePath%>'+val.tupian1+'" alt="iPod Classic" title="iPod Classic" class="img-responsive"> <img style="width:223px;height:285px;" src="<%=basePath%>'+val.tupian1+'" alt="iPod Classic" title="iPod Classic" class="img-responsive"> </a> </div>'+' <div class="caption product-detail text-left">'+' <h6 data-name="product_name" class="product-name mt_20"><a href="home/details.jsp?ids='+val.id+'" title="Casual Shirt With Ruffle Hem">'+val.biaoti+'</a></h6>'+' <div class="rating"> <span class="fa fa-stack"><i class="fa fa-star-o fa-stack-1x"></i><i class="fa fa-star fa-stack-1x"></i></span> <span class="fa fa-stack"><i class="fa fa-star-o fa-stack-1x"></i><i class="fa fa-star fa-stack-1x"></i></span> <span class="fa fa-stack"><i class="fa fa-star-o fa-stack-1x"></i><i class="fa fa-star fa-stack-1x"></i></span> <span class="fa fa-stack"><i class="fa fa-star-o fa-stack-1x"></i><i class="fa fa-star fa-stack-1x"></i></span> <span class="fa fa-stack"><i class="fa fa-star-o fa-stack-1x"></i><i class="fa fa-star fa-stack-x"></i></span> </div>'+'<span class="price"><span class="amount"><span class="currencySymbol">$</span>'+val.jiage+'</span>'+'</span>'+'<div class="button-group text-center">'+' <div class="wishlist"><a href="home/details.jsp?ids='+val.id+'"><span>wishlist</span></a></div>'+'<div class="quickview"><a href="home/details.jsp?ids='+val.id+'"><span>Quick View</span></a></div>'+'<div class="compare"><a href="home/details.jsp?ids='+val.id+'"><span>Compare</span></a></div>'+'<div class="add-to-cart"><a href="home/details.jsp?ids='+val.id+'"><span>Add to cart</span></a></div>'+'</div>'+'</div>'+'</div>'+'</div>'+' </div>'; })html+='</div>'; } })}) $("nArrivals").html(html); } }); 本篇文章为转载内容。原文链接：https://blog.csdn.net/newlw/article/details/127608579。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-03-21 18:24:50

转载

转载文章

[转载]PLC通讯实现-C#访问OpcUa实现读写PLC（十）

...UA{public class Equip : BaseEquip{region 字段定义private bool _isOpen = false; //是否已打开设备private bool _isClosing = false; //是否正在关闭设备private OPCUAClass myOpcHelper; //OPCUA设备访问辅助对象private Dictionary<string, string> dicTags = null; //保存标签集合private Dictionary<string, object> readResult = null; //设备标签数据缓存private int stepLen = 250; //标签变量的步长设置private string groupNamePrefix = "DB"; //数据块号前缀private string childTagFlag = "~"; //子元素标签标志符private System.Threading.Thread innerReadThread = null; //内部读取线程对象private int innerReadRate = 1000; //内部读取频率endregionregion 属性定义/// <summary>/// OPCUA Server Url/// </summary>public string OpcUaServerUrl{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).OpcUaServerUrl;return "opc.tcp://192.168.1.102:4840";//return "opc.tcp://192.168.100.1:4840";//return "opc.tcp://192.168.100.2:4840";} }/// <summary>/// 要连接的OPCUA服务器上的服务名/// </summary>public string OpcUaServiceName{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).OpcUaServiceName;return "[UaServer@cMT-9F1F] [None] [None] [opc.tcp://192.168.1.102:4840/G01]";//return "[UaServer@cMT-EAB9] [None] [None] [opc.tcp://192.168.100.1:4840/G01]";//return "[UaServer@cMT-EA5B] [None] [None] [opc.tcp://192.168.100.2:4840/G02]";//return "[UaServer@cMT-EA5B] [None] [None] [opc.tcp://192.168.100.2:4840/G01]";} }/// <summary>/// 要连接的OPCUA服务器上指定服务名下的PLC的名称/// </summary>public string PLCName{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).PLCName;//return "Feeding";return "Siemens_192.168.2.1";//return "Rockwell_192.168.1.10";} }/// <summary>/// OPCUA服务器的访问账户/// </summary>public string Account{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).Account;return "user1";} }/// <summary>/// OPCUA服务器的访问密码/// </summary>public string Password{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).Password;return "1";} }endregionregion BaseEquip成员实现/// <summary>/// 打开连接设备/// </summary>/// <returns>成功返回true，失败返回false</returns>public override bool Open(){lock (this){this._isClosing = false;if (this._isOpen == true && this.myOpcHelper != null){return true;}this.State = false;this.myOpcHelper = new OPCUAClass();this.dicTags = this.myOpcHelper.ConnectOPCUA(this.OpcUaServerUrl, this.Account, this.Password, this.OpcUaServiceName, this.PLCName); //连接OPCServerif (this.dicTags == null || this.dicTags.Count == 0){this.myOpcHelper = null;Console.WriteLine("OPC连接失败!");this.State = false;return false;}else{this.State = true;this._isOpen = true;region 初始化读取结果this.readResult = new Dictionary<string, object>();foreach (Equips.BaseInfo.Group group in this.Group.Values){if (!group.IsAutoRead){continue;}int groupMinStart = group.Start;int groupMaxEnd = group.Start + group.Len;int groupMaxLen = group.Len;foreach (Equips.BaseInfo.Group g in this.Group.Values){if (!g.IsAutoRead){continue;}if (g.Block == group.Block){if (g.Start < group.Start){groupMinStart = g.Start;}if (g.Start + g.Len > groupMaxEnd){groupMaxEnd = g.Start + g.Len;} }}groupMaxLen = groupMaxEnd - groupMinStart;int tagCount = groupMaxLen % this.stepLen == 0 ? groupMaxLen / this.stepLen : groupMaxLen / this.stepLen + 1;int currLen = 0;for (int i = 0; i < tagCount; i++){string tagName = String.Empty;if (tagCount == 1){tagName = String.Format("{0}-{1}", groupMinStart, groupMinStart + groupMaxLen - 1);currLen = groupMaxLen;}else if (i == tagCount - 1){tagName = String.Format("{0}-{1}", groupMinStart + (i this.stepLen), groupMinStart + (i this.stepLen) + (groupMaxLen % this.stepLen == 0 ? this.stepLen : groupMaxLen % this.stepLen) - 1);currLen = groupMaxLen % this.stepLen;}else{tagName = String.Format("{0}-{1}", groupMinStart + (i this.stepLen), groupMinStart + (i this.stepLen) + this.stepLen - 1);currLen = this.stepLen;}string tagFullName = String.Format("{0}{1}.{2}", groupNamePrefix, group.Block, tagName);if (!this.readResult.ContainsKey(tagFullName)){bool exists = false;region 判断读取结果标签组的范围是否包括了此标签比如tagFullName DB5.220-299,在readResult中存在 DB5.200-299，则认为已存在，不需要再添加string[] beginend = null;int begin = 0;int end = 0;string[] startstop = tagFullName.Replace(String.Format("{0}{1}.", groupNamePrefix, group.Block), String.Empty).Split(new char[] { '-' });int start = 0;int stop = 0;bool parseResult = false;if (startstop.Length == 2){parseResult = int.TryParse(startstop[0], out start);if (parseResult){parseResult = int.TryParse(startstop[1], out stop);} }if (parseResult){int existsMinBegin = 0; //已存在标签的最小开始索引int existsMaxEnd = 0; //已存在标签的最大结束索引bool isContinue = true; //标签值是否连续string[] existsTags = this.readResult.Keys.ToArray<string>();foreach (string tag in existsTags){if (tag.StartsWith(String.Format("{0}{1}.", groupNamePrefix, group.Block)) && tag.Contains(".") && tag.Contains("-")){string[] tagname = tag.Split(new char[] { '.' });if (tagname.Length == 2){beginend = tagname[1].Split(new char[] { '-' });if (beginend.Length == 2){parseResult = int.TryParse(beginend[0], out begin);if (parseResult){parseResult = int.TryParse(beginend[1], out end);}region 计算最小开始索引和最大结束索引if (begin < existsMinBegin){existsMinBegin = begin;region 判断标签值是否连续if (existsMaxEnd != 0 && begin != existsMaxEnd + 1){isContinue = false;}endregion}if (end > existsMaxEnd){existsMaxEnd = end;}endregion} }if (parseResult){if (start >= begin && stop <= end){exists = true;break;}if (isContinue){if (start >= existsMinBegin && stop <= existsMaxEnd){exists = true;break;} }} }} }endregionif (!exists){ushort[] groupData = new ushort[currLen];this.readResult[tagFullName] = groupData;Console.WriteLine(tagFullName);} }}//int tagCount = group.Len % this.stepLen == 0 ? group.Len / this.stepLen : group.Len / this.stepLen + 1;//int currLen = 0;//for (int i = 0; i < tagCount; i++)//{// string tagName = String.Empty;// if (tagCount == 1)// {// tagName = String.Format("{0}-{1}", group.Start, group.Start + group.Len - 1);// currLen = group.Len;// }// else if (i == tagCount - 1)// {// tagName = String.Format("{0}-{1}", group.Start + (i this.stepLen), group.Start + (i this.stepLen) + (group.Len % this.stepLen == 0 ? this.stepLen : group.Len % this.stepLen) - 1);// currLen = group.Len % this.stepLen;// }// else// {// tagName = String.Format("{0}-{1}", group.Start + (i this.stepLen), group.Start + (i this.stepLen) + this.stepLen - 1);// currLen = this.stepLen;// }// string tagFullName = String.Format("{0}{1}.{2}", groupNamePrefix, group.Block, tagName);// if (!this.readResult.ContainsKey(tagFullName))// {// short[] groupData = new short[currLen];// this.readResult[tagFullName] = groupData;// }//} }endregionregion 开启内部定时读取if (this.innerReadThread == null){this.innerReadRate = this.Main.ReadHz / 2;this.innerReadThread = new System.Threading.Thread(this.InnerAutoRead);this.innerReadThread.Start();}endregion}return this.State;} }/// <summary>/// 从设备读取数据/// </summary>/// <param name="block">要读取的块号</param>/// <param name="start">要读取的起始字</param>/// <param name="len">要读取的长度</param>/// <param name="buff">读取成功后的输出数据</param>/// <returns>成功返回true，失败返回false</returns>public override bool Read(string block, int start, int len, out object[] buff){lock (this){buff = null;if (this._isClosing){return false;}string readstrflag = String.Format("{0}{1}.{2}-{3}", this.groupNamePrefix, block, start, start + len - 1);System.Text.StringBuilder sbtaglength = new System.Text.StringBuilder();string startTag = String.Empty;string groupName = String.Format("{0}{1}", this.groupNamePrefix, block); //要读取的OPCServer块List<ushort> groupData = new List<ushort>();List<string> groupTagNames = new List<string>();int startIndex = 0;try{if (!Open()){return false;}//return true;string[] keys = this.readResult.Keys.ToArray<string>();foreach (string key in keys){if (key.StartsWith(groupName) && key.Replace(String.Format("{0}.", groupName), String.Empty).Contains("-")){groupTagNames.Add(key);} }groupTagNames.Sort(); //对块标签进行排序foreach (string key in groupTagNames){if (String.IsNullOrEmpty(startTag)){startTag = key.Replace(String.Format("{0}.", groupName), String.Empty);}ushort[] values;if (this.readResult[key] is ushort[]){values = this.readResult[key] as ushort[];}else{values = new ushort[] { (ushort)this.readResult[key] };}sbtaglength.Append(String.Format("tagName={0}, buff length = {1}", key, values.Length));groupData.AddRange(values);}buff = new object[len];if (!String.IsNullOrEmpty(startTag)){string strStartIndex = startTag.Substring(0, startTag.IndexOf("-"));int.TryParse(strStartIndex, out startIndex);startIndex = start - startIndex;Array.Copy(groupData.ToArray(), startIndex, buff, 0, buff.Length);}else{}return true;}catch (Exception ex){Console.WriteLine(String.Join(";", groupTagNames.ToArray<string>()));Console.WriteLine("data length = " + groupData.Count);Console.WriteLine(this.Name + "读取失败[" + readstrflag + "]:" + ex.Message);Console.WriteLine(sbtaglength.ToString());this.State = false;return false;} }}/// <summary>/// 写入数据到设备/// </summary>/// <param name="block">要写入的块号</param>/// <param name="start">要写入的起始字</param>/// <param name="buff">要写如的数据</param>/// <returns>成功返回true，失败返回false</returns>public override bool Write(int block, int start, object[] buff){bool result = true;lock (this){try{if (this._isClosing){return false;}if (!Open()){return false;}bool isWrite = false;region 按标签变量写入string itemId = "";foreach (Equips.BaseInfo.Group group in this.Group.Values){if (group.Block == block.ToString()){foreach (Equips.BaseInfo.Data data in group.Data.Values){if (group.Start + data.Start == start && data.Len == buff.Length){if (this.dicTags.ContainsKey(data.Name)){itemId = this.dicTags[data.Name];}break;} }} }if (!String.IsNullOrEmpty(itemId)){UInt16[] intBuff = new UInt16[buff.Length];for (int i = 0; i < intBuff.Length; i++){intBuff[i] = 0;if (!UInt16.TryParse(buff[i].ToString(), out intBuff[i])){Console.WriteLine("在写入OPCUA标签时把buff中的元素转为UInt16类型失败!");} }result = this.myOpcHelper.WriteUInt16(itemId, intBuff);if (!result){Console.WriteLine(String.Format("标签变量[{0}]写入失败!", itemId));return false;}else{Console.WriteLine("按标签变量写入..." + itemId);isWrite = true;} }if (isWrite){return true;}endregionregion 按块写入region 先读取相应标签数数据string startTag = String.Empty;string groupName = String.Format("{0}{1}", this.groupNamePrefix, block); //要读取的OPCServer块List<ushort> groupData = new List<ushort>();string[] keys = readResult.Keys.Where(o => o.StartsWith(groupName) && o.Contains("-")).OrderBy(c => c).ToArray<string>();foreach (string key in keys){if (String.IsNullOrEmpty(startTag)){startTag = key.Replace(String.Format("{0}.", groupName), String.Empty);}string[] beginEnd = key.Replace(String.Format("{0}.", groupName), String.Empty).Split(new char[] { '-' });if (beginEnd.Length != 2){Console.WriteLine(String.Format("标签变量[{0}]未按约定方式命名，请按[DB块号].[起始字-结束字]方式标签变量进行命名！", String.Format("{0}.{1}", key)));return false;}int begin = 0;int end = 0;int.TryParse(beginEnd[0], out begin);int.TryParse(beginEnd[1], out end);region 写入之前，先读取一下PLC的值if ((start >= begin && start <= end) || ((start + buff.Length - 1) >= begin && (start + buff.Length - 1) <= end) || (start < begin && (start + buff.Length - 1) > end)){this.ReadTag(key);if (this.readResult.ContainsKey(key) && this.readResult[key] is Array){Console.WriteLine("read = " + key);groupData.AddRange(this.readResult[key] as ushort[]);}else{Console.WriteLine(String.Format("读取结果中不包含标签变量[{0}]的值!", String.Format("{0}", key)));} }else{if (this.readResult.ContainsKey(key) && this.readResult[key] is Array){Console.WriteLine("no read = " + key);groupData.AddRange(this.readResult[key] as ushort[]);} }endregion}endregionif (String.IsNullOrEmpty(startTag)){Console.WriteLine("写入失败，未在OPCUAserver中找到对应的标签,block = {0}, start = {1}, len = {2}", block, start, buff.Length);return false;}region 更新标签中对应的数据后，再写回OPCServerint startIndex = 0;string strStartIndex = startTag.Substring(0, startTag.IndexOf("-"));int.TryParse(strStartIndex, out startIndex);startIndex = start - startIndex;ushort[] newDataBuffer = groupData.ToArray();for (int i = 0; i < buff.Length; i++){ushort svalue = 0;ushort.TryParse(buff[i].ToString(), out svalue);newDataBuffer[startIndex + i] = svalue;}int index = 0;string[] keys2 = readResult.Keys.Where(o => o.StartsWith(groupName) && o.Contains("-")).OrderBy(c => c).ToArray<string>();foreach (string key2 in keys2){string[] beginEnd = key2.Replace(String.Format("{0}.", groupName), String.Empty).Split(new char[] { '-' });if (beginEnd.Length != 2){Console.WriteLine(String.Format("标签变量[{0}]未按约定方式命名，请按[DB块号].[起始字-结束字]方式标签变量进行命名！", String.Format("{0}", key2)));return false;}int begin = 0;int end = 0;int.TryParse(beginEnd[0], out begin);int.TryParse(beginEnd[1], out end);if ((start >= begin && start <= end) || ((start + buff.Length - 1) >= begin && (start + buff.Length - 1) <= end) || (start < begin && (start + buff.Length - 1) > end)){//Console.WriteLine("---------------------------------------------------------");//Console.WriteLine("start = " + start);//Console.WriteLine("start + buff.Length - 1 = " + (start + buff.Length -1));//Console.WriteLine("begin = " + begin);//Console.WriteLine("end = " + end);//Console.WriteLine("---------------------------------------------------------");if (!this.dicTags.ContainsKey(key2)){Console.WriteLine(String.Format("写入失败：标签变量[{0}]在OpcUA Server中未定义!", String.Format("{0}", key2)));return false;}int len = (this.readResult[key2] as ushort[]).Length;ushort[] tagDataBuff = new ushort[len];//Console.WriteLine("newDataBuff");//Console.WriteLine(String.Join(",", newDataBuffer));//Console.WriteLine("index = " + index);//Console.WriteLine("tagDataBuff.Length = " + tagDataBuff.Length);//Array.Copy(newDataBuffer, begin, tagDataBuff, 0, tagDataBuff.Length);int existsMinBegin = this.GetExistsMinBeginByBlock(block.ToString());Array.Copy(newDataBuffer, begin - existsMinBegin, tagDataBuff, 0, tagDataBuff.Length);index += tagDataBuff.Length;//Console.WriteLine("Write " + key2);//Console.WriteLine(String.Join(",", tagDataBuff));//Console.WriteLine("写入标签：" + this.dicTags[key2]);result = this.myOpcHelper.WriteUInt16(this.dicTags[key2], tagDataBuff);if (!result){Console.WriteLine(String.Format("向标签变量[{0}]中写入值失败!", String.Format("{0}", key2)));return false;}else{this.ReadTag(key2);Console.WriteLine("写入...");}//Console.WriteLine("---------------------------------------------------------");} }endregionendregionreturn result;}catch (Exception ex){Console.WriteLine(this.Name + "写入失败:" + ex.Message);return false;} }}/// <summary>/// 关闭方法，断开与设备的连接释放资源/// </summary>public override void Close(){try{this._isClosing = true;System.Threading.Thread.Sleep(this.Main.ReadHz);if (this.innerReadThread != null){this.innerReadThread.Abort();this.innerReadThread = null;} }catch (Exception ex){Console.WriteLine("关闭内部读取OPCUA线程异常：" + ex.Message);}try{if (this.myOpcHelper != null){this.myOpcHelper.Close();this.myOpcHelper = null;this.State = false;this._isOpen = false;} }catch (Exception ex){Console.WriteLine("关于与OPCUA服务连接异常：" + ex.Message);} }endregionregion 辅助方法/// <summary>/// 获取某个数据块标签的最小开始索引/// </summary>/// <param name="block">块号</param>/// <returns>返回数据块标签的最小开始索引</returns>private int GetExistsMinBeginByBlock(string block){int existsMinBegin = 99999; //已存在标签的最小开始索引int existsMaxEnd = 0; //已存在标签的最大结束索引bool isContinue = true; //标签值是否连续string[] existsTags = this.readResult.Keys.ToArray<string>();string[] beginend = null;bool parseResult = false;int begin = 0;int end = 0;foreach (string tag in existsTags){if (tag.StartsWith(String.Format("{0}{1}.", groupNamePrefix, block)) && tag.Contains(".") && tag.Contains("-")){string[] tagname = tag.Split(new char[] { '.' });if (tagname.Length == 2){beginend = tagname[1].Split(new char[] { '-' });if (beginend.Length == 2){parseResult = int.TryParse(beginend[0], out begin);if (parseResult){parseResult = int.TryParse(beginend[1], out end);}region 计算最小开始索引和最大结束索引if (begin < existsMinBegin){existsMinBegin = begin;region 判断标签值是否连续if (existsMaxEnd != 0 && begin != existsMaxEnd + 1){isContinue = false;}endregion}if (end > existsMaxEnd){existsMaxEnd = end;}endregion} }if (parseResult){//} }}return existsMinBegin;}/// <summary>/// 读取标签/// </summary>/// <param name="tagName"></param>private void ReadTag(string tagName){UInt16[] buff = null;if (this.dicTags.ContainsKey(tagName)){if (this.myOpcHelper.ReadUInt16(this.dicTags[tagName], out buff)){//Console.WriteLine("tagName={0}, buff length = {1}", tagName, buff.Length);if (this.readResult.ContainsKey(tagName)){this.readResult[tagName] = buff;}else{this.readResult.Add(tagName, buff);} }else{Console.WriteLine("Mesnac.Equip.OPC.OpcUa.OPCUA.Equip.ReadTag Exception 读取标签：[{0}]失败!", tagName);} }else{Console.WriteLine("Mesnac.Equip.OPC.OpcUa.OPCUA.Equip.ReadTag Exception OPCUA Server中未定义此标签：[{0}]!", tagName);} }/// <summary>/// 内部自动读取方法/// </summary>private void InnerAutoRead(){while (this._isOpen && this._isClosing == false){try{if (this.myOpcHelper == null){this._isClosing = true;this.State = false;return;}lock (this){string[] keys = this.readResult.Keys.ToArray<string>();foreach (string key in keys){this.ReadTag(key);} }System.Threading.Thread.Sleep(this.innerReadRate);}catch (Exception ex){Console.WriteLine("Mesnac.Equip.OPC.OpcUa.OPCUA.Equip.InnerAutoRead Exception : " + ex.Message);} }this.innerReadThread = null;}endregionregion 析构方法~Equip(){this.Close();}endregion} } 代码下载代码下载本篇文章为转载内容。原文链接：https://blog.csdn.net/zlbdmm/article/details/96714776。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-05-10 18:43:00

269

转载

转载文章

[转载]一位架构师的感悟：过度忙碌使你落后

...面所要求的特性或约束条件，这些需求并不直接描述系统应实现的具体功能，而是关注系统的质量和表现。文中强调真正决定软件架构的是非功能性需求，比如性能、伸缩性、扩展性和可维护性等，而非仅限于功能性需求。微内核架构模式（Micro-Kernel Pattern） , 微内核架构是一种软件架构模式，它将操作系统或应用程序的核心功能模块化并集中管理，而将其他服务作为独立进程运行。这种模式下，内核只提供最基本的服务，如进程间通信机制，而其他所有服务都通过与内核通信来实现。在文中，微内核模式被提及是因为它更关注系统的可扩展性和可用性（错误隔离），是《面向模式的软件架构》一书中介绍的众多有助于满足非功能性需求的架构模式之一。

2023-09-19 14:55:26

转载

转载文章

[转载]三维坐标系与几何学

...球体。应用了材质后，渲染得到的球体看起来是弯曲的。如果使用高洛德着色，结果更是如此。更多信息请参阅高洛德着色。表面和顶点法向量网格中的每个面有一个垂直的法向量。该向量的方向由定义顶点的顺序及坐标系统是左手系还是右手系决定。表面法向量从表面上指向正向面那一侧，如果把表面水平放置，正向面朝上，背向面朝下，那么表面法向量为垂直于表面从下方指向上方。在Microsoft® Direct3D®中，只有面的正向是可视的。一个正向面是顶点按照顺时针顺序定义的面。任何不是正向面的面都是背向面。由于Direct3D不总是渲染背向面，因此背向面要被剔除。如果想要渲染背向面的话，可以改变剔除模式。更多信息请参阅剔除状态。 Direct3D在计算高洛德着色、光照和纹理效果时使用顶点法向。 Direct3D使用顶点法向计算光源和表面间的夹角，对多边形进行高洛德着色。Direct3D计算每个顶点的颜色和亮度值，并对图元表面所覆盖的所有像素点进行插值。Direct3D使用夹角计算光强度，夹角越大，表面得到的光照就越少。如果正在创建的物体是平直的，可将顶点法向设为与表面垂直，如下图所示。该图定义了一个由两个三角形组成的平直表面。但是，更可能的情况是物体由三角形带（triangle strips）组成且三角形不共面。要对整个三角形带的三角形平滑着色的一个简单方法是首先计算与顶点相关联的每个多边形表面的表面法向量。可以这样计算顶点法向，使顶点法向与顶点所属的每个表面的法向的夹角相等。但是，对复杂图元来说这种方法可能不够有效。这种方法如下图所示。图中有两个表面，S1与S2，它们的邻边在上方。S1与S2的法向量用蓝色显示。顶点的法向量用红色显示。顶点法向量与S1表面法向的夹角和顶点法向量与S2表面法向的夹角相同。当对这两个表面进行光照计算和高洛德着色时，得到结果是中间的边被平滑着色，看起来像是弧形的（而不是有棱角的）。如果顶点法向偏向与它相关联的某个面，那么会导致那个面上的点光强度的增加或减少。下图显示了一个例子。这些面的邻边依然朝上。顶点法向倾向S1，与顶点法向与表面法向有相同的夹角相比，这使顶点法向与光源间的夹角变小。可以用高洛德着色在三维场景中显示一些有清晰边缘的物体。要达到这个目的，只要在需要产生清晰边缘的表面交线处，把表面法向复制给交线处顶点的法向，如下图所示。如果使用DrawPrimitive方法渲染场景，要将有锋利边缘的物体定义为三角形表，而非三角形带。当将物体定义为三角形带时，Direct3D会将它作为由多个三角形组成的单个多边形处理。高洛德着色被同时应用于多边形每个表面的内部和表面之间。结果产生表面之间平滑着色的物体。因为三角形表由一系列不相连的三角形面组成，所以Direct3D对多边形每个面的内部使用高洛德着色。但是，没有在表面之间应用高洛德着色。如果三角形表的两个或更多的三角形是相邻的，那么在它们之间看起来会有一条锋利边缘。另一种可选的方法是在渲染具有锋利边缘的物体时改变到平面着色模式。这在计算上是最有效的方法，但它可能导致场景中的物体不如用高洛德着色渲染的物体真实。三角形光栅化法则顶点指定的点经常不能精确地对应到屏幕上的像素。此时，Microsoft® Direct3D®使用三角形光栅化法则决定对于给定三角形使用哪个像素。三角形光栅化法则点、线光栅化法则点精灵光栅化法则三角形光栅化法则 Direct3D在填充几何图形时使用左上填充约定（top-left filling convention）。这与Microsoft Windows®的图形设备接口（GUI）和OpenGL中的矩形使用的约定相同。Direct3D中，像素的中心是决定点。如果中心在三角形内，那么该像素就是三角形的一部分。像素中心用整数坐标表示。这里描述的Direct3D使用的三角形光栅化法则不一定适用于所有可用的硬件。测试可以发现这些法则的实现间的细微变化。下图显示了一个左上角为（0，0），右下角为（5，5）的矩形。正如大家想象的那样，此矩形填充25个像素。矩形的宽度由right减left定义。高度由bottom减top定义。在左上填充约定中，上表示水平span在垂直方向上的位置，左表示span中的像素在水平方向上的位置。一条边除非是水平的，否则不可能是顶边——一般来说，大多数三角形只有左边或右边。左上填充约定确定当一个三角形穿过像素的中心时Direct3D采取的动作。下图显示了两个三角形，一个在（0，0），（5，0）和（5，5），另一个在（0，5），（0，0）和（5，5）。在这种情况下第一个三角形得到15个像素（显示为黑色），而第二个得到10个像素（显示为灰色），因为公用边是第一个三角形的左边。如果应用程序定义一个左上角为（0.5，0.5），右下角为（2.5，4.5）的矩形，那么这个矩形的中心在（1.5，2.5）。当Direct3D光栅化器tessellate这个矩形时，每个像素的中心都毫无异义地分别位于四个三角形中，此时就不需要左上填充约定。下图显示了这种情况。矩形内的像素根据在Direct3D中被哪个三角形包含做了相应的标注。如果将上例中的矩形移动，使之左上角为（1.0，1.0），右下角为（3.0，5.0），中心为（2.0，3.0），那么Direct3D使用左上角填充约定。这个矩形中大多数的像素跨越两个或更多的三角形的边界，如下图所示。这两个矩形会影响到相同的像素。点、线光栅化法则点和点精灵一样，都被渲染为与屏幕边缘对齐的四边形，因此它们使用与多边形同样的渲染法则。非抗锯齿线段的渲染法则与GDI使用的法则完全相同。更多有关抗锯齿线段的渲染，请参阅ID3DXLine。点精灵光栅化法则对点精灵和patch图元的渲染，就好像先把图元tessellate成三角形，然后将得到的三角形进行光栅化。更多信息，请参阅点精灵。矩形贯穿Microsoft® Direct3D®和Microsoft Windows®编程，都是用术语包围矩形来讨论屏幕上的物体。由于包围矩形的边总是与屏幕的边平行，因此矩形可以用两个点描述，左上角和右下角。当在屏幕上进行位块传输（Blit = Bit block transfer）或命中检测时，大多数应用程序使用RECT结构保存包围矩形的信息。 C++中，RECT结构有如下定义。 typedef struct tagRECT { LONG left; // 这是左上角的x坐标。 LONG top; // 这是左上角的y坐标。 LONG right; // 这是右下角的x坐标。 LONG bottom; // 这是右下角的y坐标。 } RECT, PRECT, NEAR NPRECT, FAR LPRECT; 在上例中，left和top成员是包围矩形左上角的x-和y-坐标。类似地，right和bottom成员组成右下角的坐标。下图直观地显示了这些值。为了效率、一致性及易用性， Direct3D所有的presentation函数都使用矩形。三角形插值对象（interpolants）在渲染时，流水线会贯穿每个三角形的表面进行顶点数据插值。有五种可能的数据类型可以进行插值。顶点数据可以是各种类型的数据，包括（但不限于）：漫反射色、镜面反射色、漫反射阿尔法（三角形透明度）、镜面反射阿尔法、雾因子（固定功能流水线从镜面反射的阿尔法分量中取得，可编程顶点流水线则从雾寄存器中取得）。顶点数据通过顶点声明定义。对一些顶点数据的插值取决于当前的着色模式，如下表所示。着色模式描述平面在平面着色模式下只对雾因子进行插值。对所有其它的插值对象，整个面都使用三角形第一个顶点的颜色。高洛德在所有三个顶点间进行线性插值。根据不同的颜色模型，对漫反射色和镜面反射色的处理是不同的。在RGB颜色模型中，系统在插值时使用红、绿和蓝颜色分量。颜色的阿尔法成员作为单独的插值对象对待，因为设备驱动程序可以以两种不同的方法实现透明：使用纹理混合或使用点画法（stippling）。可以用D3DCAPS9结构的ShadeCaps成员确定设备驱动程序支持何种插值。向量、顶点和四元数贯穿Microsoft® Direct3D®，顶点用于描述位置和方向。图元中的每个顶点由指定其位置的向量、颜色、纹理坐标和指定其方向的法向量描述。四元数给三元素向量的[ x, y, z]值增加了第四个元素。用于三维旋转的方法，除了典型的矩阵以外，四元数是另一种选择。四元数表示三维空间中的一根轴及围绕该轴的一个旋转。例如，一个四元数可能表示轴(1,1,2)和1度的旋转。四元数包含了有价值的信息，但它们真正的威力源自可对它们执行的两种操作：合成和插值。对四元数进行插值与合成它们类似。两个四元数的合成如下表示：将两个四元数的合成应用于几何体意味着“把几何体绕axis2轴旋转rotation2角度，然后绕axis1轴旋转rotation1角度”。在这种情况下，Q表示绕单根轴的旋转，该旋转是先后将q2和q1应用于几何体的结果。使用四元数，应用程序可以计算出一条从一根轴和一个方向到另一根轴和另一个方向的平滑、合理的路径。因此，在q1和q2间插值提供了一个从一个方向变化到另一个方向的简单方法。当同时使用合成与插值时，四元数提供了一个看似复杂而实际简单的操作几何体的方法。例如，设想我们希望把一个几何体旋转到某个给定方向。我们已经知道希望将它绕axis2轴旋转r2度，然后绕axis1轴旋转r1度，但是我们不知道最终的四元数。通过使用合成，我们可以在几何体上合成两个旋转并得到最终单个的四元数。然后，我们可以在原始四元数和合成的四元数间进行插值，得到两者之间的平滑转换。 Direct3D扩展（D3DX）工具库包含了帮助用户使用四元数的函数。例如，D3DXQuaternionRotationAxis函数给一个定义旋转轴的向量增加一个旋转值，并在由D3DXQUTERNION结构定义的四元数中返回结果。另外，D3DXQuaternionMultiply函数合成四元数，D3DXQuaternionSlerp函数在两个四元数间进行球面线性插值（spherical linear interpolation）。 Direct3D应用程序可以使用下列函数简化对四元数的使用。 D3DXQuaternionBaryCentric D3DXQuaternionConjugate D3DXQuaternionDot D3DXQuaternionExp D3DXQuaternionIdentity D3DXQuaternionInverse D3DXQuaternionIsIdentity D3DXQuaternionLength D3DXQuaternionLengthSq D3DXQuaternionLn D3DXQuaternionMultiply D3DXQuaternionNormalize D3DXQuaternionRotationAxis D3DXQuaternionRotationMatrix D3DXQuaternionRotationYawPitchRoll D3DXQuaternionSlerp D3DXQuaternionSquad D3DXQuaternionToAxisAngle Direct3D应用程序可以使用下列函数简化对三成员向量的使用。 D3DXVec3Add D3DXVec3BaryCentric D3DXVec3CatmullRom D3DXVec3Cross D3DXVec3Dot D3DXVec3Hermite D3DXVec3Length D3DXVec3LengthSq D3DXVec3Lerp D3DXVec3Maximize D3DXVec3Minimize D3DXVec3Normalize D3DXVec3Project D3DXVec3Scale D3DXVec3Subtract D3DXVec3Transform D3DXVec3TransformCoord D3DXVec3TransformNormal D3DXVec3Unproject D3DX工具库提供的数学函数中包含了许多辅助函数，可以简化对二成员和四成员向量的使用 http://www.gesoftfactory.com/developer/3DCS.htm 本篇文章为转载内容。原文链接：https://blog.csdn.net/okvee/article/details/3438011。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-10-24 12:49:42

271

转载

转载文章

[转载]关于mysql的一些小知识

...性名数据类型[约束条件],…); Paimary key 主键 auto_increment自增 foreign key 外键 references 另一表名(字段名).–>外键这个表连接着另外一个表的哪个键. 删除表: drop table 表名;–>表结构也删除了(也即是这个表没了) Truncate table 表名 --> 只删除表中数据,表结构不会删除. 2.In 与 not in 在或不在这个(1,3)里面,单个查询,只会查询(1或者3) 3.Between and 与 not … 和上面差不多,Between 1 and 3 但是这个是范围查询(1,3) 1-3 之间(包含1,3) 4.Like,模糊查询 “%” 代表任意字符,”_”代表单个字符. 5.Is Not null 与 is null 是否为空 6.And 与 or 一个是所有条件都要完成,or则是任何一个条件完成即可 7.Distinct 去重 8.Order by age asc 与 desc 排序,假如根据age排序,asc正序(升序默认),desc倒叙(降序) 9.Gruop by 分组查询,单独使用无意义,group_concat(字段),拼接,若是根据age group by 则会发现age一样的会出现在同一字段内例如: : 最后要注意group by 后面的字段与所查字段的关系(一对一),当然还有having,having和where基本一样,只不过跟在group by后面. 10.Limit 分页查询 limit 0,5 .查询前5条数据,从0开始,5结束,但是5取不到,也即是取头不取尾. 11.聚合函数:count() 查询数据的总数据量经常使用别名例如:as total sum(字段)函数:求和…若字段为成绩,where条件或gruop by 为个人的id,那么查出的就是个人的成绩总分. AVG(字段),但是查的是平均分,min(字段)与max(字段) 查出最小或最大. 三者都类似sum(),当然max()与min()若是在最前面使用,就会当条件查询只会出来这一笔数据.例如: 12.Sql多表查询,内连接不只是inner join,平时写的from a表,b表 where 条件这也是内连接,意思就是两张表中数据都有才可以查询出来 13.而外连接分为左连接和右连接,意思是以左表或右表为主,假如两张表,左表数据多,右表数据少,且条件符合,则左连接的时候左表数据全部出来,右表没有的为null,反之也是一样. 14.Exist() 与 not exist() …()内的数据是否为空,若是为空则代表false,返回数据为空,若不为空,则代表true,正常查询. 15.Any 与 all 例如 age > any(age1,age2) 大于两者中的一个就可以,但是all的情况下则是全部大于.也就是相当于,any为大于最小的,all则是大于最大的就行了,当然若是小于号那就是另外一种情况了,另外分析. 16.Union,(也就是联合的意思,自带distinct,重复的去除)用法,例如两张表的id要全部查出来,则:select id from A union select id from B ,若Aid为1,2,3,Bid为1,2,4.则查出来的数据为1.2.3.4,若是union all,则不带distinct,用法一样,查出来以后为1.2.3.1.2.4. 17.给表取别名,表名空格别名给字段取别名字段名 as 别名. 18.Insert插入数据时若是使用insert into 表名 values();主键必须到写进去,当然与其他数据不相同即可,若是自增,可以写null.若是insert into 表名(字段)values(值),这时插入数据,字段不用写主键字段,写入其他数据字段名与值就可以完成数据的添加.(主键自己生成为前提,UUID,auto_increament都可以). 19.Insert into 插入多条数据时,其他与18一样,只不过由values()变成了values(),(),(); 20.索引是由数据库表中一列或多列组合而成,其作用提高对表数据的查询速度.像图书目录. 优缺点:优:提高了查询数据的效率.缺:创建和维护索引的时间增加了(内容改了,目录也要改). 21.索引分类:普通索引,唯一性索引UNIQUE(unique修饰,例如主键),全文索引FULLTEXT(创建在文本上,例如:char,varchar,varchar2等,mysql默认引擎不支持,),单列索引:单个字段建立索引,多列索引:多个字段创建一个索引,空间索引SPATIAL:不常用(mysql默认引擎不支持) 22.创建索引: index为关键字,或者key (1)可以index(字段名)–>普通索引 (2)Unique index(字段名)–>唯一索引 (3)Unique index 别名(字段名)–>取别名的唯一索引 (4)index 别名(字段名1,字段名2)–>取别名的多列索引 1.创建表的时候创建索引, 前三个为参数修饰,唯一性,全文,空间索引; 2.在已存在的表上创建索引,或者用ALTER TABLE 表名 ADD 索引,也就是用修改表的形式来创建索引 Create index 索引别名 on 表名(字段名) -->普通单列索引 Create index 索引别名 on 表名(字段名1,字段名2) -->多列索引 Create unique index 索引别名 on 表名(字段名) -->唯一单列索引 Alter table 表名 add +(1)|(2)|(3)|(4)即可. 23.删除索引: drop index 索引名 on 表名. 24.NOW(); mysql的函数,表示当前时间 25.视图:是一个虚拟的表,没有物理数据,是从其他表中导出的数据,当原表数据发生改变时,视图数据也会发生改变,反之也一样. (1)作用:操作简单化;增加数据安全性:不直接对表进行操作;提高表的逻辑性:原表修改字段对视图无影响. (2)创建视图:语法:create view 视图名 as 查询语句. 例如:create view vi as select id,name from user;–>这是把user中id,name字段的数据写入到vi视图中. 若是想自己定义字段名不用查出的字段名,可以如下面这样写. 例如:create view vi(vi_id,vi_name) as select id,name from user;–>这样的话id对应vi_id,name对应vi_name; 上面的都是单表的视图,多表的视图也是一样的,只不过后面的单表查询变成多表查询了. 建议创建视图后自己定义字段名,也即是定义别名. (3)查看视图: Describe(desc) 视图名–>查看视图基本信息 Show table status like ‘视图名’ --> 查看视图基本信息 Show create view 视图名 --> 视图详细信息,建表具体信息. 在view表中查看视图详细信息–>view 系统表自带的. (4)修改视图:修改使徒的定义 Create or replace view 没有的话就创建,有的话就替换例如:Create or replace view vi(id,name) as select语句. Alter view 只修改不能创建(也就是说视图必须存在的情况下才可修改) Alter view vi as select语句 (5)更新视图:视图是虚拟的,对视图进行的crud操作都会对原表的数据产生影响. 也就是说对视图的操作最后都会转换为对视图所连接那个表的操作. (6)删除视图:删除数据库中已存在的视图,视图为虚表,因此只会删除结构,不会删除数据. Drop view if exist 视图名. 26.触发器:由事件来触发某个操作,这些事件包括insert语句,update语句和delete语句.当数据库系统执行这些事件时,就会激活触发器执行相应的方法. 创建触发器:create trigger 触发器名 (before/after) 触发事件 on 表名 for each row sql语句. 这里的new是指代新插入的拿一条数据(更新的也算),若是old的话,指的是删除的那一条数据(更新之前的数据).(new和old属于过渡变量) 这条触发器的意思时:当t_book有插入数据时,就会根据新插入数据的id找到t_bookType的id,并试该条数据的bookNum加1. Begin与end写sql语句,中间可以写多条sql语句用分号;分隔开…也即是说语句要写完成,不能少分号. Delimiter | 设置分隔符,要不然好像只会执行begin与and之间的第一条sql语句. 查看触发器: 1.show triggers; 语句查看触发器信息.(查询所有的触发器) 2.在triggers表中查看触发器信息.(在数据库原始表triggers中可以查看) 删除触发器: Drop trigger 触发器名称 ; 27.函数: (1)日期函数: CURDATE()当前日期,CURTIME()当前时间,MONTH(d):返回日期d中的月份值,范围试1-12 (2)字符串函数:CHAR_LENGTH(s) 计算字段s值->字符串的长度.UPPER(s) 把该字段的值中所有英文都变成大写,LOWER(s) 和相面相反->把英文都变成小写. (3)数学函数:sum():求和,ABS(s) 求绝对值,SQRT(s):求平方根,mod(x,y),求余x/y (4)加密函数:PASSWORD(STR) 一般对密码加密不可逆… MD5(STR) 普通加密 ,不可逆. ENCODE(str,pswd_str) 加密函数,结果是一个二进制文件,用blob类型的字段保存,pswd_str类似一个加密的钥匙,可以随便写. DECODE(被加密的值,pswd_str)–>对encode进行解密. 28.存储过程: (1)存储过程和函数:两者是在数据库中定义一些SQL语句的集合,然后直接调用这些存储过程和函数来执行已经定义好的SQL语句.存储过程和函数可以避免重复的写一些sql语句,而且存储过程是在mysql服务器中存储和执行的,减少客户端和服务器端的数据传输.(类似于java代码写的工具类.) (2)创建存储过程和函数: Create procedure 关键字 pro_book 存储过程名称, in 输入 bT 输入参数名称 int 输入参数类型 out 输出 count_num 输出参数名称 int 输入参数类型 Begin 过程开始 end过程结束中间是sql语句, Delimiter 默认是分号,而他的作用就是若是遇见分号时就开始执行该过程(语句),但是一个存储过程可能有很多sql语句且以分号结束,若这样的情况下当第一条sql语句结束后就会开始执行该过程,产生的后果是创建过程时,执行到第一个分号就会开始创建,导致存储过程创建错误.(若是有多个参数,在多条sql中均有参数,第一条设置完执行了,而这时第二条的参数有可能还么有设置完成,导致sql执行失败.)因此,需要把默认执行过程的demiliter关键字的默认值改为其他的字符,例如上面的就是改为&&,(当然我认为上面就一条sql语句,改不改默认的demiliter的默认值都一样.) . 使用navicat的话不使用delimiter好像也是可以的. Reads sql data则是上面图片所提到的参数指定存储过程的特性.(这个是指读数据,当然还有写输入与读写数据专用的参数类型.)看下图经常用contains sql (应该是可以读,) 这个是调用上面的存储过程,1为入参,@total相当于全局变量,为出参. 这是一个存储函数,create function 为关键字,fun_book为函数名称, 括号里面为传入的参数名(值)以及入参的类型.RETURNS 为返回的关键字,后面接返回的类型. BEGIN函数开始,END函数结束.中间是return 以及查询数据的sql语句, 这里是指把bookId 传进去,通过存储函数返回对应的书本名字, ---------存储函数的调用和调用系统函数一样例如:select 存储函数名称(入参值) Select 为查询 func_book 为存储函数名 2为入参值. (3)变量的使用:declaer:声明变量的值 Delimiter && Create procedure user() Begin Declare a,b varchar2(20) ; — a,b有默认的值,为空 Insert into user values(a,b); End && Delimiter ; Set 可以用来赋值,例如: 可以从其他表中查询出对应的值插入到另一个表中.例如: 从t_user2中查询出username2与password2放入到变量a,b中,然后再插入到t_user表中.(当然这只是创建存储过程),创建完以后,需要用CALL 存储过程名(根据过程参数描写.)来调用存储过程.注意:这一种的写法只可以插入单笔数据,若是select查询出多笔数据,因为无循环故而会插入不进去语句,会导致倒致存储过程时出错.下面的游标也是如此. (4)游标的使用.查询语句可能查询出多条记录,在存储过程和函数中使用游标逐条读取查询结果集中的记录.游标的使用包括声明游标,打开游标,使用游标和关闭游标.游标必须声明到处理程序之前,并且声明在变量和条件之后. 声明:declare 游标名 curson for 查询sql语句. 打开:open 游标名使用:fetch 游标名 into x, 关闭:close 游标名 ----- 游标只能保存单笔数据. 类似于这一个,意思就是先查询出来username2,与password2的值放入到cur_t_user2的游标中(声明,类似于赋值),然后开启->使用.使用的意思就是把游标中存储的值分别赋值到a,b中,然后执行sql语句插入到t_user表中.最后关闭游标. (5)流程控制的使用:mysql可以使用:IF 语句 CASE语句 LOOP语句 LEAVE语句 ITERATE 语句 REPEAT语句与WHILE语句. 这个过程的意思是,查询t_user表中是否存在id等于我们入参时所写的id,若有的情况下查出有几笔这样的数据并且把数值给到全局变量@num中,if判断是否这样的数据是否存在,若是存在执行THEN后面的语句,即使更新该id对应的username,若没有则插入一条新的数据,最后注意END IF. 相当于java中的switch case.例如: 这里想当然于,while(ture){ break; } 这里的意思是,参数一个int类型的参数,loop aaa循环,把参数当做主键id插入到t_user表中,每循环一次参入的参数值减一,直到参数值为0,跳出循环(if判断,leave实现.) 相当于java的continue. 比上面的多了一个当totalNum = 3时,结束本次循环,下面的语句不在执行,直接执行下一次循环,也即是说插入的数据没有主键为3的数据. 和上面的差不多,只不过当执行到UNTIL时满足条件时,就跳出循环.就如上面那一个意思就是当执行到totalNum = 1时,跳出循环,也就是说不会插入主键为0的那一笔数据当while条件判断为true时,执行do后面的语句,否则就不再执行. (6)调用存储过程和函数 CALL 存储过程名字(参数值1,参数值2,…) 存储函数名称(参数值1,参数值2,…) (7)查看存储过程和函数. Show procedure status like ‘存储过程名’ --只能查看状态 Show create procedure ‘存储过程名’ – 查看定义(使用频率高). 存储函数查看也和上面的一样. 当然还可以从information_schema.Routines中(系统数据库表)查看存储过程与函数. (8)修改存储过程与函数: 修改存储过程comment属性的值 ALTER procedure 存储过程名 comment ‘新值’; (9)删除存储过程与函数: DROP PROCEDURE 存储过程名; DROP function 存储函数名; 29.数据备份与还原: (1)数据备份:数据备份可以保证数据库表的安全性,数据库管理员需要定期的进行数据库备份. 命令:使用mysqldump(下图),或者使用图形工具 Mysqldump在msql文件夹+bin+mysqldump.exe中,相当于一个小软件.执行的话是在dos命令窗操作的. 其实就是导出数据库数据,在navacat中可以如下图导出 (2)数据还原: 若是从navacat中就是把外部的.sql文件数据导入到数据库中去.如下图本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_42847571/article/details/102686087。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-04-26 19:09:16

转载

转载文章

[转载]java中访问不可视字段_Kotlin与Java的不同之处

...on 关键字标记： class MyClass { 该伴生对象的成员可通过只使用类名作为限定符来调用： val instance = MyClass.create() 可以省略伴生对象的名称，在这种情况下将使用名称 Companion： class MyClass { 伴生对象的作用类似于 Java 中使用类访问静态成员的语法。因为 Kotlin 取消了 static 关键字，所以 Kotlin 引入伴生对象来弥补没有静态成员的不足。可见，伴生对象的主要作用就是为其所在的外部类模拟静态成员。在 Java 代码中调用伴生对象如何在 Java 代码中调用 Kotlin 的伴生对象呢？ public static void main(String[] args) { 如果声明伴生对象有名称，则使用：类名.伴生对象名.方法名() 类名.半生对象名.属性的setter,getter方法如果声明伴生对象无名称，则采用 Companion 关键字调用： .Companion.方法名() @JvmField 和 @JvmStatic 的使用在上面的例子中，我们知道了可以在 Java 代码中调用 Kotlin 中伴生对象的成员，类似于 Java 类中的静态成员。但是看上去和 Java 中的还是略有区别，因为类名和方法名/属性setter,getter方法名之间多了个伴生对象的名称或者 Companion 关键字。如何使其在调用的时候与 Java 中的调用看上去一样呢？ Kotlin 为我们提供了 @JvmField 和 @JvmStatic 两个注解。@JvmField 使用在属性上，@JvmStatic 使用在方法上。如： class Test { 这样我们在 Java 代码中调用的时候就和 Java 类调用静态成员的形式一致了，Kotlin 代码调用方式不变： System.out.println(Test.flag); System.out.println(Test.add(1, 2)); const 关键字在伴生对象中，我们可能需要声明一个常量，目的是等同于 Java 中的静态常量。有两种方式，一种是上面所提到的使用 @JvmField 注解，另一种则是使用 const 关键字修饰。这两种声明方式都等同于 Java 中 static final 所修饰的变量。如下代码： companion 扩展属性和扩展方法扩展函数 Kotlin的扩展函数可以让你作为一个类成员进行调用的函数，但是是定义在这个类的外部。这样可以很方便的扩展一个已经存在的类，为它添加额外的方法下面我们为String添加一个toInt的方法 package com.binzi.kotlin 在这个扩展函数中，你可以直接访问你扩展的类的函数和属性，就像定义在这个类中的方法一样，但是扩展函数并不允许你打破封装。跟定义在类中方法不同，它不能访问那些私有的、受保护的方法和属性。扩展函数的导入我们直接在包里定义扩展函数。这样我们就可以在整个包里面使用这些扩展，如果我们要使用其他包的扩展，我们就需要导入它。导入扩展函数跟导入类是一样的方式。 import 有时候，可能你引入的第三方包都对同一个类型进行了相同函数名扩展，为了解决冲突问题，你可以使用下面的方式对扩展函数进行改名 import com.binzi.kotlin.toInt as toInteger 扩展函数不可覆盖扩展方法的原理 Kotlin 中类的扩展方法并不是在原类的内部进行拓展，通过反编译为Java代码，可以发现，其原理是使用装饰模式，对源类实例的操作和包装，其实际相当于我们在 Java中定义的工具类方法，并且该工具类方法是使用调用者为第一个参数的，然后在工具方法中操作该调用者如： fun String?.toInt(): 反编译为对应的Java代码： public 扩展属性类的扩展属性原理其实与扩展方法是一样的，只是定义的形式不同，扩展属性必须定义get和set方法为MutableList扩展一个firstElement属性: var 反编译后的java代码如下： public static final Object getFirstElement(@NotNull List $this$firstElement) { 内部类 kotlin的内部类与java的内部类有点不同java的内部类可以直接访问外部类的成员，kotlin的内部类不能直接访问外部类的成员，必须用inner标记之后才能访问外部类的成员没有使用inner标记的内部类 class A{ 反编译后的java代码 public 用inner标记的内部类 class A{ 反编译后的java代码 public 从上面可以看出，没有使用inner标记的内部类最后生成的是静态内部类，而使用inner标记的生成的是非静态内部类匿名内部类匿名内部类主要是针对那些获取抽象类或者接口对象而来的。最常见的匿名内部类View点击事件： //java,匿名内部类的写法上面这个是java匿名内部类的写法，kotlin没有new关键字，那么kotlin的匿名内部类该怎么写呢？ object : View.OnClickListener{ 方法的参数是一个匿名内部类，先写object:，然后写你的参数类型View.OnClickListener{} kotlin还有一个写法lambda 表达式，非常之方便： print( 数据类在Java中没有专门的数据类，常常是通过JavaBean来作为数据类，但在Kotlin中提供了专门的数据类。 Java public 从上面的例子中可以看到，如果要使用数据类，需要手动写相应的setter/getter方法(尽管IDE也可以批量生成)，但是从代码阅读的角度来说，在属性较多的情况下，诸多的seeter/getter方法还是不利于代码的阅读和维护。 Kotlin 在Kotlin中，可以通过关键字data来生成数据类： data 即在class关键字之前添加data关键字即可。编译器会根据主构造函数中的参数生成相应的数据类。自动生成setter/getter、toString、hashCode等方法要声明一个数据类，需要满足：主构造函数中至少有一个参数主构造函数中所有参数需要标记为val或var 数据类不能是抽象、开发、密封和内部的枚举类枚举类是一种特殊的类，kotlin可以通过enum class关键字定义枚举类。枚举类可以实现0~N个接口；枚举类默认继承于kotlin.Enum类(其他类最终父类都是Any)，因此kotlin枚举类不能继承类；非抽象枚举类不能用open修饰符修饰，因此非抽象枚举类不能派生子类；抽象枚举类不能使用abstract关键字修饰enum class，抽象方法和抽象属性需要使用；枚举类构造器只能使用private修饰符修饰，若不指定，则默认为private；枚举类所有实例在第一行显式列出，每个实例之间用逗号隔开，整个声明以分号结尾；枚举类是特殊的类，也可以定义属性、方法、构造器；枚举类应该设置成不可变类，即属性值不允许改变，这样更安全；枚举属性设置成只读属性后，最好在构造器中为枚举类指定初始值，如果在声明时为枚举指定初始值，会导致所有枚举值(或者说枚举对象)的该属性都一样。定义枚举类 / 定义一个枚举类 / 枚举类实现接口枚举值分别实现接口的抽象成员 enum 枚举类统一实现接口的抽象成员 enum 分别实现抽象枚举类抽象成员 enum 委托委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。委托模式是一项基本技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托模式使得我们可以用聚合来替代继承。 Java中委托： interface Printer { Kotlin： interface Printer { by表示 p 将会在 PrintImpl 中内部存储，并且编译器将自动生成转发给 p 的所有 Printer 的方法。委托属性有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现它们，但是如果能够为大家把他们只实现一次并放入一个库会更好。例如包括：延迟属性(lazy properties): 其值只在首次访问时计算；可观察属性(observable properties): 监听器会收到有关此属性变更的通知；把多个属性储存在一个映射(map)中，而不是每个存在单独的字段中。为了涵盖这些(以及其他)情况，Kotlin 支持委托属性。委托属性的语法是： var : 在 by 后面的表达式是该委托，因为属性对应的 get()(和 set())会被委托给它的 getValue() 和 setValue() 方法。标准委托： Kotlin 标准库为几种有用的委托提供了工厂方法。延迟属性 Lazy lazy() 接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托：第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果，后续调用 get() 只是返回记录的结果。例如： val lazyValue: String 可观察属性 Observable Delegates.observable() 接受两个参数：初始值和修改时处理程序(handler)。每当我们给属性赋值时会调用该处理程序(在赋值后执行)。它有三个参数：被赋值的属性、旧值和新值： class User { 如果想拦截赋的新值，并根据你是不是想要这个值来决定是否给属性赋新值，可以使用 vetoable() 取代 observable()，接收的参数和 observable 一样，不过处理程序返回值是 Boolean 来决定是否采用新值，即在属性被赋新值生效之前会调用传递给 vetoable 的处理程序。例如： class User { 把属性存在map 中一个常见的用例是在一个映射(map)里存储属性的值。这经常出现在像解析 JSON 或者做其他“动态”事情的应用中。在这种情况下，你可以使用映射实例自身作为委托来实现委托属性。例如： class User(map: Map 在上例中，委托属性会从构造函数传入的map中取值(通过字符串键——属性的名称)，如果遇到声明的属性名在map 中找不到对应的key 名，或者key 对应的value 值的类型与声明的属性的类型不一致，会抛出异常。内联函数当一个函数被声明为inline时，它的函数体是内联的，也就是说，函数体会被直接替换到函数被调用地方 inline函数(内联函数)从概念上讲是编译器使用函数实现的真实代码来替换每一次的函数调用，带来的最直接的好处就是节省了函数调用的开销，而缺点就是增加了所生成字节码的尺寸。基于此，在代码量不是很大的情况下，我们是否有必要将所有的函数定义为内联？让我们分两种情况进行说明：将普通函数定义为内联：众所周知，JVM内部已经实现了内联优化，它会在任何可以通过内联来提升性能的地方将函数调用内联化，并且相对于手动将普通函数定义为内联，通过JVM内联优化所生成的字节码，每个函数的实现只会出现一次，这样在保证减少运行时开销的同时，也没有增加字节码的尺寸；所以我们可以得出结论，对于普通函数，我们没有必要将其声明为内联函数，而是交给JVM自行优化。将带有lambda参数的函数定义为内联：是的，这种情况下确实可以提高性能；但在使用的过程中，我们会发现它是有诸多限制的，让我们从下面的例子开始展开说明： inline 假如我们这样调用doSomething: fun main(args: Array<String>) { 上面的调用会被编译成： fun main(args: Array<String>) { 从上面编译的结果可以看出，无论doSomething函数还是action参数都被内联了，很棒，那让我们换一种调用方式： fun main(args: Array<String>) { 上面的调用会被编译成： fun main(args: Array<String>) { doSomething函数被内联，而action参数没有被内联，这是因为以函数型变量的形式传递给doSomething的lambda在函数的调用点是不可用的，只有等到doSomething被内联后，该lambda才可以正常使用。通过上面的例子，我们对lambda表达式何时被内联做一下简单的总结：当lambda表达式以参数的形式直接传递给内联函数，那么lambda表达式的代码会被直接替换到最终生成的代码中。当lambda表达式在某个地方被保存起来，然后以变量形式传递给内联函数，那么此时的lambda表达式的代码将不会被内联。上面对lambda的内联时机进行了讨论，消化片刻后让我们再看最后一个例子： inline 上面的例子是否有问题？是的，编译器会抛出“Illegal usage of inline-parameter”的错误，这是因为Kotlin规定内联函数中的lambda参数只能被直接调用或者传递给另外一个内联函数，除此之外不能作为他用；那我们如果确实想要将某一个lambda传递给一个非内联函数怎么办？我们只需将上述代码这样改造即可： inline 很简单，在不需要内联的lambda参数前加上noinline修饰符就可以了。以上便是我对内联函数的全部理解，通过掌握该特性的运行机制，相信大家可以做到在正确的时机使用该特性，而非滥用或因恐惧弃而不用。 Kotlin下单例模式饿汉式实现 //Java实现懒汉式 //Java实现上述代码中，我们可以发现在Kotlin实现中，我们让其主构造函数私有化并自定义了其属性访问器，其余内容大同小异。如果有小伙伴不清楚Kotlin构造函数的使用方式。请点击 - - - 构造函数不清楚Kotlin的属性与访问器，请点击 - - -属性和字段线程安全的懒汉式 //Java实现大家都知道在使用懒汉式会出现线程安全的问题，需要使用使用同步锁，在Kotlin中，如果你需要将方法声明为同步，需要添加@Synchronized注解。双重校验锁式 //Java实现哇！小伙伴们惊喜不，感不感动啊。我们居然几行代码就实现了多行的Java代码。其中我们运用到了Kotlin的延迟属性 Lazy。 Lazy内部实现 public 观察上述代码，因为我们传入的mode = LazyThreadSafetyMode.SYNCHRONIZED，那么会直接走 SynchronizedLazyImpl，我们继续观察SynchronizedLazyImpl。 Lazy接口 SynchronizedLazyImpl实现了Lazy接口，Lazy具体接口如下： public 继续查看SynchronizedLazyImpl，具体实现如下： SynchronizedLazyImpl内部实现 private 通过上述代码，我们发现 SynchronizedLazyImpl 覆盖了Lazy接口的value属性，并且重新了其属性访问器。其具体逻辑与Java的双重检验是类似的。到里这里其实大家还是肯定有疑问，我这里只是实例化了SynchronizedLazyImpl对象，并没有进行值的获取，它是怎么拿到高阶函数的返回值呢？。这里又涉及到了委托属性。委托属性语法是：val/var : by 。在 by 后面的表达式是该委托，因为属性对应的 get()(和 set())会被委托给它的 getValue() 和 setValue() 方法。属性的委托不必实现任何的接口，但是需要提供一个 getValue() 函数(和 setValue()——对于 var 属性)。而Lazy.kt文件中，声明了Lazy接口的getValue扩展函数。故在最终赋值的时候会调用该方法。 internal.InlineOnly 静态内部类式 //Java实现静态内部类的实现方式，也没有什么好说的。Kotlin与Java实现基本雷同。补充在该篇文章结束后，有很多小伙伴咨询，如何在Kotlin版的Double Check，给单例添加一个属性，这里我给大家提供了一个实现的方式。(不好意思，最近才抽出时间来解决这个问题) class SingletonDemo private constructor( 其中关于?:操作符，如果 ?: 左侧表达式非空，就返回其左侧表达式，否则返回右侧表达式。请注意，当且仅当左侧为空时，才会对右侧表达式求值。 Kotlin 智能类型转换对于子父类之间的类型转换先看这样一段 Java 代码 public 尽管在 main 函数中，对 person 这个对象进行了类型判断，但是在使用的时候还是需要强制转换成 Student 类型，这样是不是很不智能？同样的情况在 Kotlin 中就变得简单多了 fun main(args: Array<String>) { 在 Kotlin 中，只要对类型进行了判断，就可以直接通过父类的对象去调用子类的函数了安全的类型转换还是上面的那个例子，如果我们没有进行类型判断，并且直接进行强转，会怎么样呢？ public static void main(String[] args) { 结果就只能是 Exception in thread "main" java.lang.ClassCastException 那么在 Kotlin 中是不是会有更好的解决方法呢？ val person: Person = Person() 在转换操作符后面添加一个 ?，就不会把程序 crash 掉了，当转化失败的时候，就会返回一个 null 在空类型中的智能转换需要提前了解 Kotlin 类型安全的相关知识(Kotlin 中的类型安全(对空指针的优化处理)) String? = aString 在定义的时候定义成了有可能为 null，按照之前的写法，我们需要这样写 String? = 但是已经进行了是否为 String 类型的判断，所以就一定不是空类型了，也就可以直接输出它的长度了 T.()->Unit 、 ()->Unit 在做kotlin开发中，经常看到一些系统函数里，用函数作为参数 public .()-Unit与()->Unit的区别是我们调用时，在代码块里面写this，的时候，两个this代表的含义不一样，T.()->Unit里的this代表的是自身实例，而()->Unit里，this代表的是外部类的实例。推荐阅读对 Kotlin 与 Java 编程语言的思考使用 Kotlin 做开发一个月后的感想扫一扫关注我的公众号如果你想要跟大家分享你的文章，欢迎投稿~ 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_39611037/article/details/109984124。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-06-23 23:56:14

470

转载

转载文章

[转载]Android P Beta！您想要知道的所有更新内容都在这里

...本识别 (Text Classifier) 在 Android P 中，我们将识别文本的机器学习模型进行了扩展，使得它可以识别出诸如日期或航班号这样的信息，并通过 TextClassifier API 来让开发者使用到这些改进。我们还更新了 Linkify API 来利用文本识别的结果生成链接，并为用户提供了更多点击后的选项，从而让他们得以更快地进行下一步操作。当然，开发者也可以在给文本识别出来的信息添加链接时拥有更多的选项。智能 Linkify 在识别精准度以及速度上都有明显的提升。这个模型现在正在通过 Google Play 进行更新，所以您的应用使用现有的 API 就可以享受到本次更新所带来的变化。在安装更新完的模型后，设备即可直接在本地识别文本里的各种信息，而且这些识别出来的信息只保存在您的手机上而不会通过网络流传出去。请点击蓝色字体前往 “Android Developers 官方文档”查看详细说明简洁 (Simplicity) 在 Android P，我们格外强调简洁，并据此改进 Android 的 UI 从而帮助用户们更流畅、更高效地完成操作。对开发者来说，简洁的系统则会帮助用户更容易查找、使用和管理您的应用。 · 全新系统导航 (New system navigation) 我们为 Android P 设计了全新的系统导航，只需使用下图中这个在所有界面中都能看到的小按钮，即可更轻松地访问手机主屏、概览页以及 Assistant。新导航系统也使多任务切换及发现关联应用变得更加简单。在概览页，用户可以拥有更大的视野来查看他们之前中断的操作，这自然也会让他们更容易找到并回到之前的应用中。概览页也提供了搜索、预测推荐应用以及上文提到的 App Actions，而且只需再多划一次即可进入所有应用的列表。 · 文字放大镜 (Text Magnifier) 在 Android P 中，我们加入了新的放大镜工具 (Magnifier widget)，使选择文本和调整光标位置变得更加轻松。默认情况下，所有继承自 TextView 的类都会自动支持放大镜，但您也可以使用放大镜 API 将它添加到任何自定义的视图上，从而打造更多样化的体验。 · 后台限制 (Background restrictions) 用户可以更加简单地找到并管理那些在后台消耗电量的应用。通过 Android Vitals 积累下来的成果，Android 可以识别那些过度消耗电量的行为，如滥用唤醒锁定等。在 Android P 中，电池设置页面直接列出了这些过度消耗电量的应用，用户只需一次点击就可以限制它们在后台的活动。一旦应用被限制，那么它的后台任务、警报、服务以及网络访问都会受限。想要避免被限制的话，请留意 Play Console 中的Android Vitals 控制面板，帮助您了解如何提高性能表现以及优化电量消耗。后台限制能有效保护系统资源不被恶意消耗，从而确保开发者的应用在不同制造商的不同设备上也能拥有一个基础的合理的运行环境。虽然制造商可以在限制列表上额外添加限制的应用，但它们也必须在电池设置页面为用户开放这些限制的控制权。我们添加了一个标准 API 来帮助应用知晓自己是否被限制，以及一个 ADB 命令来帮助开发者手动限制应用，从而进行测试。具体请参阅相关文档。接下来我们计划在 Play Console 的 Android Vitals 控制面板里添加一个统计数据，以展示应用受到限制的情况。 · 使用动态处理增强音频 (Enhanced audio with Dynamics Processing) Android P 在音频框架里加入了动态处理效果 (Dynamic Processing Effect) 来帮助开发者改善声音品质。通过动态处理，您可以分离出特定频率的声音，降低过大的音量，或者增强那些过小的音量。举例来说，即便说话者离麦克风较远，而且身处嘈杂或者被刺耳的各种环境音包围的地方，您的应用依然可以有效分离并增强他/她的细语。动态处理 API 提供了多声场、多频段的动态处理效果，包括一个预均衡器、一个多频段压缩器，一个后均衡器以及一个串联的音量限制器。这样您就可以根据用户的喜好或者环境的变化来控制 Android 设备输出的声音。频段数量以及各个声场的开关都完全可控，大多数参数都支持实时控制，如增益、信号的压缩/释放 (attack/release) 时长，阈值等等。请点击蓝色字体前往 “Android Developers 官方文档”查看详细说明安全 (Security) · 用户识别提示 (Biometric prompt) Android P 为市面上涌现出来的各种用户识别机制在系统层面提供了统一的使用体验，应用们不再需要自行提供用户识别操作界面，而只需要使用统一的 BiometricPrompt API 即可。这套全新的 API 替代了 DP1 版本中的 FingerprintDialog API，且支持包括指纹识别 (包括屏幕下指纹识别)、面部识别以及虹膜识别，而且所有系统支持的用户识别需求都包含在一个 USE_BIOMETRIC 权限里。FingerprintManager 以及对应的 USE_FINGERPRINT 权限已经被废弃，请开发者尽快转用 BiometricPrompt。 · 受保护的确认操作 (Protected Confirmation) Android P 新增了受保护的确认操作 (Android Protected Confirmation)，这个功能使用可信执行环境 (Trusted Execution Environment, TEE) 来确保一个显示出来的提示文本被真实用户确认。只有在用户确认之后，TEE 才会放行这个文本并可由应用去验证。 · 对私有密钥的增强保护 (Stronger protection for private keys) 我们添加了一个新的 KeyStore 类型，StrongBox。并提供对应的 API 来支持那些提供了防入侵硬件措施的设备，比如独立的 CPU，内存以及安全存储。您可以在 KeyGenParameterSpec 里决定您的密钥是否该交给 StrongBox 安全芯片来保存。 Android P Beta 为用户带来新版本的 Android 需要 Google、芯片供应商以及设备制造商和运营商的共同努力。这个过程中充满了技术挑战，并非一日之功 —— 为了让这个过程更加顺畅，去年我们启动了 Project Treble，并将其包含在 Android Oreo 中。我们与合作伙伴们一直在努力开发这个项目，也已经看到 Treble 所能带来的机遇。我们宣布，以下 6 家顶级合作伙伴将和我们一起把 Android P Beta 带给全世界的用户，这些设备包括：索尼 Xperia XZ2, 小米 Mi Mix 2S, 诺基亚 7 Plus, Oppo R15 Pro, Vivo X21UD 和 X21, 以及 Essential PH‑1。此外，再加上 Pixel 2, Pixel 2 XL, Pixel 和 Pixel XL，我们希望来自世界各地的早期体验者以及开发者们都能通过这些设备体验到 Android P Beta。您可查看今天推送的文章查阅支持 beta 体验的合作伙伴和 Pixel 设备清单，并能看到每款设备的详细配置说明。如果您使用 Pixel 设备，现在就可以加入 Android Beta program，然后自动获得最新的 Android P Beta。马上开始在您喜欢的设备上体验 Android P Beta 吧，欢迎您向我们反馈意见和建议！并请继续关注 Project Treble 的最新动态。确保 app 兼容随着越来越多的用户开始体验 Android P Beta，是时候开始测试您 app 的兼容性，以尽早解决在测试中发现的问题并尽快发布更新。请查看迁移手册了解操作步骤以及 Android P 的时间推进表。请从 Google Play 下载您的应用，并在运行 Android P Beta 的设备或模拟器上测试用户流程。确保您的应用体验良好，并正确处理 Android P 的行为变更。尤其注意动态电量管理、Wi-Fi 权限变化、后台调用摄像头以及传感器的限制、针对应用数据的 SELinux 政策、默认启用 TLS 的变化，以及 Build.SERIAL 限制。 · 公开 API 的兼容性 (Compatibility through public APIs) 针对非 SDK 接口的测试十分重要。正如我们之前所强调的，在 Android P 中，我们将逐渐收紧一些非 SDK 接口的使用，这也要求广大的开发者们，包括 Google 内部的应用团队，使用公开 API。如果您的应用正在使用私有 Android API 或者库，您需要改为使用 Android SDK 或 NDK 公开的 API。我们在 DP1 里已经对使用私有接口的开发者发出了警告信息，从 Android P Beta 开始，调用非 SDK 接口将会报错 (部分被豁免的私有 API 除外) —— 也就是说您的应用将会遭遇异常，而不再只是警告了。为了帮助您定位非 SDK API 的使用情况，我们在 StrictMode 里加入了两个新的方法。您可以使用 detectNonSdkApiUsage() 在应用通过反射或 JNI 调用非 SDK API 的时候收到警报，您还可以使用 permitNonSdkApiUsage() 来阻止 StrictMode 针对这些调用报错。这些方法都可助您了解应用调用非 SDK API 的情况，但请注意，即便调用的 API 暂时得到了豁免，最保险的做法依然是尽快放弃对它们的使用。如果您确实遇到了公开 API 无法满足需求的情况，请立刻告知我们。更多详细内容请查看相关文档。 · 凹口屏测试 (Test with display cutout) 针对凹口屏测试您的应用也十分重要。现在您可以在运行 Android P Beta 的合作伙伴机型上测试，确保您的应用在凹口屏上表现良好。同时，您也可以在 Android P 设备的开发者选项里打开对凹口屏的模拟，对您的应用做相应测试。体验 Android P 在准备好开发条件后，请深入了解 Android P 并学习可以在您的应用中使用到的全新功能和 API。为了帮助您更轻松地探索和使用新 API，请查阅 API 变化报告 (API 27->DP2, DP1->DP2) 以及 Android P API 文档。访问开发者预览版网站了解详情。下载/更新 Android P 开发者预览版 SDK 和工具包至 Android Studio 3.1，或使用最新版本的 Android Studio 3.2。如果您手边没有 Android P Beta 设备 (或查看今天推送的次条文章)，请使用 Android P 模拟器来运行和测试您的应用。您的反馈一直都至关重要，我们欢迎您畅所欲言。如果您在开发或测试过程中遇到了问题，请在文章下方留言给我们。再次感谢大家一路以来的支持。请点击蓝色字体前往 “Android Developers 官方文档”查看详细说明本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_34258782/article/details/87952581。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-04-10 18:19:36

338

转载

转载文章

[转载]调用阿里云API实现证件照生成

...plt.show()class SeedNet(nn.Module):def __init__(self,nstacks=2,nblocks=1,njoints=21,block=BottleneckBlock,):super(SeedNet, self).__init__()self.njoints = njointsself.nstacks = nstacksself.in_planes = 64self.conv1 = nn.Conv2d(3, self.in_planes, kernel_size=7, stride=2, padding=3, bias=True)self.bn1 = nn.BatchNorm2d(self.in_planes)self.relu = nn.ReLU(inplace=True)self.maxpool = nn.MaxPool2d(2, stride=2)self.layer1 = self._make_residual(block, nblocks, self.in_planes, 2self.in_planes) current self.in_planes is 64 2 = 128self.layer2 = self._make_residual(block, nblocks, self.in_planes, 2self.in_planes) current self.in_planes is 128 2 = 256self.layer3 = self._make_residual(block, nblocks, self.in_planes, self.in_planes)ch = self.in_planes 256hg2b, res1, res2, fc1, _fc1, fc2, _fc2= [],[],[],[],[],[],[]hm, _hm, mask, _mask = [], [], [], []for i in range(nstacks): 2hg2b.append(HourglassBisected(block, nblocks, ch, depth=4))res1.append(self._make_residual(block, nblocks, ch, ch))res2.append(self._make_residual(block, nblocks, ch, ch))fc1.append(self._make_fc(ch, ch))fc2.append(self._make_fc(ch, ch))hm.append(nn.Conv2d(ch, njoints, kernel_size=1, bias=True))mask.append(nn.Conv2d(ch, 1, kernel_size=1, bias=True))if i < nstacks-1:_fc1.append(nn.Conv2d(ch, ch, kernel_size=1, bias=False))_fc2.append(nn.Conv2d(ch, ch, kernel_size=1, bias=False))_hm.append(nn.Conv2d(njoints, ch, kernel_size=1, bias=False))_mask.append(nn.Conv2d(1, ch, kernel_size=1, bias=False))self.hg2b = nn.ModuleList(hg2b) hgs: hourglass stackself.res1 = nn.ModuleList(res1)self.fc1 = nn.ModuleList(fc1)self._fc1 = nn.ModuleList(_fc1)self.res2 = nn.ModuleList(res2)self.fc2 = nn.ModuleList(fc2)self._fc2 = nn.ModuleList(_fc2)self.hm = nn.ModuleList(hm)self._hm = nn.ModuleList(_hm)self.mask = nn.ModuleList(mask)self._mask = nn.ModuleList(_mask)def _make_fc(self, in_planes, out_planes):bn = nn.BatchNorm2d(in_planes)conv = nn.Conv2d(in_planes, out_planes, kernel_size=1, bias=False)return nn.Sequential(conv, bn, self.relu)def _make_residual(self, block, nblocks, in_planes, out_planes):layers = []layers.append( block( in_planes, out_planes) )self.in_planes = out_planesfor i in range(1, nblocks):layers.append(block( self.in_planes, out_planes))return nn.Sequential(layers)def forward(self, x):l_hm, l_mask, l_enc = [], [], []x = self.conv1(x) x: (N,64,128,128)x = self.bn1(x)x = self.relu(x)x = self.layer1(x)x = self.maxpool(x) x: (N,128,64,64)x = self.layer2(x)x = self.layer3(x)for i in range(self.nstacks): 2y_1, y_2, _ = self.hg2b[i](x)y_1 = self.res1[i](y_1)y_1 = self.fc1[i](y_1)est_hm = self.hm[i](y_1)l_hm.append(est_hm)y_2 = self.res2[i](y_2)y_2 = self.fc2[i](y_2)est_mask = self.mask[i](y_2)l_mask.append(est_mask)if i < self.nstacks-1:_fc1 = self._fc1[i](y_1)_hm = self._hm[i](est_hm)_fc2 = self._fc2[i](y_2)_mask = self._mask[i](est_mask)x = x + _fc1 + _fc2 + _hm + _maskl_enc.append(x)else:l_enc.append(x + y_1 + y_2)assert len(l_hm) == self.nstacksreturn l_hm, l_mask, l_encif __name__ == '__main__':a = torch.randn(10, 3, 256, 256) SeedNetmodel = SeedNet() output1,output2,output3 = SeedNetmodel(a) print(output1,output2,output3)total_params = sum(p.numel() for p in SeedNetmodel.parameters())/1000000print("Total parameters: ", total_params)pretrained_weights_path = 'E:/bihand/released_checkpoints/ckp_seednet_all.pth.tar'img_rgb_path=r"E:\FreiHAND\training\rgb\00000153.jpg"img=io.imread(img_rgb_path)resized_img = transform.resize(img, (256, 256), anti_aliasing=True)img256=util.img_as_ubyte(resized_img)plt.imshow(resized_img)plt.axis('off') 关闭坐标轴plt.show()''' implicit HWC -> CHW, 255 -> 1 '''img1 = func.to_tensor(img256).float() 转换为张量并且进行标准化处理''' 0-mean, 1 std, [0,1] -> [-0.5, 0.5] '''img2 = func.normalize(img1, [0.5, 0.5, 0.5], [1, 1, 1])img3 = torch.unsqueeze(img2, 0)ok=img3print(img.shape)SeedNetmodel = SeedNet()misc.load_checkpoint(SeedNetmodel, pretrained_weights_path)加载权重output1, output2, output3 = SeedNetmodel(img3)mask_tensor = torch.rand(1, 64, 64)output=output2[1] 1,1,64,64output_1=output[0] 1,64,64output_ok=torch.sigmoid(output_1[0])output_real=output_1[0].detach().numpy()直接产生的张量图color_mask=color_mask(output_ok) 显示彩色分割图two_color=two_color(output_ok)显示黑白分割图see=output_ok.detach().numpy() 使用Matplotlib库显示分割掩码 plt.imshow(see, cmap='gray') plt.axis('off') plt.show() print(output1, output2, output3)images = [resized_img, color_mask, two_color,output_real,see,see]rows = 1cols = 4 创建子图并展示图像fig, axes = plt.subplots(1, 6, figsize=(30, 5)) 遍历图像列表，并在每个子图中显示图像for i, image in enumerate(images):ax = axes[i] if cols > 1 else axes 如果只有一列，则直接使用axesif i ==5:ax.imshow(image, cmap='gray')else:ax.imshow(image)ax.imshowax.axis('off') 调整子图之间的间距plt.subplots_adjust(wspace=0.1, hspace=0.1) 展示图像plt.show() 上述的代码文件是在bihand/models/net_seed.py中，全部代码链接在https://github.com/lixiny/bihand。把bihand/models/net_seed.p中的代码修改为我提供的代码即可使用作者训练好的模型和进行各种可视化。（预训练模型根据作者代码提示下载） 3.调用阿里云API进行证件照生成实例 3.1 准备工作 1.找到接口进入下面链接即可快速访问 link 2.购买试用包 3.查看APPcode 4.下载代码 5.参数说明 3.2 实验代码 !/usr/bin/python encoding: utf-8"""===========================证件照制作接口==========================="""import requestsimport jsonimport base64import hashlibclass Idphoto:def __init__(self, appcode, timeout=7):self.appcode = appcodeself.timeout = timeoutself.make_idphoto_url = 'https://idp2.market.alicloudapi.com/idphoto/make'self.headers = {'Authorization': 'APPCODE ' + appcode,}def get_md5_data(self, body):"""md5加密:param body_json::return:"""md5lib = hashlib.md5()md5lib.update(body.encode("utf-8"))body_md5 = md5lib.digest()body_md5 = base64.b64encode(body_md5)return body_md5def get_photo_base64(self, file_path):with open(file_path, 'rb') as fp:photo_base64 = base64.b64encode(fp.read())photo_base64 = photo_base64.decode('utf8')return photo_base64def aiseg_request(self, url, data, headers):resp = requests.post(url=url, data=data, headers=headers, timeout=self.timeout)res = {"status_code": resp.status_code}try:res["data"] = json.loads(resp.text)return resexcept Exception as e:print(e)def make_idphoto(self, file_path, bk, spec="2"):"""证件照制作接口:param file_path::param bk::param spec::return:"""photo_base64 = self.get_photo_base64(file_path)body_json = {"photo": photo_base64,"bk": bk,"with_photo_key": 1,"spec": spec,"type": "jpg"}body = json.dumps(body_json)body_md5 = self.get_md5_data(body=body)self.headers.update({'Content-MD5': body_md5})data = self.aiseg_request(url=self.make_idphoto_url, data=body, headers=self.headers)return dataif __name__ == "__main__":file_path = "图片地址"idphoto = Idphoto(appcode="你的appcode")d = idphoto.make_idphoto(file_path, "red", "2")print(d) 3.3 实验结果与分析原图片背景为红色生成的证件照背景为蓝色生成的证件照另外尝试了使用柴犬照片做实验，也生成了证件照原图背景为红色生成的证件照参考（可供参考的链接和引用文献） 1.参考：BiHand: Recovering Hand Mesh with Multi-stage Bisected Hourglass Networks（BMVC2020）论文链接：https://arxiv.org/pdf/2008.05079.pdf 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_37758063/article/details/131128967。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-07-11 23:36:51

131

转载

转载文章

[转载]arm-1

...标也同样会执行 – 条件判断 ifeq ifneq ifdef ifndef – makefile函数使用 shell脚本类似于windoes的批处理文件将连续执行的命令写成一个文件 shell脚本可以提供数组，循环，条件判断等功能开头必须是：!/bin/bash 表示使用bash 脚本的扩展名：.sh – 交互式shell 有输入有输出输入：read 第三行 name在这里作为变量，read输入这个变量下一行使用这个变量直接是 $name，不用像 Makefile 里面那样子加括号 read -p “读取前你想打印的内容” 变量1 变量2 变量3… – 数值计算第五行等于号两边不能有空格右边计算的时候是 $( ( ) )，注意要两个括号 – test 测试命令文件状态查询，字符、数字比较 && cmd1 && cmd2 当cmd1执行完并且正确，那么cmd2也执行当cmd2执行完并且错误，那么cmd2不执行 || cmd1 || cmd2 当cmd1执行完并且正确，那么cmd2不执行当cmd2执行完并且错误，那么cmd2也执行查看一个文件是否存在 – 测试两个字符串是否相等 ==两边必须要有空格，如果不加空格，test这句就一直是对的。 – 中括号判断符 [ ] 作用和test类似里面只能输入 == 或者！= 四个箭头所指必须用空格隔开而且如果变量是字符串的话，一定要加双引号 – 默认变量 $0——shell脚本本身的命令 $——最后一个参数的标号（1，2，3，4…） $@——表示 $1 , $2 , $3 … $1 $2 $3 – shell 脚本的条件判断 if [ 条件判断 ];then //do something fi 红点处都要加空格 exit 0——表示退出 – if 条件判断;then //do something elif 条件判断;them //do something else //do something fi 红线处要加空格 – case 语句 case $var in “第一个变量的内容”) //do something ;; “第二个变量的内容”) // do something ;; . . . “第n个变量的内容”) //do something ;; esac 不能用 “”，否则就不是通配符的意思，而是表示字符 – shell 脚本函数 function fname(){ //函数代码段 } 其中function可以写也可以不写调用函数的时候不要加括号 shell 脚本函数传参方式 – shell 循环 while[条件] //括号内的状态是判断式 do //循环代码段 done – until [条件] do //循环代码段 done – for循环，使用该循环可以知道有循环次数 for var con1 con2 con3 … … do //循环代码段 done – for 循环数值处理 for((初始值；限制值；执行步长)) do //循环代码段 done – 红点处必须要加空格！！ loop 环 – – 注意变量有的地方用了 $ ，有的地方不需要 $ 这里的赋值号两边都不用加空格 $(())数值运算本篇文章为转载内容。原文链接：https://blog.csdn.net/engineer0/article/details/107965908。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-11-23 17:18:30

转载

转载文章

[转载]JavaScript中的时间与日期、正则表达式和Function类型

...用这种数据存储格式的条件下，Date 类型保存的日期能够精确到 1970 年 1 月 1 日之前或之后的 285616 年。创建一个日期对象，使用 new 运算符和 Date 构造方法（构造函数）即可。 var box = new Date(); // 创建一个日期对象在调用 Date 构造方法而不传递参数的情况下，新建的对象自动获取当前的时间和日期。 alert(box); // 不同浏览器显示不同 ECMAScript 提供了两个方法，Date.parse()和 Date.UTC()。Date.parse()方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应的毫秒数。ECMA-262 没有定义 Date.parse()应该支持哪种日期格式，因此方法的行为因实现而异，因地区而异。默认通常接收的日期格式如下： ‘月/日/年’，如 6/13/2011; ‘英文月名日, 年’，如 May 25, 2004; ‘英文星期几英文月名日年时:分:秒时区’，如 Tue May 25 2004 00:00:00 GMT-070 alert(Date.parse('6/13/2011')); // 1307894400000 如果 Date.parse()没有传入或者不是标准的日期格式，那么就会返回 NaN。 alert(Date.parse()); // NaN 如果想输出指定的日期，那么把 Date.parse()传入 Date 构造方法里。 var box = new Date(Date.parse('6/13/2011')); // Mon Jun 13 2011 00:00:00 GMT+0800var box = new Date('6/13/2011'); // 直接传入，Date.parse()后台被调用 Date 对象及其在不同浏览器中的实现有许多奇怪的行为。其中有一种倾向是将超出的范围的值替换成当前的值，以便生成输出。例如，在解析“January 32, 2007”时，有的浏览器会将其解释为“February 1, 2007”。而 Opera 则倾向与插入当前月份的当前日期。 Date.UTC()方法同样也返回表示日期的毫秒数，但它与 Date.parse()在构建值时使用不同的信息。（年份，基于 0 的月份[0 表示 1 月，1 表示 2 月]，月中的哪一天[1-31]，小时数[0-23] ，分钟，秒以及毫秒)。只有前两个参数是必须的。如果没有提供月数，则天数为 1；如果省略其他参数，则统统为 0。 alert(Date.UTC(2011,11)); // 1322697600000 如果 Date.UTC()参数传递错误，那么就会出现负值或者 NaN 等非法信息。 alert(Date.UTC()); // 负值或者 NaN 如果要输出指定日期，那么直接把 Date.UTC()传入 Date 构造方法里即可。 var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16)); 通用的方法与其他类型一样，Date 类型也重写了 toLocaleString()、toString()和 valueOf()方法；但这些方法返回值与其他类型中的方法不同。 var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16));alert('toString:' + box.toString());alert('toLocaleString:' + box.toLocaleString()); // 按本地格式输出这两个方法在不同浏览器显示的效果又不一样，但不用担心，这两个方法只是在调试比较有用，在显示时间和日期上，没什么价值。valueOf()方法显示毫秒数。日期格式化方法 Date 类型还有一些专门用于将日期格式化为字符串的方法。 var box = new Date();alert(box.toDateString()); // 以特定的格式显示星期几、月、日和年alert(box.toTimeString()); // 以特定的格式显示时、分、秒和时区alert(box.toLocaleDateString()); // 以特定地区格式显示星期几、月、日和年alert(box.toLocaleTimeString()); // 以特定地区格式显示时、分、秒和时区alert(box.toUTCString()); // 以特定的格式显示完整的 UTC 日期组件方法组件方法，是为我们单独获取你想要的各种时间/日期而提供的方法。需要注意的时候，这些方法中，有带 UTC 的，有不带 UTC 的。UTC 日期指的是在没有时区偏差的情况下的日期值。 alert(box.getTime()); // 获取日期的毫秒数，和 valueOf()返回一致alert(box.setTime(100)); // 以毫秒数设置日期，会改变整个日期alert(box.getFullYear()); // 获取四位年份alert(box.setFullYear(2012)); // 设置四位年份，返回的是毫秒数alert(box.getMonth()); // 获取月份，没指定月份，从 0 开始算起alert(box.setMonth(11)); // 设置月份alert(box.getDate()); // 获取日期alert(box.setDate(8)); // 设置日期，返回毫秒数alert(box.getDay()); // 返回星期几，0 表示星期日，6 表示星期六alert(box.setDay(2)); // 设置星期几alert(box.getHours()); // 返回时alert(box.setHours(12)); // 设置时alert(box.getMinutes()); // 返回分钟alert(box.setMinutes(22)); // 设置分钟alert(box.getSeconds()); // 返回秒数alert(box.setSeconds(44)); // 设置秒数alert(box.getMilliseconds()); // 返回毫秒数alert(box.setMilliseconds()); // 设置毫秒数alert(box.getTimezoneOffset()); // 返回本地时间和 UTC 时间相差的分钟数以上方法除了 getTimezoneOffset()，其他都具有 UTC 功能，例如 setDate()及 getDate()获取星期几，那么就会有 setUTCDate()及getUTCDate()，表示世界协调时间。 2、正则表达式假设用户需要在 HTML 表单中填写姓名、地址、出生日期等。那么在将表单提交到服务器进一步处理前，JavaScript 程序会检查表单以确认用户确实输入了信息并且这些信息是符合要求的。什么是正则表达式正则表达式（regular expression）是一个描述字符模式的对象。ECMAScript 的 RegExp 类表示正则表达式，而 String 和 RegExp 都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。正则表达式主要用来验证客户端的输入数据。用户填写完表单单击按钮之后，表单就会被发送到服务器，在服务器端通常会用 PHP、ASP.NET 等服务器脚本对其进行进一步处理。因为客户端验证，可以节约大量的服务器端的系统资源，并且提供更好的用户体验。创建正则表达式创建正则表达式和创建字符串类似，创建正则表达式提供了两种方法，一种是采用 new 运算符，另一个是采用字面量方式。两种创建方式 var box = new RegExp('box'); // 第一个参数字符串var box = new RegExp('box', 'ig'); // 第二个参数可选模式修饰符模式修饰符的可选参数参数含义 i 忽略大小写 g 全局匹配 m 多行匹配 var box = /box/; // 直接用两个反斜杠var box = /box/ig; // 在第二个斜杠后面加上模式修饰符测试正则表达式 RegExp 对象包含两个方法：test()和 exec()，功能基本相似，用于测试字符串匹配。test()方法在字符串中查找是否存在指定的正则表达式并返回布尔值，如果存在则返回 true，不存在则返回 false。exec()方法也用于在字符串中查找指定正则表达式，如果 exec()方法执行成功，则返回包含该查找字符串的相关信息数组。如果执行失败，则返回 null。 RegExp 对象的方法方法功能 test 在字符串中测试模式匹配，返回 true 或 false exec 在字符串中执行匹配搜索，返回结果数组 // 使用 new 运算符的 test 方法示例var pattern = new RegExp('box', 'i'); // 创建正则模式，不区分大小写var str = 'This is a Box!'; // 创建要比对的字符串alert(pattern.test(str)); // 通过 test()方法验证是否匹配// 使用字面量方式的 test 方法示例var pattern = /box/i; // 创建正则模式，不区分大小写var str = 'This is a Box!';alert(pattern.test(str));// 使用一条语句实现正则匹配alert(/box/i.test('This is a Box!')); // 模式和字符串替换掉了两个变量// 使用 exec 返回匹配数组var pattern = /box/i;var str = 'This is a Box!';alert(pattern.exec(str)); // 匹配了返回数组，否则返回 null 使用字符串的正则表达式方法除了 test()和 exec()方法，String 对象也提供了 4 个使用正则表达式的方法。 String 对象中的正则表达式方法方法含义 match(pattern) 返回 pattern 中的子串或 null replace(pattern, replacement) 用 replacement 替换 pattern search(pattern) 返回字符串中 pattern 开始位置 split(pattern) 返回字符串按指定 pattern 拆分的数组 // 使用 match 方法获取获取匹配数组var pattern = /box/ig; // 全局搜索var str = 'This is a Box!，That is a Box too';alert(str.match(pattern)); // 匹配到两个 Box,Boxalert(str.match(pattern).length); // 获取数组的长度// 使用 search 来查找匹配数据var pattern = /box/ig;var str = 'This is a Box!，That is a Box too';alert(str.search(pattern)); // 查找到返回位置，否则返回-1 因为 search 方法查找到即返回，也就是说无需 g 全局。 // 使用 replace 替换匹配到的数据var pattern = /box/ig;var str = 'This is a Box!，That is a Box too';alert(str.replace(pattern, 'Tom')); // 将 Box 替换成了 Tom// 使用 split 拆分成字符串数组var pattern = / /ig;var str = 'This is a Box!，That is a Box too';alert(str.split(pattern)); // 将空格拆开分组成数组 RegExp 对象的静态属性属性短名含义 input $_ 当前被匹配的字符串 lastMatch $& 最后一个匹配字符串 lastParen $+ 最后一对圆括号内的匹配子串 leftContext $ 最后一次匹配前的子串 multiline $ 用于指定是否所有的表达式都用于多行的布尔值 rightContext $’ 在上次匹配之后的子串 // 使用静态属性var pattern = /(g)oogle/;var str = 'This is google！';pattern.test(str); // 执行一下alert(RegExp.input); // This is google！alert(RegExp.leftContext); // This isalert(RegExp.rightContext); // ！alert(RegExp.lastMatch); // googlealert(RegExp.lastParen); // galert(RegExp.multiline); // false Opera 不支持 input、lastMatch、lastParen 和 multiline 属性。IE 不支持 multiline 属性。所有的属性可以使用短名来操作。RegExp.input 可以改写成 RegExp['$_']，依次类推。但 RegExp.input 比较特殊，它还可以写成 RegExp.$_。 RegExp 对象的实例属性属性含义 global Boolean 值，表示 g 是否已设置 ignoreCase Boolean 值，表示 i 是否已设置 lastIndex 整数，代表下次匹配将从哪里字符位置开始 multiline Boolean 值，表示 m 是否已设置 Source 正则表达式的源字符串形式 // 使用实例属性var pattern = /google/ig;alert(pattern.global); // true，是否全局了alert(pattern.ignoreCase); // true，是否忽略大小写alert(pattern.multiline); // false，是否支持换行alert(pattern.lastIndex); // 0，下次的匹配位置alert(pattern.source); // google，正则表达式的源字符串var pattern = /google/g;var str = 'google google google';pattern.test(str); // google，匹配第一次alert(pattern.lastIndex); // 6，第二次匹配的位以上基本没什么用。并且 lastIndex 在获取下次匹配位置上 IE 和其他浏览器有偏差，主要表现在非全局匹配上。lastIndex 还支持手动设置，直接赋值操作。获取控制正则表达式元字符是包含特殊含义的字符。它们有一些特殊功能，可以控制匹配模式的方式。反斜杠后的元字符将失去其特殊含义。字符类：单个字符和数字元字符/元符号匹配情况 . 匹配除换行符外的任意字符 [a-z0-9] 匹配括号中的字符集中的任意字符 [^a-z0-9] 匹配任意不在括号中的字符集中的字符 \d 匹配数字 \D 匹配非数字，同[^0-9]相同 \w 匹配字母和数字及_ \W 匹配非字母和数字及_ 字符类：空白字符元字符/元符号匹配情况 \0 匹配 null 字符 \b 匹配空格字符 \f 匹配进纸字符 \n 匹配换行符 \r 匹配回车字符 \t 匹配制表符 \s 匹配空白字符、空格、制表符和换行符 \S 匹配非空白字符字符类：锚字符元字符/元符号匹配情况 ^ 行首匹配 $ 行尾匹配 \A 只有匹配字符串开始处 \b 匹配单词边界，词在[]内时无效 \B 匹配非单词边界 \G 匹配当前搜索的开始位置 \Z 匹配字符串结束处或行尾 \z 只匹配字符串结束处字符类：重复字符元字符/元符号匹配情况 x? 匹配 0 个或 1 个 x x 匹配 0 个或任意多个 x x+ 匹配至少一个 x (xyz)+ 匹配至少一个(xyz) x{m,n} 匹配最少 m 个、最多 n 个 x 字符类：替代字符元字符/元符号匹配情况 this where 字符类：记录字符元字符/元符号匹配情况 (string) 用于反向引用的分组 \1 或$1 匹配第一个分组中的内容 \2 或$2 匹配第二个分组中的内容 \3 或$3 匹配第三个分组中的内容 // 使用点元字符var pattern = /g..gle/; // .匹配一个任意字符var str = 'google';alert(pattern.test(str));// 重复匹配var pattern = /g.gle/; // .匹配 0 个一个或多个var str = 'google'; //,?,+,{n,m}alert(pattern.test(str));// 使用字符类匹配var pattern = /g[a-zA-Z_]gle/; // [a-z]表示任意个 a-z 中的字符var str = 'google';alert(pattern.test(str));var pattern = /g[^0-9]gle/; // [^0-9]表示任意个非 0-9 的字符var str = 'google';alert(pattern.test(str));var pattern = /[a-z][A-Z]+/; // [A-Z]+表示 A-Z 一次或多次var str = 'gOOGLE';alert(pattern.test(str));// 使用元符号匹配var pattern = /g\wgle/; // \w匹配任意多个所有字母数字_var str = 'google';alert(pattern.test(str));var pattern = /google\d/; // \d匹配任意多个数字var str = 'google444';alert(pattern.test(str));var pattern = /\D{7,}/; // \D{7,}匹配至少 7 个非数字var str = 'google8';alert(pattern.test(str));// 使用锚元字符匹配var pattern = /^google$/; // ^从开头匹配，$从结尾开始匹配var str = 'google';alert(pattern.test(str));var pattern = /goo\sgle/; // \s 可以匹配到空格var str = 'goo gle';alert(pattern.test(str));var pattern = /google\b/; // \b 可以匹配是否到了边界var str = 'google';alert(pattern.test(str));// 使用或模式匹配var pattern = /google|baidu|bing/; // 匹配三种其中一种字符串var str = 'google';alert(pattern.test(str));// 使用分组模式匹配var pattern = /(google){4,8}/; // 匹配分组里的字符串 4-8 次var str = 'googlegoogle';alert(pattern.test(str));var pattern = /8(.)8/; // 获取 8..8 之间的任意字符var str = 'This is 8google8';str.match(pattern);alert(RegExp.$1); // 得到第一个分组里的字符串内容var pattern = /8(.)8/;var str = 'This is 8google8';var result = str.replace(pattern,'<strong>$1</strong>'); // 得到替换的字符串输出document.write(result);var pattern = /(.)\s(.)/;var str = 'google baidu';var result = str.replace(pattern, '$2 $1'); // 将两个分组的值替换输出document.write(result); 贪婪惰性 + +? ? ?? ? {n} {n}? {n,} {n,}? {n,m} {n,m}? // 关于贪婪和惰性var pattern = /[a-z]+?/; // ?号关闭了贪婪匹配，只替换了第一个var str = 'abcdefjhijklmnopqrstuvwxyz';var result = str.replace(pattern, 'xxx');alert(result);var pattern = /8(.+?)8/g; // 禁止了贪婪，开启的全局var str = 'This is 8google8, That is 8google8, There is 8google8';var result = str.replace(pattern,'<strong>$1</strong>');document.write(result);var pattern = /8([^8])8/g; // 另一种禁止贪婪var str = 'This is 8google8, That is 8google8, There is 8google8';var result = str.replace(pattern,'<strong>$1</strong>');document.write(result);// 使用 exec 返回数组var pattern = /^[a-z]+\s[0-9]{4}$/i;var str = 'google 2012';alert(pattern.exec(str)); // 返回整个字符串var pattern = /^[a-z]+/i; // 只匹配字母var str = 'google 2012';alert(pattern.exec(str)); // 返回 googlevar pattern = /^([a-z]+)\s([0-9]{4})$/i; // 使用分组var str = 'google 2012';alert(pattern.exec(str)[0]); // google 2012alert(pattern.exec(str)[1]); // googlealert(pattern.exec(str)[2]); // 2012// 捕获性分组和非捕获性分组var pattern = /(\d+)([a-z])/; // 捕获性分组var str = '123abc';alert(pattern.exec(str));var pattern = /(\d+)(?:[a-z])/; // 非捕获性分组var str = '123abc';alert(pattern.exec(str));// 使用分组嵌套var pattern = /(A?(B?(C?)))/; // 从外往内获取var str = 'ABC';alert(pattern.exec(str));// 使用前瞻捕获var pattern = /(goo(?=gle))/; // goo 后面必须跟着 gle 才能捕获var str = 'google';alert(pattern.exec(str));// 使用特殊字符匹配var pattern = /\.\[\/b\]/; // 特殊字符，用\符号转义即可var str = '.[/b]';alert(pattern.test(str));// 使用换行模式var pattern = /^\d+/mg; // 启用了换行模式var str = '1.baidu\n2.google\n3.bing';var result = str.replace(pattern, '');alert(result); 常用的正则检查邮政编码 var pattern = /[1-9][0-9]{5}/; // 共 6 位数字，第一位不能为 0var str = '224000';alert(pattern.test(str)); 检查文件压缩包 var pattern = /[\w]+\.zip|rar|gz/; // \w 表示所有数字和字母加下划线var str = '123.zip'; // \.表示匹配.，后面是一个选择alert(pattern.test(str)); 删除多余空格 var pattern = /\s/g; // g 必须全局，才能全部匹配var str = '111 222 333';var result = str.replace(pattern,''); // 把空格匹配成无空格alert(result); 删除首尾空格 var pattern = /^\s+/; // 强制首var str = ' goo gle ';var result = str.replace(pattern, '');pattern = /\s+$/; // 强制尾result = result.replace(pattern, '');alert('|' + result + '|');var pattern = /^\s(.+?)\s$/; // 使用了非贪婪捕获var str = ' google ';alert('|' + pattern.exec(str)[1] + '|');var pattern = /^\s(.+?)\s$/;var str = ' google ';alert('|' + str.replace(pattern, '$1') + '|'); // 使用了分组获取简单的电子邮件验证 var pattern = /^([a-zA-Z0-9_\.\-]+)@([a-zA-Z0-9_\.\-]+)\.([a-zA-Z]{2,4})$/;var str = 'yc60.com@gmail.com';alert(pattern.test(str));var pattern = /^([\w\.\-]+)@([\w\.\-]+)\.([\w]{2,4})$/;var str = 'yc60.com@gmail.com';alert(pattern.test(str)); 3、Function类型在 ECMAScript 中，Function（函数）类型实际上是对象。每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针。函数的声明方式普通的函数声明 function box(num1, num2) {return num1+ num2;} 使用变量初始化函数 var box= function(num1, num2) {return num1 + num2;}; 使用 Function 构造函数 var box= new Function('num1', 'num2' ,'return num1 + num2'); 第三种方式我们不推荐，因为这种语法会导致解析两次代码（第一次解析常规 ECMAScript 代码，第二次是解析传入构造函数中的字符串），从而影响性能。但我们可以通过这种语法来理解"函数是对象，函数名是指针"的概念。作为值的函数 ECMAScript 中的函数名本身就是变量，所以函数也可以作为值来使用。也就是说，不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回。 function box(sumFunction, num) {return sumFunction(num); // someFunction}function sum(num) {return num + 10;}var result = box(sum, 10); // 传递函数到另一个函数里函数内部属性在函数内部，有两个特殊的对象：arguments 和 this。arguments 是一个类数组对象，包含着传入函数中的所有参数，主要用途是保存函数参数。但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。 function box(num) {if (num <= 1) {return 1;} else {return num box(num-1); // 一个简单的的递归} } 对于阶乘函数一般要用到递归算法，所以函数内部一定会调用自身；如果函数名不改变是没有问题的，但一旦改变函数名，内部的自身调用需要逐一修改。为了解决这个问题，我们可以使用 arguments.callee 来代替。 function box(num) {if (num <= 1) {return 1;} else {return num arguments.callee(num-1); // 使用 callee 来执行自身} } 函数内部另一个特殊对象是 this，其行为与 Java 和 C中的 this 大致相似。换句话说，this 引用的是函数据以执行操作的对象，或者说函数调用语句所处的那个作用域。当在全局作用域中调用函数时，this 对象引用的就是 window。 // 便于理解的改写例子window.color = '红色的'; // 全局的，或者 var color = '红色的';也行alert(this.color); // 打印全局的 colorvar box = {color : '蓝色的', // 局部的 colorsayColor : function () {alert(this.color); // 此时的 this 只能 box 里的 color} };box.sayColor(); // 打印局部的 coloralert(this.color); // 还是全局的// 引用教材的原版例子window.color = '红色的'; // 或者 var color = '红色的';也行var box = {color : '蓝色的'};function sayColor() {alert(this.color); // 这里第一次在外面，第二次在 box 里面}getColor();box.sayColor = sayColor; // 把函数复制到 box 对象里，成为了方法box.sayColor(); 函数属性和方法 ECMAScript 中的函数是对象，因此函数也有属性和方法。每个函数都包含两个属性：length 和 prototype。其中，length 属性表示函数希望接收的命名参数的个数。 function box(name, age) {alert(name + age);}alert(box.length); // 2 对于 prototype 属性，它是保存所有实例方法的真正所在，也就是原型。这个属性，我们将在面向对象一章详细介绍。而 prototype 下有两个方法：apply()和 call()，每个函数都包含这两个非继承而来的方法。这两个方法的用途都在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值。 function box(num1, num2) {return num1 + num2; // 原函数}function sayBox(num1, num2) {return box.apply(this, [num1, num2]); // this 表示作用域，这里是 window} // []表示 box 所需要的参数function sayBox2(num1, num2) {return box.apply(this, arguments); // arguments 对象表示 box 所需要的参数}alert(sayBox(10,10)); // 20alert(sayBox2(10,10)); // 20 call()方法于 apply()方法相同，他们的区别仅仅在于接收参数的方式不同。对于 call()方法而言，第一个参数是作用域，没有变化，变化只是其余的参数都是直接传递给函数的。 function box(num1, num2) {return num1 + num2;}function callBox(num1, num2) {return box.call(this, num1, num2); // 和 apply 区别在于后面的传参}alert(callBox(10,10)); 事实上，传递参数并不是 apply()和 call()方法真正的用武之地；它们经常使用的地方是能够扩展函数赖以运行的作用域。 var color = '红色的'; // 或者 window.color = '红色的';也行var box = {color : '蓝色的'};function sayColor() {alert(this.color);}sayColor(); // 作用域在 windowsayColor.call(this); // 作用域在 windowsayColor.call(window); // 作用域在 windowsayColor.call(box); // 作用域在 box，对象冒充这个例子是之前作用域理解的例子修改而成，我们可以发现当我们使用 call(box)方法的时候，sayColor()方法的运行环境已经变成了 box 对象里了。使用 call()或者 apply()来扩充作用域的最大好处，就是对象不需要与方法发生任何耦合关系（耦合，就是互相关联的意思，扩展和维护会发生连锁反应）。也就是说，box 对象和 sayColor()方法之间不会有多余的关联操作，比如 box.sayColor = sayColor;。本篇文章为转载内容。原文链接：https://blog.csdn.net/gongxifacai_believe/article/details/108286196。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-01-24 13:01:25

529

转载

转载文章

[转载]【C++面向对象程序设计】CH3 怎样使用类和对象

...成员初始化。例如： class Time{public:int hour;int minute;int sec;};Time t1{15,36,26}; 在一个打括号内顺序列出各个公有数据成员的值，在两个值之间用逗号分隔。注意这只能用于数据成员都是共有的情况。在前面的例子里，是用成员函数对对象的数据成员赋初值，如果一个类定义了多个对象，对每个对象都要调用成员函数对数据成员赋初值，那么程序就会变得繁琐，所以用成员函数为数据成员赋初值不是一个好办法。 2.构造函数的作用构造函数用于为对象分配空间和进行初始化，它属于某一个类，可以由系统自动生成。也可以由程序员编写，程序员根据初始化的要求设计构造函数及函数参数。构造函数是一种特殊的成员函数，在程序中不需要写调用语句，在系统建立对象时由系统自觉调用执行。构造函数的特点：构造函数的名字与它的类名必须相同它没有类型，也不返回值它可以带参数，也可以不带参数 include <iostream>using namespace std;class Time {public:Time() {hour = 0;minute = 0;sec = 0;}void set_time();void show_time();private:int hour;int minute;int sec;};int main() {Time t1;t1.set_time();t1.show_time();Time t2;t2.show_time();return 0;}void Time::set_time() {cin >> hour;cin >> minute;cin >> sec;}void Time::show_time() {cout << hour << ":" << minute << ":" << sec << endl;} 在类Time中定义了构造函数Time，它与所在的类同名。在建立对象时自动执行构造函数，该函数的作用是为对象中的每个数据成员赋初值0。注意只有执行构造函数时才能为数据成员赋初值。程序运行时首先建立对象t1，并对t1中的数据成员赋初值0，然后执行t1.set_time函数，从键盘输入新值给对象t1的数据成员，再输出t1的数据成员的值。接着建立对象t2，同时对t2中的数据成员赋初值0，最后输出t2的数据成员的初值。程序运行情况如下：也可以在类内声明构造函数然后在类外定义构造函数。将程序修改为Time();然后在类外定义构造函数： Time::Time() {hour = 0;minute = 0;sec = 0;} 关于构造函数的使用，说明如下：什么时候调用构造函数？当函数执行到对象定义语句时建立对象，此时就要调用构造函数，对象就有了自己的作用域，对象的生命周期开始了。构造函数没有返回值，因此不需要在定义中声明类型。构造函数不需要显式地调用，构造函数是在建立对象时由系统自动执行的，且只执行以此。构造函数一般定义为public。在构造函数中除了可以对数据成员赋初值，还可以使用其他语句。如果用户没有定义构造函数，C++系统会自动生成一个构造函数，而这个函数体是空的，不执行初始化操作。 3.带形参数的构造函数（1）含义可以采用带形参数的构造函数，在调用不同对象的构造函数时，从外边将不同的数据传递给构造函数，实现不同对象的初始化。构造函数的首部的一般格式为：构造函数名（类型形参1，类型形参2，……）。在定义对象时指定实参，定义对象的格式为：类名对象名（实参1，实参2，……）。（2）【例3.2】有两个长方柱，其长、宽、高分别为：（1）12，25，30（2）15，30，21编写程序，在类中用带参数的构造函数，计算它们的体积。分析：可以在类中定义一个计算长方体体积的成员函数计算对象的体积。 include<iostream>using namespace std;class Box{public:Box(int,int,int); //声明int volume();private:int height;int width;int length;};Box::Box(int h,int w,int len) //长方体构造函数{height=h;width=w;length=len;}int Box::volume() //计算长方体体积{return(heightwidthlength);}int main(){Box box1(12,25,30); //定义对象box1cout<<"box1体积="<<box1.volume()<<endl;Box box2(15,30,21); //定义对象box2cout<<"box2体积="<<box2.volume()<<endl;return 0;} 【注】带形参的构造函数在定义对象时必须指定实参用这种方法可以实现不同对象的初始化 4.用参数初始化表对数据成员初始化 C++提供了参数初始化表的方法对数据成员初始化。这种方法不必再构造函数内对数据成员初始化，在函数的首部就能实现数据成员初始化。函数名(类型1 形参1，类型2 形参2): 成员名1(形参1),成员名2(形参2){ } 功能：执行构造函数时，将形参1的值赋予成员1，将形参2的值赋予成员2，形参的值由定义对象时的实参值决定。此时定义对象的格式依然是带实参的形式：类名对象名(实参1,实参2); 例：定义带形参初始化表的构造函数 Box::Box(int h,int w,int len):height(h),width(w),length(len){}//定义对象:Box box1(12,25,30);//……Box box2(15,30,21); 5.构造函数的重载（1）含义构造函数也可以重载。一个类可以有多个同名构造函数，函数参数的个数、参数的类型各不相同。（2）【例3.3】在【例3.2】的基础上定义两个构造函数，其中一个无参数，另一个有参数 include <iostream>using namespace std;class Box {public:Box();Box(int h, int w, int len): height(h), width(w), length(len) {}int volume();private:int height;int width;int length;};Box::Box() {height = 10;width = 10;length = 10;}int Box::volume() {return (height width length);}int main() {Box box1;cout << "box1 体积" << box1.volume() << endl;Box box2(15, 30, 25);cout << "box2 体积" << box2.volume() << endl;return 0;} （3）说明不带形参的构造函数为默认构造函数，每个类只有一个默认构造函数，如果是系统自动给的默认构造函数，其函数体是空的虽然每个类可以包含多个构造函数，但是创建对象时，系统仅执行其中一个 6.使用默认参数值的构造函数（1）含义 C++允许在构造函数里为形参指定默认值，如果创建对象时，未给出相应的实参时，系统将用形参的默认值为形参赋值。（2）格式函数名（类型形参1=常数，类型形参2=常数，……）；（3）【例3.4】将【例3.3】中的构造函数改用带默认值的参数，长、宽、高的默认值都是10 include <iostream>using namespace std;class Box {public:Box(int w = 10, int h = 10, int len = 10);int volume();private:int height;int width;int length;};Box::Box(int w, int h, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1;cout << "box1 体积" << box1.volume() << endl;Box box2(15);cout << "box2 体积" << box2.volume() << endl;Box box3(15, 30);cout << "box3 体积" << box3.volume() << endl;Box box4(15, 30, 20);cout << "box4 体积" << box4.volume() << endl;return 0;} （4）说明如果在类外定义构造函数，应该在声明构造函数时指定默认参数值，再定以函数时不再指定默认参数值在声明构造函数时，形参名可以省略。例如：Box(int 10,int 10,int 10); 如果构造函数的所有形参都指定了默认值，在定义对象时，可以指定实参也可不指定实参。由于不指定实参也可以调用构造函数，因此全部形参都指定了默认值的构造函数也属于默认构造函数。为了避免歧义，不允许同时定义不带形参的构造函数和全部形参都指定默认值的构造函数。不能同时使用重载构造函数和带默认值的构造函数二、析构函数 1.含义析构函数也是个特殊的成员函数，它的作用与构造函数相反，当对象的生命周期结束时，系统自动调用析构函数，收回对象占用的内存空间。 2.执行析构函数的时机在一个函数内定义的对象当这个函数结束时，自动执行析构函数释放对象 static局部对象要到main函数结束或执行exit命令时才自动执行析构函数释放对象全局对象（在函数外定义的对象）当main函数结束或执行exit命令时自动执行析构函数释放对象如果用new建立动态对象，用delete时自动执行析构函数释放对象 3.特征以~符号开始后跟类名析构函数没有数据类型、返回值、形参。由于没有形参所以析构函数不能重载。一个类只有一个析构函数如果程序员没有定义析构函数，C++编译系统会自动生成一个析构函数【注】析构函数除了释放对象（资源）外，还可以执行程序员在最后一次适用对象后希望执行的任何操作。例如输出有关的信息。 4.【例3.5】包含构造函数和析构函数的C++程序 include <iostream>include <string>using namespace std;class Student {public:Student(int n, string nam, char s) {num = n;name = nam;sex = s;cout << "Constructor called." << endl;}~Student() {cout << "Destructor called." << endl;}void display() {cout << "num:" << num << endl;cout << "name:" << name << endl;cout << "sex:" << sex << endl;}private:int num;string name;char sex;};int main() {Student stud1(10010, "wang_li", 'f');stud1.display();Student stud2(10011, "zhang_han", 'm');stud2.display();return 0;}//main函数前声明的类其作用域是全局的三、调用构造函数和析构函数的顺序 1.同一类存储类别的对象一般情况下，调用析构函数的次序与调用构造函数的次序恰好相反：最先调用构造函数的对象，最后调用析构函数；最后调用构造函数的对象，最先调用析构函数。可简记为：先构造的后析构，后构造的先析构。它相当于一个栈，后进先出。 2.全局范围内定义的对象在全局范围内定义的对象（在所有函数之外定义的对象），在文件中的所有函数（包括主函数）执行前调用构造函数。当主函数结束或执行exit函数时，调用析构函数。 3.局部自动对象如果定义局部自动对象（在函数内定义对象），在创建对象时调用构造函数。如多次调用对象所在的函数，则每次创建对象时都调用构造函数。在函数调用结束时调用析构函数。 4.静态局部对象如果在函数中定义静态局部对象，则在第一次调用该函数建立对象时调用构造函数，但在主函数结束或调用exit函数时才调用析构函数。 5.例 void fun(){student st1; //定义局部自动对象static student st2; //定义静态局部对象...} 对象st1是每次调用函数fun时调用构造函数。在函数fun结束时调用析构函数。对象st2是第一次调用函数fun时调用构造函数，在函数fun结束时并不调用析构函数，到主函数结束时才调用析构函数四、对象数组 1.含义类是一种特殊的数据类型，它当然是C++的合法类型，自然可以定义对象数组。在一个对象数组中各个元素都是同类对象。例如一个班级有50个同学，每个学生有学号、年龄、成绩等属性，可以为这个班级建立一个对象数组，数组包括了50个元素：student std[50];。可以这样建立构造函数：student::student(int 1001,int 18,int 60);。在建立数组时，同样要调用构造函数。上面的数组有50个元素，要调用50次构造函数。如果构造函数有多个参数，C++要求：在等号后的花括号中为每个对象分别写出构造函数并指定实参。格式为： student st[n]={ student(实参1,实参2,实参3); …… student(实参1,实参2,实参3); }；假定对象有三个数据成员：学号、年龄、成绩。下面定义有三个学生的对象数组： student st[3]={ student(1001,18,87); student(1002,19,76); student(1003,18,80); }；//构造函数带实参在建立对象数组时，分别调用构造函数，对每个对象初始化。每个元素的实参用括号括起来，实参的位置与构造函数形参的位置一一对应，不会混淆。 2.【例3.6】 include <iostream>using namespace std;class Box {public:Box(int h = 10, int w = 12, int len = 15): height(h), width(w), length(len) {} //int volume();private:int height;int width;int length;};int Box::volume() {return (height width length);}int main() {Box a[3] = {Box(10, 12, 15), Box(15, 18, 20), Box(16, 20, 26)};cout << "a[0]的体积是" << a[0].volume() << endl;cout << "a[1]的体积是" << a[1].volume() << endl;cout << "a[2]的体积是" << a[2].volume() << endl;return 0;}//每个数组元素是一个对象五、对象指针指针的含义是内存单元的地址，可以指向一般的变量，也可以指向对象。 1.指向对象的指针对象要占据一片连续的内存空间，CPU实际都是按地址访问内存，所以对象在内存的其实地址是CPU确定对象在内存中位置的依据。这个起始地址称为对象指针。 C++的对象也可以参加取地址运算：&对象名。运算的结果是该对象的起始地址，也称对象的指针，要用与对象类型相同的指针变量保存运算的结果。 C++中定义对象的指针变量与定义其他的指针变量相似，格式如下：类名变量名表。类名表示对象所属的类，变量名按标识符规则取名，两个变量名之间用逗号分隔。定义好指针变量后，必须先给赋予合法的地址后才能使用。例如定义如下一个类： class Time {public:Time() {hour = 0;minute = 0;sec = 0;}void set_time();void show_time();private:int hour;int minute;int sec;};void Time::set_time() {cin >> hour;cin >> minute;cin >> sec;}void Time::show_time() {cout << hour << ":" << minute << ":" << sec << endl;} 在此基础上，有如下语句： Time pt; //定义pt是指向Time类对象的指针Time t1; //定义Time类对象t1pt=&t1; //将对象t1的地址赋予pt 程序在此基础上就可以用指针变量访问对象的成员。 (pt).hour;pt->hour;(pt).show_time();pt->show_time(); 2.指向对象成员的指针（1）含义对象由成员组成。对象占据的内存区是各个数据成员占据的内存区的总和。对象成员也有地址，即指针。这指针分指向数据成员的指针和指向成员函数的指针。（2）指向对象公有数据成员的指针定义数据成员的指针变量：数据类型指针变量名（这里的数据类型是数据成员的数据类型）计算公有数据成员的地址：&对象名.成员名 Time t1;int p1; //定义一个指向整型数据的指针变量p1=&t1.hour; //假定hour是公有成员cout<<p1<<endl; （3）指向对象成员函数的指针定义指向成员函数的指针变量：数据类型(类名::变量名)(形参表); 数据类型是成员函数的类型；类名是对象所属的类；变量名按标识符取名；形参表：指定成员函数的形参表（形参个数、类型）取成员函数的地址：&类名::成员函数名给指针变量赋初值：指针变量名=&类名::成员函数名; 用指针变量调用成员函数：(对象名.指针变量名)([实参表]); 对象名：指定调用成员函数的对象；：明确其后的是一个指针变量；实参表：与成员函数的形参表对应，如无形参，可以省略实参表（4）【例3.7】有关对象指针的使用方法 include <iostream>using namespace std;class Time {public:Time(int, int, int);int hour;int minute;int sec;void get_time();};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void Time::get_time() {cout << hour << ":" << minute << ":" << sec << endl;}int main() {Time t1(10, 13, 56);int p1 = &t1.hour; //定义指向数据成员的指针p1cout << p1 << endl;t1.get_time(); //调用成员函数Time p2 = &t1; //定义指向对象t1的指针p2p2->get_time(); //用对象指针调用成员函数void(Time::p3)(); //定义指向成员函数的指针p3 = &Time::get_time; //给成员函数的指针赋初值(t1.p3)(); //用指向成员函数的指针调用成员函数return 0;} 【注】代码的34，35行可合并为：void(Time::p3)=&Time::get_time; 3.this指针一个类的成员函数只有一个内存拷贝。类中不论哪个对象调用某个成员函数，调用的都是内存中同一个成员函数代码。例如Time类一个成员函数： void Time::get_time(){cout<<hour<<":"<<minute<<":"<<sec<<endl;}t1.get_time();t2.get_time(); 当不同对象的成员函数访问数据成员时，怎么保证访问的就是指定对象的数据成员？其实每个成员函数中都包含一个特殊的指针，他的名字是this指针。它是指向本类对象的指针。当对象调用成员函数时，它的值就是该对象的起始地址。所以为了区分不同对象访问成员函数，语法要求的调用成员函数的格式是：对象名.成员函数名(实参表)。从语法上明确是对象名所指的对象调用成员函数。This指针是隐式使用的，在调用成员函数时C++把对象的地址作为实参传递给this指针。例如成员函数定义如下： int Box::volume(){return(heightwidthlength);} C++编译成： int Box::volume(this){return(this->heightthis->widththis->length);} 对于计算长方体体积的成员函数volume，当对象调用它时，就把对象地址给this指针，编译程序将的地址作为实参调用成员函数：a.volume(&a);。实际上函数是计算(this->height)(this->width)(this->length)，这时就等价计算(a.height)(a.width)(a.length)。可以用(this)表示调用成员函数的对象。(this)就是this所指的对象。如前面的计算长方体体积的函数中return语句可以写成：return((this).height(this).width(this).length);注意，this两侧的括号不能省略。 C++通过编译程序，在对象调用成员函数时，把对象的地址赋予this指针，用this指针指向对象，实现了用同一个成员函数访问不同对象的数据成员。六、共用数据的保护如果既希望数据在一定范围内共享，又不愿它被随意修改，从技术上可以把数据指定为只读型的。C++提供const手段，将数据、对象、成员函数指定为常量，从而实现了只读要求，达到保护数据的目的。 1.常对象定义格式： const 类名对象名（实参表）;或类名 const 对象名（实参表）; 把对象定义为常对象，对象中的数据成员就是常变量，在定义时必须带实参作为数据成员的初值，在程序中不允许修改常对象的数据成员值。如果一个常对象的成员函数未被定义为常成员函数（除构造函数和析构函数外），则对象不能调用这样的函数。 const Time t1(10,16,36);t1.get_time();//错误，不能调用为了访问常对象中的数据成员，要定义常成员函数。 void get_time() const 如果在常对象中要修改某个数据成员，C++提供了指定可变的数据成员方法。格式：mutable 类型数据成员在定义数据成员时加mutable后，将数据成员声明为可变的数据成员，就可以用声明为const的成员函数修改它的值。 2.常对象成员可以在声明普通对象时将数据成员或成员函数声明为常数据成员或常成员函数。（1）常数据成员格式： const 类型数据成员名将类中的数据成员定义为具有只读的性质。注意只能通过带参数初始表的构造函数对常数据成员进行初始化。例如： const int hour;Time::Time(int h){hour=h;...//错误}Time::Time(int h):hour(h){}//正确在类中声明了某个常数据成员后，该类中每个对象的这个数据成员的值都是只读的，而每个对象的这个数据成员的值可以不同，由定义对象时给出。（2）常成员函数定义格式：类型函数名（形参表）const const是函数类型的一部分，在声明函数原型和定义函数时都要用const关键字。【注1】const是函数类型的一个组成部分，因此在函数的实现部分也要使用关键字const。常成员函数不能修改对象的数据成员，也不能调用该类中没有由关键字const修饰的成员函数，从而保证了在常成员函数中不会修改数据成员的值。如果一个对象被说明为常对象，则通过该对象只能调用它的常成员函数。【注2】一般成员函数可以访问或修改本类中非const数据成员。而常成员函数只能读本类中的数据成员，而不能写他们。数据成员非const成员函数 const成员函数非const的数据成员可以引用，也可以改变值可以引用，但不可以改变值 const数据成员可以引用，但不可以改变值可以引用，但不可以改变值 const对象的数据成员不允许引用和改变值可以引用，但不可以改变值常成员函数的使用：如果类中有部分数据成员的值要求为只读，可以将它们声明为const，这样成员函数只能读这些数据成员的值，但不能修改它们的值如果所有数据成员的值为只读，可将对象声明为const，在类中必须声明const成员函数，常对象只能通过常成员函数读数据成员常对象不能调用非const成员函数【注】如果常对象的成员函数未加const，编译系统将其当作非const成员函数；常成员函数不能调用非const成员函数 3.指向对象的常指针如果在定义指向对象的指针时，使用了关键字const，他就是一个常指针，必须在定义时对其初始化，并且在程序运行中不能再修改指针的值。格式：const 指针变量名=对象地址 Time t1(10,12,15),t2;Time const p1=&t1;//在此后，不能修改p1Time const p1=&t2;//错误语句指向对象的常指针，在程序运行中始终指向的是同一个对象。即指针变量的值始终不变，但它所指对象的数据成员值可以修改。当需要将一个指针变量固定地与一个对象相联系时，就可将指针变量指定为const。往往用常指针作为函数的形参，目的是不允许在函数中修改指针变量的值，让它始终指向原来的对象。 4.指向常对象的指针变量 5.对象的常引用（1）含义前面学过引用是传递参数的有效方法。用引用形参时，形参变量与实参变量是同一个变量，在函数内修改引用形参也就是修改实参变量。如果用引用形参又不想让函数修改实参，可以使用常引用机制。（2）格式 const 类名 &形参变量名（3）【例3.8】对象的引用 include <iostream>using namespace std;class Time {public:Time(int, int, int);int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void fun(Time &t) {t.hour = 18;}int main() {Time t1(10, 13, 56);fun(t1);cout << t1.hour << endl;return 0;} //如果用引用形参又不想让函数修改实参，可以使用常引用机制include <iostream>using namespace std;class Time {public:Time(int, int, int);void fun(int &t) {hour = t;t = 18;}int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}int main(int argc, char argc[]) {int x = 15;Time t1(10, 13, 56);t1.fun(x);cout << t1.hour << endl;cout << x << endl;return 0;} 6.const型数据小结七、对象的动态建立与释放——动态建立对象 C++提供了new和delete运算符，实现动态分配、回收内存。他们也可以用来动态建立对象和释放对象。格式：new 类名; 功能：在堆里分配内存，建立指定类的一个对象。如果分配成功，将返回动态对象的起始地址（指针）；如不成功，返回0.为了保存这个指针，必须事先建立以类名为类型的指针变量。格式：类名指针变量名 Box pt;pt=new Box;//如果分配成功，就可以用指针变量pt访问动态对象的数据成员cout<<pt->height;cout<<pt->volume(); 当不再需要使用动态变量时，必须用delete运算符释放内存。格式：delete 指针变量（存放的是用new运算返回的指针）八、对象的赋值和复制 1.对象的赋值（1）含义如果一个类定义了两个或多个对象，则这些同类对象之间可以相互赋值。这里所指的对象的值含义是对象中所有数据成员的值。对象1、对象2都是已建立好的同类对象。格式：对象1=对象2；（2）【例3.9】对象的赋值 include <iostream>using namespace std;class Box {public:Box(int = 10, int = 10, int = 10);int volume();private:int height;int width;int length;};Box::Box(int h, int w, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1(15, 30, 25), box2;cout << "box1 体积=" << box1.volume() << endl;box2 = box1;cout << "box2 体积=" << box2.volume() << endl;return 0;} （3）说明对象的赋值只对数据成员操作数据成员中不能含有动态分配的数据成员 2.对象的复制（1）含义对象赋值的前提是对象1和对象2是已经建立的对象。C++还可以按照一个对象克隆出另一个对象（从无到有），这就是复制对象。复制对象是创建对象的另一种方法（以前学过的是定义对象）。创建对象必须调用构造函数，复制对象要调用复制构造函数。以Box类为例，复制构造函数的形式是： Box::Box(const Box &b){height=b.height;width=b.width;length=b.length;} 复制构造函数只有一个参数，这个参数是本类的对象，且采用引用对象形式。为了防止修改数据，加const限制。构造函数的内容就是将实参对象的数据成员值赋予新对象对应的数据成员，如果程序中未定义复制构造函数，编译系统将提供默认的复制构造函数，复制类中的数据成员。复制对象有两种格式：类名对象2（对象1）；按对象1复制对象2 类名对象2=对象1，对象3=对象1，……按对象1复制对象2、对象3 （2）【例】用复制对象的方法创建Box类的对象（用默认复制构造函数） //include "stdafx.h"include <iostream>using namespace std;class Box {public:Box(int = 10, int = 10, int = 10);int volume();private:int height;int width;int length;};Box::Box(int h, int w, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1(15, 30, 25);cout << "box1 体积=" << box1.volume() << endl;//Box box2=box1,box3=box2;Box box2(box1), box3(box2);cout << "box2 体积=" << box2.volume() << endl;cout << "box3 体积=" << box3.volume() << endl;return 0;} （3）说明在以下情况调用复制构造函数：在程序里用复制对象格式创建对象当函数的参数是对象。调用函数时，需要将实参对象复制给形参对象，在此系统将调用复制构造函数 void fun(Box b){...}int main(){Box box1(12,15,18);fun(box1);return 0;} 在函数返回值是类的对象时，需要将函数里的对象复制一个临时对象当作函数值返回 Box f(){Box box1(12,15,18);return box1;}int main(){Box box2;box2=f();} 九、静态成员 C++用const保护数据对象不被修改，在实际中还需要共享数据，C++怎样提供数据共享机制？C++静态成员、友元实现对象之间、类之间的数据共享。 1.静态数据成员（1）定义格式 static 类型数据成员名 class Box{public:Box(int=10,int=10,int=10);int volume();private:static int height;int width;int length;}; （2）特性设Box有n个对象box1..boxn。这n个对象的height成员在内存中共享一个整型数据空间。如果某个对象修改了height成员的值，其他n-1个对象的height成员值也被改变，从而达到n个对象共享height成员值的目的。（3）说明由于一个类的所有对象共享静态数据成员，所以不能用构造函数为静态数据成员初始化，只能在类外专门对其初始化。如果程序未对静态数据成员赋初值，则编译系统自动用0为它赋初值格式：数据类型类名::静态数据成员名=初值；即可已用对象名引用静态成员，也可以用类名引用静态成员静态数据成员在对象外单独开辟内存空间，只要在类中定义了静态成员，即使不定义对象，系统也为静态成员分配内存空间，可以被引用在程序开始时为静态成员分配内存空间，直到程序结束才释放内存空间静态数据成员作用域是它的类的作用域（如果在一个函数内定义类，他的静态数据成员作用域就是这个函数）在此范围内可以用“类名::静态成员名”的形式访问静态数据成员（4）【例3.10】引用静态数据成员 include <iostream>using namespace std;class Box {public:Box(int, int);int volume();static int height;int width;int length;};Box::Box(int w, int len) {width = w;length = len;}int Box::volume() {return (height width length);}int Box::height = 10;int main() {Box a(15, 20), b(25, 30);cout << a.height << endl;cout << b.height << endl;cout << Box::height << endl;cout << a.volume() << endl;cout << b.volume() << endl;return 0;} 2.静态成员函数（1）含义 C++提供静态成员函数，用它访问静态数据成员，静态成员函数不属于某个对象而属于类。类中的非静态成员函数可以访问类中所有数据成员；而静态成员函数可以直接访问类的静态成员，不能直接访问非静态成员。静态成员函数定义格式： static 类型成员函数（形参表）{……} 调用公有静态成员函数格式：类名::成员函数（实参表）引用方式静态数据成员非静态数据成员静态成员函数成员名对象名.成员名非静态成员函数成员名成员名【注】静态成员函数不带this指针，所以必须用对象名和成员运算符.访问非静态成员；而普通成员函数有this指针，可以在函数中直接引用成员名。（2）【例3.11】关于引用非静态成员和静态成员的具体方法 class Student {private:int num;int age;float score;static float sum;static int count;public:Student(int, int, int);void total();static float average();};Student::Student(int m, int a, int s) {num = m;age = a;score = s;}void Student::total() {sum += score;count++;}float Student::average() {return (sum / count);}float Student::sum = 0;int Student::count = 0;int main() {Student stud[3] = {Student(1001, 18, 70), Student(1002, 19, 79), Student(1005, 20, 98)};int n;cout << "请输入学生的人数：";cin >> n;for (int i = 1; i < n; i++)stud[i].total();cout << n << "个学生的平均成绩是："cout << Student::average() << endl;return 0;} （3）【例】具有静态数据成员的point类 include <iostream>using namespace std;class Point {private:int X, Y;static int countP;public:Point(int xx = 0, int yy = 0) {X = xx;Y = yy;countP++;}Point(Point &p); //复制构造函数int GetX() {return X;}int GetY() {return Y;}int GetC() {cout << "Object id=" << countP << endl;return 0;} };Point::Point(Point &p) {X = p.X;Y = p.Y;countP++;}int Point::countP = 0;int main() {Point A(4, 5);cout << "Point A," << A.GetC() << "," << A.GetY();A.GetC();Point B(A);cout << "Point B," << B.GetC() << "," << B.GetY();B.GetC();return 0;} （4）静态成员函数举例 include <iostream>using namespace std;class application {private:static int global;public:static void f();static void g();};int application::global = 0;void application::f() {global = 5;}void application::g() {cout << global << endl;}int main() {application::f();application::g();return 0;} class A{private:int x; //非静态成员public:static void f(A a);};void A::f(A a){cout<<x; //对x的引用是错误的cout<<a.x; //正确} （5）具有静态数据、函数成员的Point类 include <iostream>using namespace std;class Point { //point类声明private: //私有数据成员int X, Y;static int countP;public: //外部接口Point(int xx = 0, int yy = 0) {X = xx;Y = yy;countP++;}Point(Point &p); //复制构造函数int GetX() {return X;}int GetY() {return Y;}static int GetC() {cout << "Object id=" << countP << endl;return 0;} };Point::Point(Point &p) {X = p.X;Y = p.Y;countP++;}int Point::countP = 0;int main() //主函数实现{ Point A(4, 5); //声明对象Acout << "Point A," << A.GetC() << "," << A.GetY();A.GetC(); //输出对象号，对象名引用Point B(A); //声明对象Bcout << "Point B," << B.GetC() << "," << B.GetY();Point::GetC(); //输出对象号，类名引用return 0;} （6）静态成员函数、静态数组及其初始化 include <iostream>include <stdio.h>using namespace std;class A {static int a[20];int x;public:A(int xx = 0) {x = xx;}static void in();static void out();void show() {cout << "x=" << x << endl;} };int A::a[20] = {0, 0};void A::in() {cout << "input a[20]:" << endl;for (int i = 0; i < 20; ++i)cin >> a[i];}void A::out() {for (int i = 0; i < 20; ++i)cout << "a[" << i << "]=" << a[i] << endl;}int main() {A::in();A::out();A a;a.out();a.show();return 0;} 十、友元除了在同类对象之间共享数据外，类和类之间也可以共享数据。类的私有成员只能被类的成员函数访问，但是有时需要在类的外部访问类的私有成员，C++通过友元的手段实现这一特殊要求。友元可以是不属于任何类的一般函数，也可以是另一个类的成员函数，还可以是整个的一个类（这个类中的所有成员函数都可以成为友元函数）。友元是C++提供的一种破坏数据封装和数据隐藏的机制。为了保证数据的完整性及数据封装与隐藏的原则，建议尽量不使用或少使用友元。 1.友元函数（1）含义如果在A类外定义一个函数（它可以是另一个类的成员函数，也可以是一个普通函数），在A类中声明该函数是A的友元函数后，这个函数就能访问A类中的所有成员。（2）格式 friend 类型类1::成员函数x(类2 &对象); friend 类型函数y(类2 &对象); //类1是另一个类的类名，类2是本类的类名功能：第一种形式在类2中声明类1的成员函数x为友元函数。第二种形式在类2中声明一个普通函数y是友元函数。友元函数内访问对象的格式：对象名.成员名因为友元不是成员函数，它不属于类，所以它访问对象时必须冠以对象名。定义友元函数时形参通过定义引用对象，这样在友元函数内就能访问实参对象了。（3）【例3.12】将普通函数声明为友元函数 include <iostream>using namespace std;class Time {public:Time(int, int, int);friend void display(Time &);private:int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void display(Time &t) {cout << t.hour << ":" << t.minute << ":" << t.sec << endl;}int main() {Time t1(10, 13, 56);display(t1);return 0;} 【例】使用友元函数计算两点距离 include <iostream>include <cmath>using namespace std;class Point {public:Point(int xx = 0, int yy = 0) {X = xx;Y = yy;}int GetX() {return X;}int GetY() {return Y;}friend double Distance(Point &a, Point &b);private:int X, Y;};double Distance(Point &a, Point &b) {double dx = a.X - b.X;double dy = b.Y - b.Y;return sqrt(dx dx + dy dy);}int main() {Point p1(3.0, 5.0), p2(4.0, 6.0);double d = Distance(p1, p2);cout << "The distance is " << d << endl;return 0;} include <iostream>include <math.h>using namespace std;class TPoint {private:double x, y;public:TPoint(double a, double b) {x = a;y = b;cout << "点：（" << x << "," << y << "）" << endl;}friend double distance(TPoint &a, TPoint &b) {return sqrt((a.x - b.x) (a.x - b.x) + (a.y - b.y) (a.y - b.y));} };int main(int argc, char argv[]) {TPoint myp1(2.1, 1.3), myp2(5.4, 6.5);cout << "两点之间的距离为：";cout << distance(myp1, myp2) << endl;return 0;} （4）友元成员函数【例3.13】将成员函数声明为友元函数例子中有两个类Time和Date。其中Time类里定义了成员函数void display(Date &)，他除了显示时间外还要显示日期，这个日期通过引用形参访问。在Date类中将Time类的display成员函数定义为友元函数，允许display访问Date类的所有私有数据成员。 include <iostream>using namespace std;class Date;class Time {private:int hour;int minute;int sec;public:Time(int, int, int);void display(const Date &);};class Date {private:int month;int day;int year;public:Date(int, int, int);friend void Time::display(const Date &);};Time::Time(int h, int m, int s) hour = h;minute = m;sec = s;}void Time::display(const Date &da) {cout << da.month << "/" << da.day << "/" << da.year << endl;cout << hour << ":" << minute << ":" << sec << endl;}Date::Date(int m, int d, int y) {month = m;day = d;year = y;}int main() {Time t1(10, 13, 56);Date d1(12, 25, 2004);t1.display(d1);return 0;} 【注1】友元是单向的，此例中声明Time的成员函数display是Date类的友元，允许它访问Date类的所有成员，但不等于说Date类的成员函数也是Time类的友元。【注2】一个函数（包括普通函数和成员函数）可以被多个类声明为“朋友”，这样就可以引用多个类中的私有数据【注3】例如可以将例3.13程序中的display函数作为类外的普通函数，分别在Time和Date类中将display声明为友元。Display就可以分别引用Time和Date类的对象的私有数据成员。输出年月日和时分秒。 2.友元类 C++允许将一个类声明为另一个类的友元。假定A类是B类的友元类，A类中所有的成员函数都是B类的友元函数，在B类中声明A类为友元类的格式：friend A; 【注1】友元关系是单向的，不是双向的【注2】友元关系不能传递【注3】实际中一般不把整个类声明友元类，而只是将确有需要的成员函数声明为友元函数 include <iostream>include <math.h>using namespace std;class B;class A {private:int x;public:A() {x = 3;}friend class B;};class B {public:void disp1(A temp) {temp.x++;cout << "disp1:x" << temp.x << endl;}void disp2(A temp) {temp.x--;cout << "disp2:x" << temp.x << endl;} };int main(int argc, char argv[]) {A a;B b;b.disp1(a);b.disp2(a);return 0;} class Student; //前向声明，类名声明class Teacher{privated:int noOfStudents;Student pList[100];public:void assignGrades(Student &s); //赋成绩void adjustHours(Student &s); //调整学时数};class Student{privated:int hours;float gpa;public:friend class Teacher;};void Teacher::assignGrades(Student &s){...};void Teacher::adjustHours(Student &s){...}; //函数定义必须在Student定义之后十一、类模板 1.含义对于功能相同而只是数据类型不同的函数，不必须定义出所有函数，我们定义一个可对任何类型变量操作的函数模板。对于功能相同的类而数据类型不同，不必定义出所有类，只要定义一个可对任何类进行操作的类模板。例如定义比较两个整数的类和比较两个浮点数的类，这两个类做的工作是相似的，所以可以用类模板，减少工作量。 class Compare_int{private:int x,y;public:Compare_int(int a,int b){x=a;y=b;}int max(){return (x>y)?x:y;}int min(){return (x<y)?x:y;} };class Compare_float{private:float x,y;public:Compare_float(float a,float b){x=a;y=b;}float max(){return (x>y)?x:y;}float min(){return (x<y)?x:y;} }; 2.定义类模板的格式 template <class 类型参数名> class 类模板名 {……} 类型参数名：按标识符取名。如有多个类型参数，每个类型参数都要以class为前导，两个类型参数之间用逗号分隔类模板名：按标识符取名类模板{...}内定义数据成员和成员函数的规则：用类型参数作为数据类型，用类模板名作为类 template<class numtype>class Compare{private:numtype x,y;public:Compare(numtype a,numtype b){x=a,y=b;}numtype max(){return (x>y)?x:y;}numtype min(){return (x<y)?x:y;} }; 3.在类模板外定义成员函数的语法类型参数类模板名<类型参数>::成员函数名（形参表）{……} 例如在类模板外定义max和min成员函数 template<class numtype>class Compare{public:Compare(numtype a,numtype b){x=a,y=b;}numtype max();numtype min();private:numtype x,y;};numtype Compare<numtype>::max(){return(x>y)?x:y;}numtype Compare<numtype>::min(){return(x<y)?x:y;} 4.使用类模板时，定义对象的格式类模板名 <实际类型名>对象名；类模板名 <实际类型名>对象名（实参表）；例如：Compare <int>cmp2(4,7) 在编译时，编译系统用int取代类模板中的类型参数numtype，就把类模板具体化了。这时Compare<int>将相当于Compare_int类。 5.【例3.14】声明类模板，实现两个整数、浮点数和字符的比较，求出大数和小数 include <iostream>using namespace std;template<class numtype>class Compare {private:numtype x, y;public:Compare(numtype a, numtype b) {x = a;y = b;}numtype max() {return (x > y) ? x : y;}numtype min() {return (x < y) ? x : y;} };int main() {Compare<int>cmp1(3, 7);cout << cmp1.max() << "是两个整数中的大数." << endl;cout << cmp1.min() << "是两个整数中的小数." << endl;Compare<float>cmp2(45.78, 93.6);cout << cmp2.max() << "是两个浮点数中的大数." << endl;cout << cmp2.min() << "是两个浮点数中的小数." << endl;Compare<char>cmp3('a', 'A');cout << cmp3.max() << "是两个字符中的大者." << endl;cout << cmp3.min() << "是两个字符中的小者." << endl;return 0;} 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_72318954/article/details/127064376。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2024-01-29 12:38:23

544

转载

转载文章

[转载]java培训后好找工作吗

...OP，分别如何实现(classloader、动态代理)JVM的内存布局以及垃圾回收原理及过程讲一下，讲一下CMS垃圾收集器垃圾回收的流程，以及CMS的缺点 redis如何处理分布式服务器并发造成的不一致OSGi的机制spring中bean加载机制，bean生成的具体步骤，ioc注入的方式spring何时创建- applicationContextlistener是监听哪个事件？介绍ConcurrentHashMap原理，用的是哪种锁，segment有没可能增大? 解释mysql索引、b树，为啥不用平衡二叉树、红黑树 Zookeeper如何同步配置 3.3 三面 Java线程池ThreadPoolEcecutor参数，基本参数，使用场景 MySQL的ACID讲一下，延伸到隔离级别 dubbo的实现原理，说说RPC的要点 GC停顿原因，如何降低停顿？ JVM如何调优、参数怎么调？如何用工具分析jvm状态（visualVM看堆中对象的分配，对象间的引用、是否有内存泄漏，jstack看线程状态、是否死锁等等）描述一致性hash算法分布式雪崩场景如何避免? 再谈谈消息队列 04 抖音Java 三面 4.1 一面： hashmap，怎么扩容，怎么处理数据冲突？怎么高效率的实现数据迁移？ Linux的共享内存如何实现，大概说了一下。 socket网络编程，说一下TCP的三次握手和四次挥手同步IO和异步IO的区别？ Java GC机制？GC Roots有哪些？红黑树讲一下，五个特性，插入删除操作,时间复杂度？快排的时间复杂度，最坏情况呢，最好情况呢，堆排序的时间复杂度呢，建堆的复杂度是多少 4.2 二面：自我介绍，主要讲讲做了什么和擅长什么设计模式了解哪些？ AtomicInteger怎么实现原子修改的？ ConcurrentHashMap 在Java7和Java8中的区别？为什么Java8并发效率更好？什么情况下用HashMap，什么情况用ConcurrentHashMap？ redis数据结构？ redis数据淘汰机制？ 4.3 三面（约五十分钟）： mysql实现事务的原理(MVCC) MySQL数据主从同步是如何实现的？ MySQL索引的实现，innodb的索引，b+树索引是怎么实现的，为什么用b+树做索引节点，一个节点存了多少数据，怎么规定大小，与磁盘页对应。如果Redis有1亿个key，使用keys命令是否会影响线上服务？ Redis的持久化方式，aod和rdb，具体怎么实现，追加日志和备份文件，底层实现原理的话知道么? 遇到最大困难是什么？怎么克服？未来的规划是什么？你想问我什么？ 05 百度三面 5.1 百度一面自我介绍 Java中的多态为什么要同时重写hashcode和equals Hashmap的原理 Hashmap如何变线程安全，每种方式的优缺点垃圾回收机制 Jvm的参数你知道的说一下设计模式了解的说一下啊手撕一个单例模式手撕算法：反转单链表手撕算法：实现类似微博子结构的数据结构，输入一系列父子关系，输出一个类似微博评论的父子结构图手写java多线程手写java的soeket编程，服务端和客户端手撕算法：爬楼梯，写出状态转移方程智力题：时针分针什么时候重合 5.2 百度二面（现场）自我介绍项目介绍服务器如何负载均衡，有哪些算法，哪个比较好，一致性哈希原理，怎么避免DDOS攻击请求打到少数机器。 TCP连接中的三次握手和四次挥手，四次挥手的最后一个ack的作用是什么，为什么要time wait，为什么是2msl。数据库的备份和恢复怎么实现的，主从复制怎么做的，什么时候会出现数据不一致，如何解决。 Linux查看cpu占用率高的进程手撕算法：给定一个数字三角形，找到从顶部到底部的最小路径和。每一步可以移动到下面一行的相邻数字上。然后继续在这个问题上扩展求出最短那条的路径递归求出所有的路径设计模式讲一下熟悉的会不会滥用设计模式多线程条件变量为什么要在while体里你遇到什么挫折，怎么应对和处理 5.3 百度三面（现场）自我介绍项目介绍 Redis的特点 Redis的持久化怎么做，aof和rdb，有什么区别，有什么优缺点。 Redis使用哨兵部署会有什么问题，我说需要扩容的话还是得集群部署。说一下JVM内存模型把，有哪些区，分别干什么的说一下gc算法，分代回收说下 MySQL的引擎讲一下，有什么区别，使用场景呢分布式事务了解么反爬虫的机制，有哪些方式 06 蚂蚁中间件团队面试题 6.1 蚂蚁中间件一面：自我介绍 JVM垃圾回收算法和垃圾回收器有哪些，最新的JDK采用什么算法。新生代和老年代的回收机制。讲一下ArrayList和linkedlist的区别，ArrayList与HashMap的扩容方式。 Concurrenthashmap1.8后的改动。 Java中的多线程，以及线程池的增长策略和拒绝策略了解么。 Tomcat的类加载器了解么 Spring的ioc和aop，Springmvc的基本架构，请求流程。 HTTP协议与Tcp有什么区别，http1.0和2.0的区别。 Java的网络编程，讲讲NIO的实现方式，与BIO的区别，以及介绍常用的NIO框架。索引什么时候会失效变成全表扫描介绍下分布式的paxos和raft算法 6.2 蚂蚁中间件二面你在项目中怎么用到并发的。消息队列的使用场景，谈谈Kafka。你说了解分布式服务，那么你怎么理解分布式服务。 Dubbo和Spring Clound的区别，以及使用场景。讲一下docker的实现原理，以及与JVM的区别。 MongoDB、Redis和Memcached的应用场景，各自优势 MongoDB有事务吗 Redis说一下sorted set底层原理讲讲Netty为什么并发高，相关的核心组件有哪些 6.3 蚂蚁中间件三面完整的画一个分布式集群部署图，从负载均衡到后端数据库集群。分布式锁的方案，Redis和Zookeeper哪个好，如果是集群部署，高并发情况下哪个性能更好。分布式系统的全局id如何实现。数据库万级变成亿级，你如何来解决。常见的服务器雪崩是由什么引起的，如何来防范。异地容灾怎么实现常用的高并发技术解决方案有哪些，以及对应的解决步骤。 07 京东4面(Java研发） 7.1 一面（基础面：约1小时）自我介绍，主要讲讲做了什么和擅长什么 springmvc和spring-boot区别 @Autowired的实现原理 Bean的默认作用范围是什么？其他的作用范围？索引是什么概念有什么作用？MySQL里主要有哪些索引结构？哈希索引和B+树索引比较？ Java线程池的原理？线程池有哪些？线程池工厂有哪些线程池类型，及其线程池参数是什么？ hashmap原理，处理哈希冲突用的哪种方法？还知道什么处理哈希冲突的方法？ Java GC机制？GC Roots有哪些？ Java怎么进行垃圾回收的？什么对象会进老年代？垃圾回收算法有哪些？为什么新生代使用复制算法？ HashMap的时间复杂度？HashMap中Hash冲突是怎么解决的？链表的上一级结构是什么？Java8中的HashMap有什么变化？红黑树需要比较大小才能进行插入，是依据什么进行比较的？其他Hash冲突解决方式？ hash和B+树的区别？分别应用于什么场景？哪个比较好？项目里有个数据安全的，aes和md5的区别？详细点 7.2 二面（问数据库较多）自我介绍为什么MyISAM查询性能好？事务特性（acid）隔离级别 SQL慢查询的常见优化步骤？说下乐观锁，悲观锁（select for update），并写出sql实现 TCP协议的三次握手和四次挥手过程？用到过哪些rpc框架数据库连接池怎么实现 Java web过滤器的生命周期 7.3 三面（综合面；约一个小时）自我介绍。 ConcurrentHashMap 在Java7和Java8中的区别？为什么Java8并发效率更好？什么情况下用HashMap，什么情况用ConcurrentHashMap？加锁有什么机制？ ThreadLocal？应用场景？数据库水平切分，垂直切分的设计思路和切分顺序 Redis如何解决key冲突 soa和微服务的区别？单机系统演变为分布式系统，会涉及到哪些技术的调整？请从前面负载到后端详细描述。设计一个秒杀系统？ 7.4 四面（HR面）你自己最大优势和劣势是什么平时遇见过什么样的挑战，怎么去克服的工作中遇见了技术解决不了的问题，你的应对思路？你的兴趣爱好？未来的职业规划是什么？ 08 美团java高级开发3面 8.1 美团一面自我介绍项目介绍 Redis介绍了解redis源码么了解redis集群么 Hashmap的原理，增删的情况后端数据结构如何位移 hashmap容量为什么是2的幂次 hashset的源码 object类你知道的方法 hashcode和equals 你重写过hashcode和equals么，要注意什么假设现在一个学生类，有学号和姓名，我现在hashcode方法重写的时候，只将学号参与计算，会出现什么情况？往set里面put一个学生对象，然后将这个学生对象的学号改了，再put进去，可以放进set么？并讲出为什么 Redis的持久化？有哪些方式，原理是什么？讲一下稳定的排序算法和不稳定的排序算法讲一下快速排序的思想 8.2 美团二面自我介绍讲一下数据的acid 什么是一致性什么是隔离性 Mysql的隔离级别每个隔离级别是如何解决 Mysql要加上nextkey锁，语句该怎么写 Java的内存模型，垃圾回收线程池的参数每个参数解释一遍然后面试官设置了每个参数，给了是个线程，让描述出完整的线程池执行的流程 Nio和IO有什么区别 Nio和aio的区别 Spring的aop怎么实现 Spring的aop有哪些实现方式动态代理的实现方式和区别 Linux了解么怎么查看系统负载 Cpu load的参数如果为4，描述一下现在系统处于什么情况 Linux，查找磁盘上最大的文件的命令 Linux，如何查看系统日志文件手撕算法：leeetcode原题 22，Generate Parentheses，给定 n 对括号，请- 写一个函数以将其生成新的括号组合，并返回所有组合结果。 8.3 美团三面（现场）三面没怎么问技术，问了很多技术管理方面的问题自我介绍项目介绍怎么管理项目成员当意见不一致时，如何沟通并说服开发成员，并举个例子怎么保证项目的进度数据库的索引原理非聚簇索引和聚簇索引索引的使用注意事项联合索引从底层解释最左匹配原则 Mysql对联合索引有优化么？会自动调整顺序么？哪个版本开始优化？ Redis的应用 Redis的持久化的方式和原理技术选型，一个新技术和一个稳定的旧技术，你会怎么选择，选择的考虑有哪些说你印象最深的美团点评技术团队的三篇博客最近在学什么新技术你是怎么去接触一门新技术的会看哪些书怎么选择要看的书最后由于篇幅限制，小编在此截出几张知识讲解的图解，有需要的程序猿（媛）可以点赞后戳这里免费领取全部资料获取哦子怎么保证项目的进度数据库的索引原理非聚簇索引和聚簇索引索引的使用注意事项联合索引从底层解释最左匹配原则 Mysql对联合索引有优化么？会自动调整顺序么？哪个版本开始优化？ Redis的应用 Redis的持久化的方式和原理技术选型，一个新技术和一个稳定的旧技术，你会怎么选择，选择的考虑有哪些说你印象最深的美团点评技术团队的三篇博客最近在学什么新技术你是怎么去接触一门新技术的会看哪些书怎么选择要看的书最后由于篇幅限制，小编在此截出几张知识讲解的图解，有需要的程序猿（媛）可以点赞后戳这里免费领取全部资料获取哦 [外链图片转存中…(img-SFREePIJ-1624074891834)] [外链图片转存中…(img-5kF3pkiC-1624074891834)] [外链图片转存中…(img-HDVXfOMR-1624074891835)] [外链图片转存中…(img-RyaAC5jy-1624074891836)] [外链图片转存中…(img-iV32C5Ok-1624074891837)] 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_57285325/article/details/118051767。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-11-13 23:43:59

转载

转载文章

[转载]Android面试实战总结

..., Handler classes should be static or leaks might occur.。就是，推荐我们把handler 定义成static，具体看这里解释的很详细：http://www.linuxidc.com/Linux/2013-12/94065.htm 类似的还有匿名子线程。 2.还是拿网上的栗子来说， [java] view plain copy print ? Vector v = new Vector( 10 ); for ( int i = 1 ;i < 100 ; i ++ ){ Object o = new Object(); v.add(o); o = null ; } 即便是我们把 o 对象置为 null,但是 vector 集合中还有有o的引用，所以集合没有被清空，这一部分内存还是不能被释放，这就导致了内存泄露。 3，当我们操作数据库的时候，我们在执行完相应的crud 方法后，我们没有关闭 cursor .close()或者 db.close()，也同样会占用内存、因为只有关闭连接后，才会被GC 回收。 4.继续举个栗子 [java] view plain copy print ? Set<Person> set = new HashSet<Person>(); Person p1 = new Person("唐僧","pwd1",25); Person p2 = new Person("孙悟空","pwd2",26); Person p3 = new Person("猪八戒","pwd3",27); set.add(p1); set.add(p2); set.add(p3); System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:3 个元素! p3.setAge(2); //修改p3的年龄,此时p3元素对应的hashcode值发生改变 set.remove(p3); //此时remove不掉，造成内存泄漏 set.add(p3); //重新添加，居然添加成功 System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:4 个元素! Ｊ哥　亲自　实践了下，发现问题了，这个网上的栗子　是错的。实际上是可以ｒｅｍｏｖｅ掉得、真是个悲伤地故事。这个栗子是不正确的。。网上好有一片这样的文章，都是这个栗子。。这里　看下其他网站上的总结吧　：强烈推荐http://developer.51cto.com/art/201111/302465.htm。很详细。ＯＫ。还有最后一点，就是关于图片的，ｂｉｔｍａｐ对象的及时释放，这里　就不细说了，等在图片三级缓存一起去总结。此时　感觉　对面的ａｎｄｒｏｉｄ　小哥　已经被我吸引了。好像很认真的在听我讲课一样。然后，　他问我问题。我大体总结了一下。面试官01问：有没有自定义过ｖｉｅｗ。Ｊ哥回答：这个很常见，我自己定义过很多，比如　下拉刷新，上拉加载更多数据的listview,类似github 上面的pulltorefreshlistview。还有图片轮询播放的viewpager，也是继承viewpager，然后自己开启一个线程，去控制切换的。还比如，跑马灯效果的textview ，scrollview与 listview 相互嵌套导致 listview 高度计算不正确，我也是自定义listview，复写了 onmeaure方法，然后解决冲突的。在比如一些开源的可以放大缩小的图片，我也是做过，主要是对onmeasure 方法，onlayout方法，ondraw 方法的复写。以及复写一下 view 自己的 touch事件等等，奥对了，我们公司当时有需求做一个锁屏软件，侧滑解锁的，我也是自己定义的，然后展示给他看了一下，当时那篇文章在这里。传送门http://blog.csdn.net/u011733020/article/details/41863861。面试官01问：listview的优化、Ｊ哥回答：(PS：这种问题，基本上都快被问烂了，但是没办法还是要回答。）listview作为最常见的用来显示数据的view ，一般从四个方面去优化。 1 ，复用convertview，不然假如有1000条数据，那么我们滑动，就会产生1000个convertview ，这对内存是很大的浪费，所以我们一定要复用。 2. 减少 findviewbyid 的次数，因为每次去执行 findviewbyid 也是要消耗资源的，我们要尽可能的减少，通常我们定义一个viewholder，去管理这些id ，然后通过tag 去直接拿到 id。 3，分页加载，延迟加载预加载。这个在我们以前项目，有一个榜单，数据量很大，一次请求过来的数据量很大，这样有两个问题，一个是请求网络时间可能会很长，另一个展示数据上面体验对不是很好，所以我们做了第一次加载 20条，然后每次请求再去加载10条新数据。 4.就是对 listview 中一些类似头像，图片的优化。这里类似三级缓存，推荐大家看一下开源的universal-image-loader 的源码。或者这篇文章http://www.jb51.net/article/38162.htm，J哥有时间专门写一篇过于图片缓存的。面试官01问：看你简历上面做过社交，通信这块是怎么做的。Ｊ哥回答：我看咱们公司也用到了聊天，咱们公司是自己做的还是用的第三方的类似环信的。结果被J哥猜中，他说是集成的环信（但是有丢包现象，所以打算自己做通信）。 OK，Ｊ哥说　，我们　项目中聊天　是基于ｘｍｐｐ协议的做的，在没有android以前　，java有个开源的 smack ，android 上现在有一个asmack ,其实就是移植到android 中来了，服务端是基于 openfire的 ,我们就是做的 openfire+asmack 的聊天，这个原理主要就是绑定 ip 拿到 connection 然后 connect ，然后进行通信，我说，这个　跟ｈｔｔｐ请求　其实原理上一样，都是　绑定ｉｐ，然后　设置一些ｐｒｏｐｅｒｔｙ，然后通过类似流进行通信的，　asmack，其实底层就是xml通信的。面试官01问： touch 事件的传递机制，还特意画了，一个就是 button LinearLayout 嵌套。Ｊ哥回答：就是这个，这也难不倒我。因为Ｊ哥觉得　这个问题肯定会问到　所以　早有准备，这里　我就大体说下结论，详细原理　给你传送门。我回答，这个很简单，只要你继承一下　button　　和　linearlayout　复写一下　三个方法　dispatchtouchEvent onInterceptTouchEvent 和onTouchEvent .就能很清楚的明白传递的过程，我给你总的说下结论的，点击这个button，一般是外面的父控件先响应这个down 事件，然后往子类里面传递，让子类在往子类的下一级子类去传递，让最终的孩子去决定是不要要消费掉这个点击事件，如果消费掉，那么父类将不会响应，如果子类不消费，那么会退回到次级子类，然后看是否要消费，这样，一句话就是父传子，子决定要不要，不要然后传回去。这里有很详细很详细的介绍，包裹事件的分发。所以我就不罗嗦，http://blog.csdn.net/yanbober/article/details/45887547?ref=myread 面试官01问：项目中图片的优化。Ｊ哥回答：我给他展示的项目其中有一款app 是有很多图片，但是很流畅，也没有oom。关于图片优化，一般我们采用三级缓存，1 。内存加载 2.本地加载 3 网络加载。首先我们看内存中有没有，有直接拿来用，这里我项目里是这样做的，我先获取一下分配给我们应用的可用内存是多少，然后拿1/4 或者 1/8做一个 lrucache. 把我们的bitmap对象添加进去。有些比较常用的图片，我会保存到本地，避免每次重复联网下载。结合开源的 afinal universalimageloader 以及 13年谷歌官方推荐的volley(号称是 asynchttpclient 和universalimageloader)的结合、所以在我的项目中基本没有遇到过图片导致的oom 问题，对于单张的大图片，我也会利用bitmapFactory，进行计算大小，然后计算手机分辨率，进行定量的压缩处理。面试官问： GC的回收Ｊ哥回答：我说。GC 回收应该不只是按照一种方式，应该有多种不同的算法，我看过谷歌官网介绍的一点，有这样一块区域，他分为 latest（最近） middle（中等）permanent（永久的），这样三块子区域。里面分别存放，刚刚被创建的，以及时间靠后的，很久的，对象，不断地新对象往latest里面添加，当达到相应对象区域的阀值的时候，就会触发GC，GC 进行回收的时候，对于latest 中回收的速度是最快的，而permanent 相对是最久的，而时间也跟每块区域中对象的个数有关系，还有一种算法，是根据最近被引用的时间，或者被引用的次数去进行 GC的、、这里随便扯就是了。GC 回收并不是立即执行的。是不定时的。ＧＣ回收的时候　会阻塞线程，所以代码中要避免创建不必要的对象，例如ｆｏｒ循环中　创建大量对象　就会容易引起ＧＣ。当我们也可以主动在方法中执行system.gc() 去手动释放一些资源。面试官01问：怎么避免 viewpager 预加载 fragment的、Ｊ哥回答：这个问题我也碰到过，我们都知道，viewpager 它本身会预加载左右两个和当前一个对象、而我们viewpager setOffscreenPageLimit(0) 不生效因为看源码知道，这个方法默认最少也要加载一个。所以这个fragment 还没有被当前页面显示出来，已经夹在好了，有可能数据不是最新的，我是在 setuservisibilityhint() 这个方法中跟参数动态去判断要不要刷新的。问了一圈，这个哥们大概没什么问的了，然后就让我等一下，说让他们技术总监过来。我就等。。。然后等了几分钟，进来一小姑娘，坐下，看了我简历，我以为是人事，来跟我谈人生理想。结果，没说几句话，让我讲一下我的项目。我qu，惊呆我了。我问，你也是做android的，我去，是这样的、、把J哥吓到, 然后问了Ｊ哥几个问题。 Android 小姑娘问：看你项目中的listview 中item类型是统一的，而加入 item 差别挺大的你怎么复用。Ｊ哥回答：J哥装作很牛的样子说，我暂时想到两种方法，1.给这个对象加一个type 然后根据 type 去复用，或者把这几种类型一起加载，然后控制显示隐藏。然后我反问小姑娘，假如我这里有一百条数据，这一百条是无序的，包含了 10种 item类型，你有没有什么好方法去处理这个问题，小姑娘说，你不是定义了类型吗，我们就是通过type 去判断的。 Android 小姑娘问： onAttch onDetach还是onAttachedToWindow，onDetachedFromWindow Ｊ哥回答：其实那个小姑娘忘记这两个方法了。我说什么方法，她说onAttachIntent() 和 onDetachIntent(). 反正 J哥是没听说过，我只见过 onAttach ,但是这个方法我也没用过。我就问她，这两个方法是做什么的，小姑娘跟我说是把子view绑定到界面上的，那么的话应该是onAttachedToWindow，onDetachedFromWindow方法了，小姑娘说：在这个方法可以计算子 view的高度宽度，在 oncreate 里面不能计算，其实虽然刚开始在oncreate里面是不能计算，但是还是有方法计算的，（本人觉得面试问你 API 是最2的了，忍不住吐槽下，我遇到过，Camera 拍照，问我获取一个图片，还是视频的方法，我去百度一下，随便就知道，真是不懂为什么会问方法。随便一个程序员都会百度。。）跟小姑娘聊得其他问题不太记得了，感觉这个女程序员啊。。就问方法给我的印象不太好，不管方法用没用到，我觉得面试直接问你方法好2 好2... 然后技术总监有进来跟我聊了，后技术总监有进来跟我聊了、技术总监年龄30出头吧，到是没有问我什么技术问题，总监：问我做没做过通信这块，能不能做这一块。Ｊ哥回答：，我说做过，通信有几种协议的，我们用的是xmpp协议的，服务器是基于apache的 openfire 搭建的，客户端是用的asmack。还有一些其他协议的，比如我知道有些项目中用的 soap协议的，还有ip 协议的。ＰＳ：反正就是扯我说　通信　客户端这一块　我没问题，但是　服务端　我　从工作以来　一直偏向　ａｎｄｒｏｉｄ　移动端开发，后台这一块，如果数据量大了，还要考虑并发之类的，我是做不了，让我做个ｔｏｍｃａｔ搭建的ｄｅｍｏ　我可能可以。其他也是随便聊了下，然后　就说，让人事来跟我谈理想了。总监：问我什么时候能上班Ｊ哥回答：我说这个看公司需求啦。其他也是随便聊了下，然后　就说，让人事来跟我谈理想了。这里　感觉应该没问题了。差不多能拿下了。人事１：一进来，就问东问西。问加班看法啊，他们公司技术　一般都八九点走啊。说七点基本没有走的啊、、、Ｊ哥回答：我说，一般遇到项目加功能　，版本升级，等等　这些加班都没什么，只要不是一直在加班。。。。这里每个人自己看法就好了、、反正人事　是一直跟我强调这个，她不停强调　我就暗暗下决心，薪资　我是不会要低了。人事１：看你还年轻啊，还能拼一拼啊、、、、Ｊ哥回答：我说现在　这几年对我人生规划也算比较重要的时期，也是过一年少一年了，其实她的意思　还是侧面强调加班。。。。日了UZI了。中间一堆废话，然后我问了她公司一般上下班时间啊。。之类的有没有技术交流啊，之类的。。。最后到关键问题上啦，最关心的，薪资问题。人事１：期望薪资Ｊ哥回答：我说16K左右吧。她问你以前公司多少握手 15K。她说她们公司是 14薪。反正我还是说16K。她说那好，你等下，然后就出去了。不知道跟什么人讨论了许久，然后又来一个可能是人事吧。又进来，问了一遍，也问了薪资。。哥还是说16K 。。。估计是她们公司想要我，但是又觉得有点超出她们薪资期望吧，当场被没有给什么offer。然后就有点婉拒的说，两天给我答复，心里很气愤，饿着肚子面试到三点，竟然婉拒、、、反正我是很生气，我说，好，然后我就走。结果，没过一个小时，人事又打电话来，非要约我见一下她们CEO。这是什么鬼，难道她们CEO要给我煲汤了？我说可以，然后时间定在后天了，，反正心灵鸡汤对我是没用了、 OK ，这家面试先写到这里，下面下午还有一家，等下在写。准备睡觉。今天面试回来，累的就睡着了，晚上十点多才醒过来，想了想还是把今天面试的过程总结一下。 ------------------------------待续------------------------- 第二弹http://blog.csdn.net/u011733020/article/details/46058273 本篇文章为转载内容。原文链接：https://blog.csdn.net/haluoluo211/article/details/51010955。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-06-19 17:42:52

336

转载

转载文章

[转载]教你学Python47-机器学习迷你课程

..., 'age', 'class'] data = pandas.read_csv(url, names=names) print(data.shape) 到现在为止做得很好！等一下到目前为止有什么问题吗？在评论中提问。第4课：使用描述性统计数据理解数据将数据加载到Python之后，您需要能够理解它。您越了解数据，可以构建的模型就越精确。了解数据的第一步是使用描述性统计数据。今天，您的课程是学习如何使用描述性统计信息来理解您的数据。我建议使用Pandas DataFrame上提供的帮助程序功能。使用head（）函数了解您的数据以查看前几行。使用shape属性查看数据的维度。使用dtypes属性查看每个属性的数据类型。使用describe（）函数查看数据的分布。使用corr（）函数计算变量之间的成对相关性。以下示例加载了皮马印第安人糖尿病发病数据集，并总结了每个属性的分布。 1 2 3 4 5 6 7 Statistical Summary import pandas url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] data = pandas.read_csv(url, names=names) description = data.describe() print(description) 试试看！第5课：通过可视化了解数据从昨天的课程继续，您必须花一些时间更好地了解您的数据。增进对数据理解的第二种方法是使用数据可视化技术（例如，绘图）。今天，您的课程是学习如何在Python中使用绘图来单独理解属性及其相互作用。再次，我建议使用Pandas DataFrame上提供的帮助程序功能。使用hist（）函数创建每个属性的直方图。使用plot（kind ='box'）函数创建每个属性的箱须图。使用pandas.scatter_matrix（）函数创建所有属性的成对散点图。例如，下面的代码片段将加载糖尿病数据集并创建数据集的散点图矩阵。 1 2 3 4 5 6 7 8 9 Scatter Plot Matrix import matplotlib.pyplot as plt import pandas from pandas.plotting import scatter_matrix url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] data = pandas.read_csv(url, names=names) scatter_matrix(data) plt.show() 样本散点图矩阵第6课：通过预处理数据准备建模您的原始数据可能未设置为最佳建模形式。有时您需要对数据进行预处理，以便最好地将问题的固有结构呈现给建模算法。在今天的课程中，您将使用scikit-learn提供的预处理功能。 scikit-learn库提供了两个用于转换数据的标准习语。每种变换在不同的情况下都非常有用：拟合和多重变换以及组合的拟合与变换。您可以使用多种技术来准备数据以进行建模。例如，尝试以下一些方法使用比例和中心选项将数值数据标准化（例如，平均值为0，标准偏差为1）。使用范围选项将数值数据标准化（例如，范围为0-1）。探索更高级的功能工程，例如Binarizing。例如，下面的代码段加载了Pima Indians糖尿病发病数据集，计算了标准化数据所需的参数，然后创建了输入数据的标准化副本。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Standardize data (0 mean, 1 stdev) from sklearn.preprocessing import StandardScaler import pandas import numpy url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] dataframe = pandas.read_csv(url, names=names) array = dataframe.values separate array into input and output components X = array[:,0:8] Y = array[:,8] scaler = StandardScaler().fit(X) rescaledX = scaler.transform(X) summarize transformed data numpy.set_printoptions(precision=3) print(rescaledX[0:5,:]) 第7课：使用重采样方法进行算法评估用于训练机器学习算法的数据集称为训练数据集。用于训练算法的数据集不能用于为您提供有关新数据的模型准确性的可靠估计。这是一个大问题，因为创建模型的整个思路是对新数据进行预测。您可以使用称为重采样方法的统计方法将训练数据集划分为子集，一些方法用于训练模型，而另一些则被保留，并用于估计看不见的数据的模型准确性。今天课程的目标是练习使用scikit-learn中可用的不同重采样方法，例如：将数据集分为训练集和测试集。使用k倍交叉验证来估计算法的准确性。使用留一法交叉验证来估计算法的准确性。下面的代码段使用scikit-learn通过10倍交叉验证来评估Pima Indians糖尿病发作的Logistic回归算法的准确性。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Evaluate using Cross Validation from pandas import read_csv from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.linear_model import LogisticRegression url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] dataframe = read_csv(url, names=names) array = dataframe.values X = array[:,0:8] Y = array[:,8] kfold = KFold(n_splits=10, random_state=7) model = LogisticRegression(solver='liblinear') results = cross_val_score(model, X, Y, cv=kfold) print("Accuracy: %.3f%% (%.3f%%)") % (results.mean()100.0, results.std()100.0) 您获得了什么精度？在评论中让我知道。您是否意识到这是中间点？做得好！第8课：算法评估指标您可以使用许多不同的指标来评估数据集上机器学习算法的技能。您可以通过cross_validation.cross_val_score（）函数在scikit-learn中指定用于测试工具的度量，默认值可用于回归和分类问题。今天课程的目标是练习使用scikit-learn软件包中可用的不同算法性能指标。在分类问题上练习使用“准确性”和“ LogLoss”度量。练习生成混淆矩阵和分类报告。在回归问题上练习使用RMSE和RSquared指标。下面的代码段演示了根据Pima Indians糖尿病发病数据计算LogLoss指标。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Cross Validation Classification LogLoss from pandas import read_csv from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.linear_model import LogisticRegression url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] dataframe = read_csv(url, names=names) array = dataframe.values X = array[:,0:8] Y = array[:,8] kfold = KFold(n_splits=10, random_state=7) model = LogisticRegression(solver='liblinear') scoring = 'neg_log_loss' results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring) print("Logloss: %.3f (%.3f)") % (results.mean(), results.std()) 您得到了什么日志损失？在评论中让我知道。第9课：抽查算法您可能无法事先知道哪种算法对您的数据效果最好。您必须使用反复试验的过程来发现它。我称之为现场检查算法。scikit-learn库提供了许多机器学习算法和工具的接口，以比较这些算法的估计准确性。在本课程中，您必须练习抽查不同的机器学习算法。对数据集进行抽查线性算法（例如线性回归，逻辑回归和线性判别分析）。抽查数据集上的一些非线性算法（例如KNN，SVM和CART）。抽查数据集上一些复杂的集成算法（例如随机森林和随机梯度增强）。例如，下面的代码片段对Boston House Price数据集上的K最近邻居算法进行了抽查。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 KNN Regression from pandas import read_csv from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.neighbors import KNeighborsRegressor url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.data" names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV'] dataframe = read_csv(url, delim_whitespace=True, names=names) array = dataframe.values X = array[:,0:13] Y = array[:,13] kfold = KFold(n_splits=10, random_state=7) model = KNeighborsRegressor() scoring = 'neg_mean_squared_error' results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring) print(results.mean()) 您得到的平方误差是什么意思？在评论中让我知道。第10课：模型比较和选择既然您知道了如何在数据集中检查机器学习算法，那么您需要知道如何比较不同算法的估计性能并选择最佳模型。在今天的课程中，您将练习比较Python和scikit-learn中的机器学习算法的准确性。在数据集上相互比较线性算法。在数据集上相互比较非线性算法。相互比较同一算法的不同配置。创建比较算法的结果图。下面的示例在皮马印第安人发病的糖尿病数据集中将Logistic回归和线性判别分析进行了比较。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 Compare Algorithms from pandas import read_csv from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.linear_model import LogisticRegression from sklearn.discriminant_analysis import LinearDiscriminantAnalysis load dataset url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] dataframe = read_csv(url, names=names) array = dataframe.values X = array[:,0:8] Y = array[:,8] prepare models models = [] models.append(('LR', LogisticRegression(solver='liblinear'))) models.append(('LDA', LinearDiscriminantAnalysis())) evaluate each model in turn results = [] names = [] scoring = 'accuracy' for name, model in models: kfold = KFold(n_splits=10, random_state=7) cv_results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring) results.append(cv_results) names.append(name) msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std()) print(msg) 哪种算法效果更好？你能做得更好吗？在评论中让我知道。第11课：通过算法调整提高准确性一旦找到一种或两种在数据集上表现良好的算法，您可能希望提高这些模型的性能。提高算法性能的一种方法是将其参数调整为特定的数据集。 scikit-learn库提供了两种方法来搜索机器学习算法的参数组合。在今天的课程中，您的目标是练习每个。使用您指定的网格搜索来调整算法的参数。使用随机搜索调整算法的参数。下面使用的代码段是一个示例，该示例使用网格搜索在Pima Indians糖尿病发病数据集上的Ridge回归算法。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Grid Search for Algorithm Tuning from pandas import read_csv import numpy from sklearn.linear_model import Ridge from sklearn.model_selection import GridSearchCV url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] dataframe = read_csv(url, names=names) array = dataframe.values X = array[:,0:8] Y = array[:,8] alphas = numpy.array([1,0.1,0.01,0.001,0.0001,0]) param_grid = dict(alpha=alphas) model = Ridge() grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=3) grid.fit(X, Y) print(grid.best_score_) print(grid.best_estimator_.alpha) 哪些参数取得最佳效果？你能做得更好吗？在评论中让我知道。第12课：利用集合预测提高准确性您可以提高模型性能的另一种方法是组合来自多个模型的预测。一些模型提供了内置的此功能，例如用于装袋的随机森林和用于增强的随机梯度增强。可以使用另一种称为投票的合奏将来自多个不同模型的预测组合在一起。在今天的课程中，您将练习使用合奏方法。使用随机森林和多余树木算法练习装袋。使用梯度增强机和AdaBoost算法练习增强合奏。通过将来自多个模型的预测组合在一起来练习投票合奏。下面的代码段演示了如何在Pima Indians糖尿病发病数据集上使用随机森林算法（袋装决策树集合）。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 Random Forest Classification from pandas import read_csv from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.ensemble import RandomForestClassifier url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] dataframe = read_csv(url, names=names) array = dataframe.values X = array[:,0:8] Y = array[:,8] num_trees = 100 max_features = 3 kfold = KFold(n_splits=10, random_state=7) model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features) results = cross_val_score(model, X, Y, cv=kfold) print(results.mean()) 你能设计出更好的合奏吗？在评论中让我知道。第13课：完成并保存模型找到有关机器学习问题的良好模型后，您需要完成该模型。在今天的课程中，您将练习与完成模型有关的任务。练习使用模型对新数据（在训练和测试过程中看不到的数据）进行预测。练习将经过训练的模型保存到文件中，然后再次加载。例如，下面的代码片段显示了如何创建Logistic回归模型，将其保存到文件中，之后再加载它以及对看不见的数据进行预测。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 Save Model Using Pickle from pandas import read_csv from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression import pickle url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class'] dataframe = read_csv(url, names=names) array = dataframe.values X = array[:,0:8] Y = array[:,8] test_size = 0.33 seed = 7 X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed) Fit the model on 33% model = LogisticRegression(solver='liblinear') model.fit(X_train, Y_train) save the model to disk filename = 'finalized_model.sav' pickle.dump(model, open(filename, 'wb')) some time later... load the model from disk loaded_model = pickle.load(open(filename, 'rb')) result = loaded_model.score(X_test, Y_test) print(result) 第14课：Hello World端到端项目您现在知道如何完成预测建模机器学习问题的每个任务。在今天的课程中，您需要练习将各个部分组合在一起，并通过端到端的标准机器学习数据集进行操作。端到端遍历虹膜数据集（机器学习的世界）这包括以下步骤：使用描述性统计数据和可视化了解您的数据。预处理数据以最好地揭示问题的结构。使用您自己的测试工具抽查多种算法。使用算法参数调整来改善结果。使用集成方法改善结果。最终确定模型以备将来使用。慢慢进行，并记录结果。您使用什么型号？您得到了什么结果？在评论中让我知道。结束！（看你走了多远）你做到了。做得好！花一点时间，回头看看你已经走了多远。您最初对机器学习感兴趣，并强烈希望能够使用Python练习和应用机器学习。您可能是第一次下载，安装并启动Python，并开始熟悉该语言的语法。在许多课程中，您逐渐地，稳定地学习了预测建模机器学习项目的标准任务如何映射到Python平台上。基于常见机器学习任务的配方，您使用Python端到端解决了第一个机器学习问题。使用标准模板，您所收集的食谱和经验现在可以自行解决新的和不同的预测建模机器学习问题。不要轻描淡写，您在短时间内就取得了长足的进步。这只是您使用Python进行机器学习的起点。继续练习和发展自己的技能。喜欢点下关注，你的关注是我写作的最大支持本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_37337849/article/details/104016531。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2023-07-11 10:04:06

转载

转载文章

[转载]小白鼠的逆袭

...模型描述的是输入确定条件下会产生确定输出的部分，在生物体内表现为对相同刺激始终作出一致反应的机制；而概率机模型则指即使输入确定，输出也存在一定的概率分布，即在特定情况下可能出现不同结果。在大脑思维过程中，这两种模型共同作用，反映了人类及其他生物思考的随机性和必然性，其中“灵魂”被比喻为旁观者，观察并体验着由概率机产生的各种心流状态。

2023-01-02 11:30:59

620

转载

转载文章

[转载]今日头条、抖音推荐算法原理全文详解！

...验时间、定义特殊过滤条件，自定义实验组ID。系统可以自动生成：实验数据对比、实验数据置信度、实验结论总结以及实验优化建议。当然，只有实验平台是远远不够的。线上实验平台只能通过数据指标变化推测用户体验的变化，但数据指标和用户体验存在差异，很多指标不能完全量化。很多改进仍然要通过人工分析，重大改进需要人工评估二次确认。五、内容安全最后要介绍今日头条在内容安全上的一些举措。头条现在已经是国内最大的内容创作与分发凭条，必须越来越重视社会责任和行业领导者的责任。如果1%的推荐内容出现问题，就会产生较大的影响。现在，今日头条的内容主要来源于两部分，一是具有成熟内容生产能力的PGC平台一是UGC用户内容，如问答、用户评论、微头条。这两部分内容需要通过统一的审核机制。如果是数量相对少的PGC内容，会直接进行风险审核，没有问题会大范围推荐。 UGC内容需要经过一个风险模型的过滤，有问题的会进入二次风险审核。审核通过后，内容会被真正进行推荐。这时如果收到一定量以上的评论或者举报负向反馈，还会再回到复审环节，有问题直接下架。整个机制相对而言比较健全，作为行业领先者，在内容安全上，今日头条一直用最高的标准要求自己。分享内容识别技术主要鉴黄模型，谩骂模型以及低俗模型。今日头条的低俗模型通过深度学习算法训练，样本库非常大，图片、文本同时分析。这部分模型更注重召回率，准确率甚至可以牺牲一些。谩骂模型的样本库同样超过百万，召回率高达95%+，准确率80%+。如果用户经常出言不讳或者不当的评论，我们有一些惩罚机制。泛低质识别涉及的情况非常多，像假新闻、黑稿、题文不符、标题党、内容质量低等等，这部分内容由机器理解是非常难的，需要大量反馈信息，包括其他样本信息比对。目前低质模型的准确率和召回率都不是特别高，还需要结合人工复审，将阈值提高。目前最终的召回已达到95%，这部分其实还有非常多的工作可以做。别平台。如果需要机器学习视频，可以在公众号后台聊天框回复【机器学习】，可以免费获取编程视频。你可能还喜欢数学在机器学习中到底有多重要？ AI 新手学习路线，附上最详细的资源整理！提升机器学习数学基础，推荐7本书酷爆了！围观2020年十大科技趋势机器学习该如何入门，听听过来人的经验！长按加入T圈，接触人工智能觉得内容还不错的话，给我点个“在看”呗本篇文章为转载内容。原文链接：https://blog.csdn.net/itcodexy/article/details/109574173。该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

2024-01-13 09:21:23

322

转载

知识学习

实践的时候请根据实际情况谨慎操作。

随机学习一条linux命令：

du -sh * - 在当前目录下查看所有文件和目录的大致大小。