首页 文章 精选 留言 我的

精选列表

搜索[学习]，共10000篇文章
优秀的个人博客,低调大师

Hadoop大数据开发框架学习

一.Hadoop框架介绍 hadoop是Apache发布的开源分布式基础架构他的两个核心是 HDFSHDFS是Hadoop的文件管理系统，负责了海量数据的存储，是做大数据的基础 MapReduceMapReduce则是为了海量数据提供了计算 两部分就组成了Hadoop的分布式基础架构 二.HDFS介绍 HDFS作为Hadoop为存储海量数据，自然有着与传统文件系统有着不同的结构，它是以Linux文件系统的基础的架构，构建里一套分布式文件系统，它是由一个NameNode和多台DataNode组成的。他通过将文件进行划分，分成多个数据块进行存储。（默认64MB，一般设置为128MB，备份X3）NameNode 管理文件系统的命名空间，存放文件元数据 维护文件系统的所有文件和目录，文件与数据块的映射 记录每个文件中各个块所在数据节点的信息 DataNode 存储并检索数据块 香NameNode更新所存储块的列表 优点 适合大文件存储，有副本策略 可以构建在廉价机器上，有一定容错和恢复机制 支持流式数据访问，一次写入多次读取 缺点 不适合大量小文件存储 不适合并发写入，不支持文件随机修改 不支持随机读等低延时的访问方式 二.Yarn yarn是Hadoop 中的资源管理器，MapReduce通过yarn来调度。ResourceManager 分配和调度资源 启动并监控ApplicationMaster 监控NodeManager ApplicationMaster 为MapReduce类型程序申请资源，并分配给内部任务 负责数据的切分 监控任务的执行与容错 NodeManager 管理单个节点的资源 处理来自ResourceManager的命令 处理来自ApplicationMaster的命令 四.MapReduce MapReduce采用分而治之的编程思想 输入一个大文件，通过split之后，将其分为多个分片 每个文件分片由单独的机器去处理，这就是Map方法 将每个机器计算的结果进行汇总并得到最终的结果，这就是Reduce方法
2018-08-31
优秀的个人博客,低调大师

MyBatis学习笔记(二) 关联关系

一、一对一关系 还是通过例子来解释说明。（一个妻子对应一个丈夫）。 1)数据库信息 create table t_wife( id int primary key auto_increment, wife_name varchar(20), fk_husband_id int ); create table t_husband( id int primary key auto_increment, husband_name varchar(20) ); insert into t_husband values (null,'hello'); insert into t_wife values(null,'kitty',1) 2）对应的JavaBean代码 虽然在数据库里只有一方配置的外键，但是这个一对一是双向的关系。 HusbandBean.java package com.cy.mybatis.beans; import java.io.Serializable; /** * one to one * @author acer * */ public class HusbandBean implements Serializable{ private static final long serialVersionUID = 1L; private Integer id; private String name; private WifeBean wife; public HusbandBean() { super(); } public HusbandBean(Integer id, String name, WifeBean wife) { super(); this.id = id; this.name = name; this.wife = wife; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public WifeBean getWife() { return wife; } public void setWife(WifeBean wife) { this.wife = wife; } @Override public String toString() { return "Husband [id=" + id + ", name=" + name + ", wife=" + wife + "]"; } } WifeBean.java package com.cy.mybatis.beans; import java.io.Serializable; /** * one to one * @author acer * */ public class WifeBean implements Serializable{ private static final long serialVersionUID = 1L; private Integer id; private String name; private HusbandBean husband; public WifeBean() { super(); } public WifeBean(Integer id, String name, HusbandBean husband) { super(); this.id = id; this.name = name; this.husband = husband; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public HusbandBean getHusband() { return husband; } public void setHusband(HusbandBean husband) { this.husband = husband; } @Override public String toString() { return "Wife [id=" + id + ", name=" + name + ", husband=" + husband + "]"; } } 3）接下来建立两个接口，HusbandMapper,WifeMapper. HusbandMapper package com.cy.mybatis.mapper; import com.cy.mybatis.beans.HusbandBean; public interface HusbandMapper { /** * 根据id查询丈夫信息 * @param id * @return * @throws Exception */ public HusbandBean selectHusbandById (int id) throws Exception; /** * 根据id查询丈夫与妻子信息 * @param id * @return * @throws Exception */ public HusbandBean selectHusbandAndWife(int id) throws Exception; } 4）定义HusbandMapper.xml文件 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.cy.mybatis.mapper.HusbandMapper"> <resultMap type="HusbandBean" id="husbandAndWife"> <id property="id" column="id" javaType="java.lang.Integer"/> <result property="name" column="name" javaType="java.lang.String"/> <!-- association – 一个复杂的类型关联；许多结果将包成这种类型 嵌入结果映射 – 结果映射自身的关联，或者参考一个 column="id" 这里的id指的是在t_wife表来的主键id 这个查询妻子，所以在妻子mapper里有个方法 --> <association property="wife" column="id" javaType="WifeBean" select="com.cy.mybatis.mapper.WifeMapper.selectWifeByHusbandId" ></association> </resultMap> <!-- resultType 返回类型 从这条语句中返回的期望类型的类的完全限定名或别名 。--> <select id="selectHusbandById" resultType="HusbandBean"> select * from t_husband where id=#{id} </select> <!-- resultMap 命名引用外部的 resultMap。返回的是一个集合。--> <select id="selectHusbandAndWife" resultMap="husbandAndWife"> select * from t_husband where id=#{id} </select> </mapper> 在WifeMapper.xml里有个方法 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.cy.mybatis.mapper.WifeMapper"> <select id="selectWifeByHusbandId" resultType="WifeBean"> select * from t_wife where fk_husband_id = #{id} </select> </mapper> 5）写个实现 package com.cy.mybatis.service; import org.apache.ibatis.session.SqlSession; import com.cy.mybatis.beans.HusbandBean; import com.cy.mybatis.mapper.HusbandMapper; import com.cy.mybatis.tools.DBTools; public class OneToOneService { public static void main(String[] args) { selectHusbandAndWife(); } private static void selectHusbandAndWife() { SqlSession session = DBTools.getSession(); HusbandMapper hm = session.getMapper(HusbandMapper.class); try { HusbandBean husband = hm.selectHusbandAndWife(1); System.out.println(husband); session.commit(); } catch (Exception e) { e.printStackTrace(); } } } 注意：那个工具类还是前一章那样写的，就相当与在昨天的基础上建立的。 注意： mybatis实际是对XML进行操作，我们所有的方法都直接定义在XML中，写个接口只是为了更好的符合我们3层的思想，如果不写接口，直接通过session也可以直接操作xml中的方法 ， XML中只要有方法，就可以使用，而调用的方式就是：namespace+方法名； 例外使用resultType时，一定要保证，你属性名与字段名相同； 如果不相同，就使用resultMap 。 二、一对多关系 还是通过例子来解释说明。（一把锁对应多把钥匙）。 2.1）数据库信息 这里没有添加数据了，我们用批量添加数据 create table t_key( id int primary key auto_increment, key_name varchar(20), fk_lock_id int ); create table t_lock( id int primary key auto_increment, lock_name varchar(20) ); 2.2) 实体类 KeyBean.java package com.cy.mybatis.beans; import java.io.Serializable; /** * manyTOone * * */ public class KeyBean implements Serializable { private static final long serialVersionUID = 3712545874604618746L; private Integer id; private String key; private LockBean lock; public KeyBean() { super(); } public KeyBean(Integer id, String key, LockBean lock) { super(); this.id = id; this.key = key; this.lock = lock; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getKey() { return key; } public void setKey(String key) { this.key = key; } public LockBean getLock() { return lock; } public void setLock(LockBean lock) { this.lock = lock; } @Override public String toString() { return "KeyBean [id=" + id + ", key=" + key + ", lock=" + lock + "]"; } } LockBean.java package com.cy.mybatis.beans; import java.io.Serializable; import java.util.List; /** * oneTOmany * * */ public class LockBean implements Serializable{ private static final long serialVersionUID = 7092410462131162665L; private Integer id; private String lock; private List<KeyBean> keys; public LockBean() { super(); } public LockBean(Integer id, String lock, List<KeyBean> keys) { super(); this.id = id; this.lock = lock; this.keys = keys; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getLock() { return lock; } public void setLock(String lock) { this.lock = lock; } public List<KeyBean> getKeys() { return keys; } public void setKeys(List<KeyBean> keys) { this.keys = keys; } @Override public String toString() { return "LockBean [id=" + id + ", keys=" + keys + ", lock=" + lock + "]"; } } 2.3) 建立接口 KeyMapper.java package com.cy.mybatis.mapper; import java.util.List; import org.apache.ibatis.annotations.Param; import com.cy.mybatis.beans.KeyBean; public interface KeyMapper { /** * 批量添加钥匙 * @return * 提倡 这样使用 @Param("keys") */ public int batchSaveKeys(@Param("keys")List<KeyBean> keys); } LockMapper.java package com.cy.mybatis.mapper; import org.apache.ibatis.annotations.Param; import com.cy.mybatis.beans.LockBean; public interface LockMapper { /** * 添加锁 * @param lock * @return */ public int saveLock(@Param("lock")LockBean lock); /** * 根据ID查询锁的资料 * @param id * @return */ public LockBean findLockById(int id); /** * 根据ID查询锁与钥匙的资料 * one2many * @param id * @return */ public LockBean findLockAndKeys(int id); } 2.4) 建立xml文件 KeyMapper.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.cy.mybatis.mapper.KeyMapper"> <resultMap id="keyMap" type="KeyBean"> <id property="id" column="id" javaType="java.lang.Integer"/> <result property="key" column="key_name" javaType="java.lang.String"/> </resultMap> <!--collection 为用于遍历的元素（必选），支持数组、List、Set --> <!-- item 表示集合中每一个元素进行迭代时的别名. --> <!--separator表示在每次进行迭代之间以什么符号作为分隔 符. --> <insert id="batchSaveKeys"> insert into t_key values <foreach collection="keys" item="key" separator=","> (null,#{key.key},#{key.lock.id}) </foreach> </insert> <select id="findKeysByLockId" resultMap="keyMap"> select * from t_key where fk_lock_id = #{id} </select> </mapper> LockMapper.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.cy.mybatis.mapper.LockMapper"> <!--自定义返回类型 --> <resultMap id="lockMap" type="LockBean"> <id property="id" column="id" javaType="java.lang.Integer"/> <result property="lock" column="lock_name" javaType="java.lang.String"/> </resultMap> <!--自定义返回类型 --> <resultMap id="lockAndKeysMap" type="LockBean"> <id property="id" column="id" javaType="java.lang.Integer"/> <result property="lock" column="lock_name" javaType="java.lang.String"/> <collection property="keys" column="id" select="com.cy.mybatis.mapper.KeyMapper.findKeysByLockId"></collection> </resultMap> <insert id="saveLock"> insert into t_lock values (null,#{lock.lock}) </insert> <select id="findLockById" resultMap="lockMap"> select * from t_lock where id= #{id} </select> <select id="findLockAndKeys" resultMap="lockAndKeysMap"> select * from t_lock where id= #{id} </select> </mapper> 2.5 ） 实现 package com.cy.mybatis.service; import java.util.ArrayList; import java.util.List; import org.apache.ibatis.session.SqlSession; import com.cy.mybatis.beans.KeyBean; import com.cy.mybatis.beans.LockBean; import com.cy.mybatis.mapper.KeyMapper; import com.cy.mybatis.mapper.LockMapper; import com.cy.mybatis.tools.DBTools; public class OneToManyService { public static void main(String[] args) { // saveLock(); // batchSaveKeys(); findLockAndKeys(); } private static void findLockAndKeys() { SqlSession session = DBTools.getSession(); LockMapper lm = session.getMapper(LockMapper.class); LockBean lock = lm.findLockAndKeys(1); System.out.println(lock); } private static void batchSaveKeys() { SqlSession session = DBTools.getSession(); LockMapper lm = session.getMapper(LockMapper.class); KeyMapper km = session.getMapper(KeyMapper.class); LockBean lock = lm.findLockById(1); List<KeyBean> keys = new ArrayList<KeyBean>(); for(int i = 0; i < 5; i++){ KeyBean key = new KeyBean(null, "钥匙"+i, lock); keys.add(key); } km.batchSaveKeys(keys); session.commit(); } private static void saveLock() { SqlSession session = DBTools.getSession(); LockMapper lm = session.getMapper(LockMapper.class); LockBean lock = new LockBean(null, "锁1", null); lm.saveLock(lock); session.commit(); } } 结果显示： 原文发布时间为：2018-08-30本文来自云栖社区合作伙伴“ 全栈开发者社区”，了解相关信息可以关注“ 全栈开发者社区”。
2018-08-30
优秀的个人博客,低调大师

PHP学习7——文件系统

主要内容： 打开和关闭文件 文件类型 文件处理 目录处理 访问远程文件 文件锁定 文件上传 数据除了可以存储在数据库中，我们主要的还是存储在文件中，而且存储在文件中更加的方便直接。 打开和关闭文件 打开fopen($filepath,$mode) 关闭fclose($file) 注意，我的test.txt文件和demo.php在同一个目录下 demo.php <?php //打开文件r只读，r+读写，打开成功返回true，否则false $file=fopen("C:/xampp/htdocs/test.txt","r");//绝对路径 if($file){ echo "文件test.txt打开了<br/>"; }else{ echo "文件test.txt打开失败文件打开了<br/>"; } $file2=fopen("./test.txt","r");//相对路径 if($file2){ echo "文件test.txt打开了<br/>"; }else{ echo "文件test.txt打开失败<br/>"; } if(fclose($file)){ echo "文件test.txt成功关闭<br/>"; } if(fclose($file2)){ echo "文件test.txt成功关闭<br/>"; } ?> 输出 文件test.txt打开了 文件test.txt打开了 文件test.txt成功关闭 文件test.txt成功关闭 文件类型 无论是txt文件还是jpg文件，还是doc文件，都属于同一种文件类型，file 文件夹是另外一种文件类型，dir 文件类型： file普通文件 dir目录类型 char字符串设备，键盘，打印机 block块设备，某个磁盘分区 link快捷方式，指针的指针 fifo管道，用于把一个进程传到另外一个进程 unknow未知文件 使用filetype($filename)判断文件的类型，返回字符串 stat($filename)可以输出文件的大部分属性 stat.php <?php print_r(stat("./test.txt")); ?> 输出 Array ( [0] => 2 [1] => 0 [2] => 33206 [3] => 1 [4] => 0 [5] => 0 [6] => 2 [7] => 12 [8] => 1533566405 [9] => 1533566414 [10] => 1533566405 [11] => -1 [12] => -1 [dev] => 2 [ino] => 0 [mode] => 33206 [nlink] => 1 [uid] => 0 [gid] => 0 [rdev] => 2 [size] => 12 [atime] => 1533566405 [mtime] => 1533566414 [ctime] => 1533566405 [blksize] => -1 [blocks] => -1 ) 文件处理 readfile($filename)读取文件内容写入输出缓冲，并返回文件字符串大小，报错返回false fgets($filename)从文件指针读取一行，出错返回false fgetc($filename)从文件指针读取一个字符，出错返回false readfile.php <?php readfile("./test.txt"); ?> test.txt 输出 这是一个测试 这是一个测试这是一个测试 这是一个测试这是一个测试 这是一个测试这是一个测试 这是一个测试这是一个测试 这是一个测试这是一个测试 这是一个测试这是一个测试 fwrite($filename,$date)向文件中写入信息 fwrite.php <?php //使用@隐藏提示信息，@叫做错误控制运算符 $file=@fopen("./test.txt","r+"); echo $file."<br/>"; $num=fwrite($file,"今天是个好日子，心想的事儿都能成"); if($num){ echo "写入成功，写入了$num 字符"; }else{ echo "写入失败"; } ?> 输出 Resource id #3 写入成功，写入了48 字符 test.txt 但是使用r+模式，会覆盖原先的内容，如果不想覆盖原先的内容，而是在原先基础上增加内容，应该使用追加模式，这里不研究。 常用方法： copy($source,$dest)复制文件到指定路径 rename($oldname,$newname)重命名文件 unlink($filename)删除文件 pathinfo($path,$options)返回文件的路径信息 realpath($path)返回文件的绝对路径 is_file($filename)判断是否是文件 目录处理 目录是一种特殊的文件类型 判断是否是目录isdir($path) 打开目录opendir($path) 关闭目录closedir($path) dir.php <?php $path="D:\资料"; if(is_dir($path)){ //打开目录 $dir=opendir($path); echo "文件打开成功<br/>"; }else{ echo "打开失败，程序退出<br/>"; exit(); } closedir($dir); ?> 输出 文件打开成功 操作目录方法： readdir($path)浏览目录，返回一个文件名 mkdir($pathname)创建目录 rmdir($pathname)删除目录 chdir($pathname)改变目录 dir_operate.php <?php if(chdir("D:/")){ echo "切换到D:/<br/>"; }//成功返回1 if(mkdir("D:/test")){ echo "创建文件夹D:/test<br/>"; }//成功返回1 if(rmdir("D:/test")){ echo "删除文件夹D:/test<br/>"; }//成功返回1 ?> 输出 切换到D:/ 创建文件夹D:/test 删除文件夹D:/test 访问远程文件 PHP支持URL格式的文件调用，需要在php.ini中设置一下 url_file.php <?php $html=file_get_contents("http://www.baidu.com/"); echo $html; ?> 输出 文件锁定 在向一个文件写入内容时，如果其他用户也修改这个文件，可能会造成冲突，为了防止冲突，使用flock()来锁定文件 flock.php <?php $file=fopen("C:/xampp/htdocs/test.txt","r+"); if(flock($file,LOCK_EX)){ echo "文件已经锁定，可以安全写入数据"; }else{ echo "文件未锁定，写入数据是不安全的"; } fclose($file); ?> 输出 文件已经锁定，可以安全写入数据 文件上传 首先需要配置php.ini文件 单文件上传 使用move_upload_file($tmpname,$name) upload.php <html> <form method="post" enctype="multipart/form-data"> <input type="file" name="upfile" /> <input type="submit" value="上传" /> </form> </html> <?php $file=fopen("C:/xampp/htdocs/test.txt","r+"); if(!empty($_FILES)){ foreach($_FILES["upfile"] as $k=>$v){ echo "$k=>$v<br/>"; } }else{ echo "没有上传文件"; } ?> 未上传效果 上传文件 上传成功 upload2.php <html> <form method="post" enctype="multipart/form-data"> <input type="file" name="upfile" /> <input type="submit" value="上传" /> </form> </html> <?php if(!empty($_FILES)){ $tmpname=$_FILES["upfile"]["tmp_name"];//文件临时名 $name=$_FILES["upfile"]["name"];//文件原名 move_uploaded_file($tmpname,$name)or die("文件上传失败，程序退出"); echo "文件上传成功"; }else{ echo "没有上传文件"; } ?> 未上传 上传 文件已经上传到跟目录 ok，文件上传先到这里
2018-08-06
优秀的个人博客,低调大师

ES6学习笔记（一）

一、let 命令 1、let命令 1.1基本用法 1.1.1 let用于声明变量 类似var，但是let声明的变量只在当前代码块内有效 { let a = 10; var b = 1; } a // ReferenceError: a is not defined. b // 1 let命令在for 循环的计数器中很实用。 1.1.2 let不存在变量提升 var命令会发送“变量提升”，即变量可以在声明之前使用，值为undefined 正常来说变量使用一定要在声明之后。 1.1.3 暂时性死区 只要块级作用域内存在let命令，它所生命的变量就绑定（binding）这个区域，不受外部影响。 ES6明确规定，在区块中存在let 和 const命令，这个区块对这些命令声明的变量都是 不能提前使用的，会报错。 总之在代码块之内，Let声明的变量不可提前使用。 1.1.4不允许重复声明 let不允许在相同作用域内重复声明同一个变量。所以不能在函数内部重新声明参数。 function func(arg) { let arg; // 报错 } function func(arg) { { let arg; // 不报错 } } 1.1.5 ES6的块级作用域 let为JavaScript新增了块级作用域，允许块级作用域的任意嵌套。 {{{{{let insane = 'Hello World'}}}}}; 外层作用域无法读取内层作用域内的变量。 {{{{ {let insane = 'Hello World'} console.log(insane); // 报错 }}}}; 内层作用域可以定义外层作用域的同名变量。 {{{{ let insane = 'Hello World'; {let insane = 'Hello World'} }}}}; 1.1.6 允许块级作用域中声明函数 // 浏览器的 ES6 环境 function f() { console.log('I am outside!'); } (function () { if (false) { // 重复声明一次函数f function f() { console.log('I am inside!'); } } f(); }()); // Uncaught TypeError: f is not a function ES6的块级作用域允许声明函数的规则只在使用大括号的前提下成立，否则就会报错。 1.1.7 do表达式 块级作用域是一个语句，将多个操作封装在一起，没有返回值。 使得块级作用域可以变为表达式，也就是说可以返回值，办法就是在块级作用域之前加上do，使它变为do表达式。 let x = do { let t = f(); t * t + 1; }; 上面代码中，变量x会得到整个块级作用域的返回值。
2018-07-30
优秀的个人博客,低调大师

Java 学习（21）--集合笔试题

集合笔试题 1.产生10个1-20之间的随机数，要求随机数不能重复（List 和 Set 分别实现） 分析：1.创建一个 ArrayList 对象 2.如果 ArrayList 对象长度小于 10 3.在循环中，创建一个 Random 对象，产生 1-20 之间的随机数 4. 通过 ArrayList 对象 d constains 方法判断，该随机数是否存在于集合中，不存在则加入，存在则放弃。 代码： 1.List package com.neuedu.collection; import java.util.ArrayList; import java.util.Random; public class Demo1 { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); while(list.size() < 10){ Random random = new Random(); int nextInt = random.nextInt(20) + 1; if(!list.contains(nextInt)) { list.add(nextInt); } } System.out.println(list); } } 输出： 2.Set (无序【添加顺序和打印顺序不一致】、不重复) package com.neuedu.collection; import java.util.HashSet; import java.util.Set; public class Demo2 { public static void main(String[] args) { Set set = new HashSet<Integer>(); while(set.size() < 10) { int random = (int)(Math.random() * 20) + 1; set.add(random); } System.out.println(set); } } 输出： 拓展：当两个内容相同则输出一个，不同则都输出 hashcode: 根据一个对象，通过一定的算法，计算出一个 32位 的 2进制 表示的数据（不定长数据 转换 定长数据） Objecthashcode（默认的hashcode）:根据对象在内存的地址来计算hashcode 值（基本都不相同） name 是string 类型，string 类型重写 hashcode ，当字符串内容相同则 hashcode 值相同（属性相关） set 结构： 竖：hashtable(hash 桶）里面的小格（hashcode），当hashcode 值相同时才会放到同一个小格里面； 横：LinkedList(链表)，里面的小格（equal 后的值），若二者相同则表示在链表的同一格里面，重复的不在添加到小格中；如二者不同则不在同一格里面，将不同的放在后面的小格里面。 package com.neuedu.collection; import java.util.HashSet; import java.util.Set; public class SetDemo { public static void main(String[] args) { Set<Person> set = new HashSet<Person>(); Person p1 = new Person("林青霞", 50); Person p2 = new Person("林青霞", 40); set.add(p1); set.add(p2); System.out.println(set); } } class Person { private String name; private int age; public Person(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } @Override public int hashCode() { return name.hashCode() + age; } @Override public boolean equals(Object obj) { if(!(obj instanceof Person)){ return false; } Person person = (Person)obj; if(this.name.equals(person.name) && this.age == person.age) { return true; } return false; } } 输出： 2.键盘录入5个学生信息（姓名、语文成绩、数学成绩、英语成绩）按照总分从高到低的顺序（若总分相同，则按照语文、数学、英语的成绩进行倒序） 二叉树：24 18 30 16 20 28 35 中序遍历（详解） ：左 中 右 16 18 20 24 28 30 35 package com.neuedu.collection; import java.util.Scanner; import java.util.Set; import java.util.TreeSet; public class Demo3 { public static void main(String[] args) { TreeSet<Student> treeSet = new TreeSet<>(); Scanner scanner = new Scanner(System.in); for(int i = 1; i <= 5; i++) { System.out.println("请输入第" + i + "个学生的信息"); System.out.println("姓名："); String name = scanner.next(); System.out.println("语文 成绩："); int chinese = scanner.nextInt(); System.out.println("数学成绩："); int math = scanner.nextInt(); System.out.println("英语成绩："); int english = scanner.nextInt(); Student student = new Student(name, chinese, math, english); treeSet.add(student); } System.out.println("学生成绩录入完毕"); System.out.println("按照分数排序后的结果是："); System.out.println(treeSet); } } class Student implements Comparable<Student>{ private String name; private int chinese; private int math; private int english; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getChinese() { return chinese; } public void setChinese(int chinese) { this.chinese = chinese; } public int getMath() { return math; } public void setMath(int math) { this.math = math; } public int getEnglish() { return english; } public void setEnglish(int english) { this.english = english; } public int getTotal() { return chinese + english + math; } @Override public String toString() { return "Student [name=" + name + ", chinese=" + chinese + ", math=" + math + ", english=" + english + "]"; } public Student(String name, int chinese, int math, int english) { super(); this.name = name; this.chinese = chinese; this.math = math; this.english = english; } @Override public int compareTo(Student o) { int temp = o.getTotal() - this.getTotal(); if(temp == 0) { temp = o.chinese - this.chinese; } if(temp == 0) { temp = o.math - this.math; } if(temp == 0) { temp = o.english - this.english; } /*temp = (temp != 0 ? temp : (o.chinese - this.chinese)); temp = (temp != 0 ? temp : (o.math - this.math)); temp = (temp != 0 ? temp : (o.english - this.english));*/ return temp; } } 输出：（只有2名学生） 3.“aababcabcdabcde”获取字符串中每个字母出现的次数，要求结果 a(5) b(4) c(3) 分析：1.将字符串转换成一个字符数组 2.对字符数组进行遍历，放到 Set 集合中 package com.neuedu.collection; import java.util.Map.Entry; import java.util.Scanner; import java.util.Set; import java.util.TreeMap; import java.util.TreeSet; import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper; public class Demo4 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入字符串"); String str = scanner.next(); TreeSet<Character> treeSet = new TreeSet<>(); for(int i = 0; i < str.length(); i++) { treeSet.add(str.charAt(i)); } System.out.println(treeSet); for(Character c : treeSet) { int count = 0; for(int i = 0; i < str.length(); i++) { if(str.charAt(i) == c) { count++; } } System.out.print(c+"(" + count + ") " ); } } } 输出： 方法二： package com.neuedu.collection; import java.util.Map.Entry; import java.util.Scanner; import java.util.Set; import java.util.TreeMap; import java.util.TreeSet; import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper; public class Demo4 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入字符串"); String str = scanner.next(); TreeMap<Character, Integer> map = new TreeMap<>(); //遍历字符串 for(int i = 0; i < str.length(); i++) { //获取每个字符 Character key = str.charAt(i); //判断map中是否包含该字符，如果不包含，value=1， if(!map.containsKey(key)) { map.put(key, 1); }else {//如果map中已经包含改字符，则取出原来的值+1 map.put(key, map.get(key) + 1); } } StringBuffer sb = new StringBuffer(); Set<Entry<Character, Integer>> entrySet = map.entrySet(); for(Entry<Character, Integer> entry : entrySet) { sb.append(entry.getKey()).append("(").append(entry.getValue()).append(") "); } System.out.println(sb.toString()); } 输出： 标准方法： //“aababcabcdabcde”获取字符串中每个字母出现的次数，要求结果 a(5) b(4) c package com.hd.file; import java.util.Set; import java.util.TreeMap; public class demo3 { public static void main(String[] args) { String str = "aababcabcdabcde"; TreeMap<Character,Integer> map = new TreeMap<Character,Integer>(); char[] chs = str.toCharArray(); for(Character ch:chs){ Integer value = map.get(ch); if(value==null){ map.put(ch, 1); }else{ value++; map.put(ch, value); } } Set<Character> set = map.keySet(); StringBuilder sb = new StringBuilder(); for(Character s:set){ Integer value = map.get(s); sb.append(s).append("(").append(value).append(")"); } System.out.println(sb.toString()); } } 输出： 4.模拟斗地主洗牌、发牌、看牌 方法一： 分析： 分析： * 1：创建一副牌 * 1.1 : 创建一个牌盒 * 1.2： 装牌 * 2：洗牌 * 3：发牌 * 4：看牌 package com.neuedu.collection; import java.util.ArrayList; import java.util.Collections; public class PokerDemo { public static void main(String[] args) { ArrayList<String> poker = new ArrayList<>(); String[] colors = {"","","",""}; String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"}; for(String color : colors) { for(String number : numbers) { poker.add(color.concat(number)); } } poker.add("大王"); poker.add("小王"); //洗牌 Collections.shuffle(poker); //创建打牌的人 ArrayList<String> rulai = new ArrayList<>(); ArrayList<String> sunwukong = new ArrayList<>(); ArrayList<String> weiwei = new ArrayList<>(); ArrayList<String> dipai = new ArrayList<>(); //摸牌 for(int i = 0; i < poker.size(); i++) { if(i >= poker.size() - 3) { dipai.add(poker.get(i)); } if(i % 3 == 0) { rulai.add(poker.get(i)); } if(i % 3 == 1) { sunwukong.add(poker.get(i)); } if(i % 3 == 2) { weiwei.add(poker.get(i)); } } //看牌 lookPoker("A", rulai); lookPoker("B", sunwukong); lookPoker("C", weiwei); lookPoker("底牌", dipai); } public static void lookPoker(String name, ArrayList<String> pai) { System.out.println(name + "的牌是："); for(String s : pai) { System.out.print(s + " "); } System.out.println(); } } 输出： 方法二： 思路： * 1:创建一个HashMap集合 * 2：创建一个ArrayList,用来存放牌的编号 * 3：创建花色数组和点数数组 * 4：从1编号开始向Hashmap中存放相应的编号和对应的牌，同时往ArrayList中存储编号 * 5：洗牌（洗的是编号） * 6：发牌（发牌发的也是编号，为了保证编号是排序的，应该创建一个TreeSet集合） * 7：看牌（遍历TreeSet，获取编号，然后从HashMap中找到对应的牌） package com.neuedu.collection; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.TreeSet; /** * 4: 模拟斗地主洗牌、发牌和看牌 * 思路： * 1:创建一个HashMap集合 * 2：创建一个ArrayList,用来存放牌的编号 * 3：创建花色数组和点数数组 * 4：从1编号开始向Hashmap中存放相应的编号和对应的牌，同时往ArrayList中存储编号 * 5：洗牌（洗的是编号） * 6：发牌（发牌发的也是编号，为了保证编号是排序的，应该创建一个TreeSet集合） * 7：看牌（遍历TreeSet，获取编号，然后从HashMap中找到对应的牌） * */ public class PokerDemo2 { public static void main(String[] args) { Map<Integer,String> poker = new HashMap<>(); List<Integer> num = new ArrayList<>(); String[] colors = {"","","",""}; String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"}; int count = 1; for(String number : numbers) { for(String c : colors) { poker.put(count, c.concat(number)); num.add(count); count++; } } poker.put(count, "小王"); num.add(count); count++; poker.put(count, "大王"); num.add(count); //洗牌 Collections.shuffle(num); TreeSet<Integer> linQingXia = new TreeSet<>(); TreeSet<Integer> zhouRunFa = new TreeSet<>(); TreeSet<Integer> liuDeHua = new TreeSet<>(); TreeSet<Integer> diPai = new TreeSet<>(); for(int i = 0; i <num.size(); i++) { if(i >= num.size() - 3) { diPai.add(num.get(i)); continue; } if(i % 3 == 0) { linQingXia.add(num.get(i)); } if(i % 3 == 1) { zhouRunFa.add(num.get(i)); } if(i % 3 == 2) { liuDeHua.add(num.get(i)); } } //看牌 lookPoker("A", linQingXia, poker); lookPoker("B", zhouRunFa, poker); lookPoker("C", liuDeHua, poker); lookPoker("底牌", diPai, poker); } public static void lookPoker(String name,Set<Integer> set,Map<Integer, String> map) { System.out.println(name + "的牌是："); for(Integer key : set) { System.out.print(map.get(key) + " "); } System.out.println(); } } 输出：
2018-07-23
优秀的个人博客,低调大师

Java 学习（20）--异常 / IO 流

异常（Exception） (1)程序出现的不正常的情况。 (2)异常的体系 Throwable（接口，将异常类对象交给 JVM 来处理） |--Error 严重问题，我们不处理。(jvm 错误，程序无法处理) |--Exception异常 （程序可以处理的异常） |--RuntimeException （运行期异常，可以通过逻辑判断进行控制，不需要捕获 处理方法：1.try...catch 2.throws） |--其他（受查）异常 （继承自Exception，且不是RuntimeException，必须要捕获） (3)异常的处理： A:JVM 的默认处理 当系统发生运行异常时，Jvm 会创建一个异常类的对象；查看是否对这个异常进行捕获和处理，若没有，则把异常的名称 ,原因,位置等信息输出在控制台，但是程序不能继续执行了。 B:自己处理 a:try...catch...finally 自己编写处理代码 ,后面的程序可以继续执行 b:throws 把自己处理不了的，在方法上声明，告诉调用者，这里有问题 (4)面试题 A:编译期异常和运行期异常的区别 ? 编译期异常必须要处理的，否则编译不通过；运行期异常可以不处理，也可以处理 B:throw和 throws 的区别 throw:在方法体中,后面跟的是异常对象名 ,并且只能是一个 throw 抛出的是一个异常对象，说明这里肯定有一个异常产生了 throws:在方法声明后,后面跟的是异常的类名 , 可以是多个 ；throws 是声明方法有异常，是一种可能性，这个异常并不一定会产生， (5)finally A:finally用于释放资源，它的代码永远会执行。 特殊情况：在执行到 finally 之前jvm 退出了 B:面试题 a:final,finally,finalize 的 区 别 ? 详解 b: 如果在 catch里面有 return, 请问 finally还执行吗 ?如果执行 ,在 return前还是后 会/前（实际上在中间） C:异常处理的变形 try...catch...finally / try...catch... / try...catch...catch.../try...catch...catch...fianlly / try...finally (6)自定义异常 继承自 Exception 或者 RuntimeException, 只需要提供无参构造和一个带参构造即可 (7)异常的注意实现 A:父的方法有异常抛出 ,子的重写方法在抛出异常的时候必须要小于等于父的异常 B:父的方法没有异常抛出 ,子的重写方法不能有异常抛出 C:父的方法抛出多个异常 ,子的重写方法必须比父少或者小 IO 流 File 我们要想实现输入输出操作就必须要知道，java在硬盘上的表现形式,也就是说硬盘上面的文件和文件夹在java中有一个专门的 类来表示：File;IO流操作中大部分都是对文件的操作，所以 Java就提供了 File类供我们来操作文件 (java类:成员变量，成员方法，构造方法，成员代码块，成员内部类) 构造方法 A:File file =newFile("e:\\demo\\a.txt");// 根据一个路径得到 File对象 B:File file =newFile("e:\\demo","a.txt");// 根据一个目录和一个子文件 /目录得到File 对象 C:File file = new File("e:\\demo"); File file2 =newFile(file,"a.txt");// 根据一个父 File对象和一个子文件 /目录得到File对象 1.File(File parent, String child) :根据一个File对象和一个文件名创建File对象 2.File(String pathname)：根据指定的路径创建File对象 3.File(String parent, String child) :根据一个路径字符串和一个文件名创建File对象 public class FileDemo1 { public static void main(String[] args) throws IOException { File file = new File("d:\\test\\a.txt"); //全路径 File file1 = new File("d:\\test", "a.txt"); //真正的路程 ， 要创建的文件名 File file1 = new File("d:\\test"); File file2 = new File(file1,"a.txt"); //将路径封装到 file 对象里去； //封装好的对象 ， 要创建的文件名 //以上三种方式实现的效果是一样的 System.out.println(file2); } } File 类的功能 A:创建功能 publicbooleancreateNewFile() :根据file对象的路径，创建一个硬盘中的文件或路径, 如果没有对应的路径，就会抛出异常 java.io.IOException； 如果该路径下没有对应文件，则创建成功，返回true； 如果该文件已经存在则创建失败，返回false publicbooleanmkdir(): 创建一个文件夹,创建成功返回true 如果没有对应的路径，则创建失败，返回false 如果该文件夹已经存在，则创建失败，返回false publicbooleanmkdirs() :创建文件夹，如果路径中的文件夹不存在，就一起创建出来 public class FileDemo2 { public static void main(String[] args) throws IOException { File file = new File("d:\\test\\a.txt"); System.out.println("createNewFile:" + file.createNewFile()); File file = new File("d:\\test\\demo"); System.out.println("mkdir:" + file.mkdir()); File file1 = new File("d:\\test\\aaa"); System.out.println("mkdir:" + file1.mkdir()); File file2 = new File("d:\\test\\aaa\\bbb"); System.out.println("mkdir:" + file2.mkdir()); File file3 = new File("d:\\test\\aaa\\bbb\\ccc"); System.out.println("mkdir:" + file3.mkdir()); File file = new File("d:\\test\\aaa\\bbb\\ccc"); System.out.println("mkdirs:" + file.mkdirs()); //说明骑白马的不一定是王子 File file = new File("D:\\test\\a.txt"); System.out.println("mkdir:" + file.mkdir()); } } B:删除功能 public boolean delete() ：java删除不走回收站，所删除时一定要小心；如果删除时对应的路径名不存在， 则删除失败，返回false；删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录必须为空才能删除。 public class FileDemo3 { public static void main(String[] args) throws IOException { File file = new File("d:\\test\\aaa\\bbb"); System.out.println("delete:" + file.delete()); } } C:重命名功能 public boolean renameTo(File dest) ：将File对象对应的路径名改为传入的file对象对应路径名， 如果重命名前后的两个文件不在同一个文件夹下，则该方法有剪切的效果 如果路径名相同，就是改名。 如果路径名不同，就是改名并剪切。 路径以盘符开始：绝对路径 c:\\a.txt 路径不以盘符开始：相对路径 a.txt public class FileDemo4 { public static void main(String[] args) throws IOException { File file = new File("d:\\test\\lihongxiao.txt"); File newFileName = new File("d:\\test\\demo\\weiwei.txt"); System.out.println("renameTo:" + file.renameTo(newFileName)); File file = new File("aaa.txt"); file.createNewFile(); //没有写盘符，叫做相对路径，会在项目的根路径下创建 File file = new File("aaa\\bbb\\ccc"); System.out.println("mkdirs:" + file.mkdirs()); // 相对路径 } } D:判断功能 publicbooleanisDirectory() :判断是否是文件夹 publicbooleanisFile() :判断是否是文件 publicbooleanexists(): 判 断 是 否 存 在 publicbooleancanRead(): 判 断 是 否 可 读 publicbooleancanWrite() :判断是否可写 publicbooleanisHidden() :判断是否隐藏 public class FileDemo5 { public static void main(String[] args) throws IOException { File file = new File("a.txt"); File file = new File("ccc"); System.out.println("是否文件夹：" + file.isDirectory()); File file = new File("aaa"); System.out.println("canRead:" + file.canRead()); System.out.println("canWrite:" + file.canWrite()); File file = new File("aaa"); System.out.println("canRead:" + file.canRead()); System.out.println("isHidden:" + file.isHidden()); } } E:获取功能 publicStringgetAbsolutePath() ：获取文件的绝对路径 publicStringgetPath() :获取相对路径 publicStringgetName() :获取名称 publiclonglength() :获取长度。字节数 publiclonglastModified() :获取最后一次的修改时间，毫秒值 public class FileDemo6 { public static void main(String[] args) throws IOException { File file1 = new File("aaa\\bbb\\ccc"); file1.mkdirs(); File file = new File("aaa\\bbb\\ccc\\weiwei.txt"); file.createNewFile(); System.out.println("AbsolutePath:----" + file.getAbsolutePath()); System.out.println("path:----" + file.getPath()); System.out.println("fileName:-----" + file.getName()); System.out.println("length:---" + file.length()); Date date = new Date(file.lastModified()); DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String format = df.format(date); System.out.println(format); } } F:高级获取功能 public String[] list() :获取指定目录下的所有文件或者文件夹的名称数组 public File[] listFiles() :获取指定目录下的所有文件或者文件夹的 File数组 public class FileDemo7 { public static void main(String[] args) throws IOException { File file = new File("d:\\"); for(String name : file.list()) { System.out.println(name); } File file = new File("d:\\"); for(File file1 : file.listFiles()) { System.out.println(file1.getName()+"----"+file1.getAbsolutePath()); } } } G:过滤器功能 案例： 判断D盘中是否存在后缀名为.png的文件 分析： 1：将D封装到一个File对象中 2：获取D盘下的所有的文件和文件夹 3: 从这些文件和文件夹中根据条件遍历查找满足条件的文件 public class FileDemo8 { public static void main(String[] args) throws IOException { File file = new File("D:\\"); File[] sonFiles = file.listFiles(); for(File file2 : sonFiles) { String filename = file2.getName(); if(filename.endsWith(".png") && file2.isFile()) { System.out.println(filename); } } } } 方法二：设置条件，查找满足条件的文件 public class FileDemo9 { public static class MyFilter implements FilenameFilter{ @Override public boolean accept(File dir, String name) { if(name.endsWith(".png")){ return true; } return false; } } public static void main(String[] args) throws IOException { File file = new File("D:\\"); MyFilter myFilter = new MyFilter(); String[] list = file.list(new FilenameFilter() { @Override public boolean accept(File dir, String name) { // TODO Auto-generated method stub return false; } }); for(String name : list) { System.out.println(name); } } } 总结：输出指定目录下指定后缀名的文件名称 a:先获取所有的，在遍历的时候判断，再输出 b: 先判断，再获取，最后直接遍历输出即可
2018-07-21
优秀的个人博客,低调大师

Python | Python学习之深浅拷贝

直接步入正题，聊一聊 Python 中的深浅拷贝 关于 is 和 == == 是 python 标准操作符中的比较操作符，用来比较判断两个对象的 value(值) 是否相等 。 # 例1.1 a = '2332424' b = '2332424' print(a == b) 输出： True [Finished in 0.1s] is 也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同。 # 例1.2 a = b = ['2343456'] c = ['2343456'] print(a == b, id(a), id(b)) print(a == c, id(a), id(c)) print(a is b, id(a), id(b)) print(a is c, id(a), id(c)) 输出： True 10715336 10715336 True 10715336 10717064 True 10715336 10715336 False 10715336 10717064 [Finished in 0.1s] 不同类型下， == 的结果都为True，但是 is 的结果则不一定 # 例1.3 # a 和 b 都为数值时 a = 1 b = 1 print(id(a)) print(id(b)) print(a == b) print(a is b) 1715077616 1715077616 True True [Finished in 0.1s] # a 和 b 都为字符串时 a = 'abcdefg' b = 'abcdefg' print(id(a)) print(id(b)) print(a == b) print(a is b) 11847696 11847696 True True [Finished in 0.1s] # a 和 b 都为列表时 a = ['12345678'] b = ['12345678'] print(id(a)) print(id(b)) print(a == b) print(a is b) 16941256 16942984 True False [Finished in 0.1s] # a 和 b 都是字典时 a = {'a':1,'b':2} b = {'a':1,'b':2} print(id(a)) print(id(b)) print(a == b) print(a is b) 10421192 10421256 True False [Finished in 0.1s] # a 和 b 都是元组时 a = (1,2,3) b = (1,2,3) print(id(a)) print(id(b)) print(a == b) print(a is b) 11960608 11960680 True False [Finished in 0.1s] # a 和 b 都为集合时 a = set([1,2,3]) b = set([1,2,3]) print(id(a)) print(id(b)) print(a == b) print(a is b) 16850504 16919464 True False [Finished in 0.1s] 只有数值型和字符串型的情况下，a is b才为True，当a和b是tuple，list，dict或set型时，a is b为False。 关于深浅拷贝 首先我们来看几个栗子： # 例2.1：赋值 a = [1,2,3] b = a a.append([4,5,6]) print(a) print(b) print(a is b) print(a == b) 输出： [1, 2, 3, [4, 5, 6]] [1, 2, 3, [4, 5, 6]] [Finished in 0.1s] True True 在例2.1中a的末尾新增了[4,5,6]之后，b的值也发生了变化，这是因为a把值赋值给b只是将创建的b对象指向了a对象指向的内存，这时的a和b指向的都是同一块内存空间(id)，所以修改a后b的值也一起改变。 # 例2.2：赋值 a = [1,2,3] b = a a = [4,5,6] print(a) print(b) print(id(a)) print(id(b)) 输出： [4, 5, 6] [1, 2, 3] 10848136 10846408 [Finished in 0.1s] 在例2.2中先将a赋值给b，又将[4,5,6]赋值给a，这时已经给a创建了新的内存空间，所以打印a，b时a和b的值并不相同。 下面来看下深浅拷贝的不同之处： 首先字符串 、元组以及数值的深浅拷贝是没有差别的，如下例子所示： # 例3.1 # 字符串 import copy a = '1345' b = copy.copy(a) c = copy.deepcopy(a) print(id(a), id(b), id(c)) 输出： 17025040 17025040 17025040 [Finished in 0.1s] # 数值 import copy a = 1345 b = copy.copy(a) c = copy.deepcopy(a) print(id(a), id(b), id(c)) 输出： 9326480 9326480 9326480 [Finished in 0.1s] # 元组 import copy a = (1,2,3) b = copy.copy(a) c = copy.deepcopy(a) print(id(a), id(b), id(c)) 输出： 10715424 10715424 10715424 [Finished in 0.2s] 而对于字典、列表 进行浅拷贝和深拷贝时，其id是有变化的 # 列表 import copy a = [1,2,3] b = copy.copy(a) c = copy.deepcopy(a) print(id(a), id(b), id(c)) 输出： 17540104 17040264 17419656 [Finished in 0.1s] #字典 import copy a = {"a": "1", "b": 2, "c": ["c", 3]} b = copy.copy(a) c = copy.deepcopy(a) print(a, b, c) print(id(a), id(b), id(c)) a['c'] = '666' print(a, b, c) print(id(a), id(b), id(c)) 输出： {'b': 2, 'a': '1', 'c': ['c', 3]} {'b': 2, 'a': '1', 'c': ['c', 3]} {'b': 2, 'a': '1', 'c': ['c', 3]} 6882248 17105992 16886792 {'b': 2, 'a': '1', 'c': '666'} {'b': 2, 'a': '1', 'c': ['c', 3]} {'b': 2, 'a': '1', 'c': ['c', 3]} 6882248 17105992 16886792 [Finished in 0.1s] 浅拷贝 ：不管多么复杂的数据结构，浅拷贝都只会copy一层，且当copy指向不可变类型时，copy不会执行copy操作。当copy指向可变类型时，copy会执行第一层拷贝，即拷贝浅层的指向。 深拷贝 ：其实深拷贝就是在内存中重新开辟一块空间，不管数据结构多么复杂，只要遇到可能发生改变的数据类型，就重新开辟一块内存空间把内容复制下来，直到最后一层，不再有复杂的数据类型，就保持其原引用。这样，不管数据结构多么的复杂，数据之间的修改都不会相互影响，这就是深拷贝，也同样可以将深拷贝理解为真正意义上的复制，是两个操作独立的个体。 有关深浅拷贝相关的图片说明可以参照下面几个链接的内容，以加深理解： http://www.cnblogs.com/wupeiqi/articles/5453708.htmlhttp://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html也可参照下面的几张图片： 原文发布时间为：2018-07-10本文来自云栖社区合作伙伴“小詹学Python”，了解相关信息可以关注“小詹学Python”。
2018-07-10
优秀的个人博客,低调大师

机器学习实战之线性回归

线性回归原理与推导 如图所示，这时一组二维的数据，我们先想想如何通过一条直线较好的拟合这些散点了？直白的说：尽量让拟合的直线穿过这些散点（这些点离拟合直线很近）。 目标函数 要使这些点离拟合直线很近，我们需要用数学公式来表示。首先，我们要求的直线公式为：Y = XTw。我们这里要求的就是这个w向量（类似于logistic回归）。误差最小，也就是预测值y和真实值的y的差值小，我们这里采用平方误差： 求解 我们所需要做的就是让这个平方误差最小即可，那就对w求导，最后w的计算公式为： 我们称这个方法为OLS，也就是“普通最小二乘法” 线性回归实践 数据情况 我们首先读入数据并用matplotlib库来显示这些数据。 def loadDataSet(filename): numFeat = len(open(filename).readline().
2018-07-02

资源下载

更多资源
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2026-01-27 大小: 1MB 下载: 5次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
热门标签
Docker Nacos3 Kubernetes Gemini3 SpringCloud Service Mesh DeepSeek HarmonyOS6 SpringBoot4 Rocky Redis OpenAi Jdk25

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册