一、项目整体管理
 
 
过程名
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、制定项目章程
 
 
 
 
1、项目工作说明书
 
2、商业论证
 
3、协议（合同，备忘录、意向及协议书）
 
4、组织过程资产
 
5、事业环境因素
 
 
1、专家判断
 
2、引导技术
 
 
 
 
1、项目章程
 
 
 
 
2、制定项目管理计划
 
 
 
 
1、  项目章程
 
2、  其他规划过程的输出
 
3、  组织过程资产
 
4、  事业环境因素
 
 
1、 专家判断
 
2、  引导技术
 
 
1、项目管理计划
 
 
 
 
3、指导与管理项目工作
 
 
1、项目管理计划
 
2、批准的变更请求
 
3、组织过程资产
 
4、事业环境因素
 
 
 
 
 
 
1、  专家判断
 
2、  项目管理信息系统（PMIS）
 
3、  会议
 
 
1、  可交付成果
 
2、  工作绩效数据
 
3、  变更请求
 
4、  项目管理计划更新
 
5、  项目文件更新
 
 
4、监控项目工作
 
 
1、  项目管理计划
 
2、  进度预测
 
3、  成本预测
 
4、  确认的变更
 
5、  工作绩效信息
 
6、  组织过程资产
 
7、  事业环境因素
 
 
 
 
1、  分析技术
 
2、  项目管理信息系统
 
3、  会议
 
4、  专家判断
 
 
 
 
1、  变更请求
 
2、  工作绩效报告
 
3、  项目管理计划更新
 
4、  项目文件更新
 
 
5、实施整体变更控制
 
 
1、  项目管理计划
 
2、  工作绩效报告
 
3、  变更请求
 
4、  组织过程资产
 
5、  事业环境因素
 
 
1、  会议
 
2、  变更控制工具
 
3、  专家判断
 
 
1、  批准的变更请求
 
2、  变更日志
 
3、  项目管理计划更新
 
4、  项目文件更新
 
 
结束项目或阶段
 
 
1、  项目管理计划
 
2、  验收的可交付成果
 
3、  组织过程资产
 
 
1、  分析技术
 
2、  会议
 
3、  专家判断
 
 
1、  最终产品、服务或成果
 
2、  组织过程资产更新
 
 
 
二、项目范围管理
 
  
过程名
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、编制范围管理计划（规划范围管理）
 
 
1、  项目管理计划
 
2、  项目章程
 
3、  组织过程资产
 
4、  事业环境因素
 
 
1、  会议
 
2、  专家判断
 
 
1、范围管理计划
 
2、需求管理计划
 
 
2、收集需求
 
 
1、  范围管理计划
 
2、  需求管理计划
 
3、  干系人管理计划
 
4、  项目章程
 
5、  干系人登记册
 
 
1、  访谈
 
2、  焦点小组
 
3、  引导式研讨会
 
4、  群体创新技术
 
5、  群体决策技术
 
6、  问卷调查
 
7、  观察
 
8、  原型法
 
9、  标杆对照
 
10、系统交付图
 
11、文件分析
 
 
1、需求文件
 
2、需求跟踪矩阵
 
 
3、定义范围
 
 
1、  范围管理计划
 
2、  项目章程
 
3、  需求文件
 
4、  组织过程资产
 
 
1、  产品分析
 
2、  专家判断
 
3、  备选方案生成
 
4、  引导式研讨会
 
 
1、  项目范围说明书
 
2、  项目文件更新
 
 
4、创建工作分解结构（WBS）
 
 
1、  范围管理计划
 
2、  项目范围说明书
 
3、  需求文件
 
4、  事业环境因素
 
5、  组织过程资产
 
 
1、  分解
 
2、  专家判断
 
 
1、  范围基准
 
2、  项目文件更新
 
 
5、确认范围
 
 
1、  项目管理计划
 
2、  需求文件
 
3、  需求跟踪矩阵
 
4、  核实的可交付成果
 
5、  工作绩效数据
 
 
1、  检查
 
2、  群体决策技术
 
 
1、  验收的可交付成果
 
2、  变更请求
 
3、  工作绩效信息
 
4、  项目文件更新
 
 
6、范围控制
 
 
1、  项目管理计划
 
2、  需求文件
 
3、  需求跟踪矩阵
 
4、  工作绩效数据
 
5、  组织过程资产
 
 
1、偏差分析
 
 
1、工作绩效信息
 
2、变更请求
 
3、项目文件更新
 
4、项目管理计划更新
 
5、组织过程资产更新
 
 
 
 
 
 
 
三、项目时间管理
 
 
 
 
过程名
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、规划进度管理
 
 
1、 项目管理计划
 
2、 项目章程
 
3、 组织过程资产
 
4、 事业环境因素
 
 
1、 专家判断
 
2、 分析技术
 
3、 会议
 
 
1、 项目进度管理计划
 
 
 
 
2、定义活动
 
 
1、 进度管理计划
 
2、 范围基准
 
3、 组织过程资产
 
4、 事业环境因素
 
 
1、 分解
 
2、 滚动式规划
 
3、 专家判断
 
 
1、 活动清单
 
2、 活动属性
 
3、 里程碑清单
 
 
3、排列活动顺序
 
 
1、 进度管理计划
 
2、 活动清单
 
3、 活动属性
 
4、 里程碑清单
 
5、 事业环境因素
 
6、 组织过程资产
 
7、 项目范围说明书
 
 
1、 前导图法
 
2、 箭线图法
 
3、 确定信赖关系
 
4、 提前量与滞后量
 
 
1、 项目进度网络图
 
2、 项目文件更新
 
 
4、估算活动资源
 
 
1、 进度管理计划
 
2、 活动清单
 
3、 活动属性
 
4、 资源日历
 
5、 风险登记册
 
6、 活动成本估算
 
7、 事业环境因素
 
8、 组织过程资产
 
 
1、 专家判断
 
2、 备选方案分析
 
3、 发布的估算数据
 
4、 项目管理软件
 
5、 自下而上估算
 
 
1、 活动资源需求
 
2、 资源分解结构
 
3、 项目文件更新
 
 
5、估算活动持续时间
 
 
1、 进度管理计划
 
2、 活动清单
 
3、 活动属性
 
4、 活动资源需求
 
5、 资源日历
 
6、 项目范围说明书
 
7、 风险登记册
 
8、 资源分解结构
 
9、 事业环境因素
 
10、组织过程资产
 
 
1、 专家判断
 
2、 类比估算
 
3、 参数估算
 
4、 三点估算
 
5、 群体决策技术
 
6、 储备分析
 
 
1、 活动持续时间估算
 
2、 项目文件更新
 
 
6、制定进度计划
 
 
1、 进度管理计划
 
2、 活动清单
 
3、 活动属性
 
4、 项目进度网络图
 
5、 活动资源需求
 
6、 资源日历
 
7、 活动持续时间估算
 
8、 项目范围说明书
 
9、 风险登记册
 
10、项目人员分配
 
11、资源分解结构
 
12、事业环境因素
 
13、组织过程资产
 
 
1、 进度网络分析法
 
2、 关键路线法
 
3、 关键链法
 
4、 资源优化技术
 
5、 建模技术
 
6、 提前量和滞后量
 
7、 进度压缩
 
8、 进度计划编制工具
 
 
1、 进度基准
 
2、 项目进度计划
 
3、 进度数据
 
4、 项目日历
 
5、 项目管理计划更新
 
6、 项目文件更新
 
 
7、控制进度
 
 
1、 项目管理计划
 
2、 项目进度计划
 
3、 工作绩效数据
 
4、 项目日历
 
5、 进度数据
 
6、 组织过程资产
 
 
1、 绩效审查
 
2、 项目管理软件
 
3、 资源优化技术
 
4、 建模技术
 
5、 提前量和滞后量
 
6、 进度压缩
 
7、 进度计划编制工具
 
 
1、 工作绩效信息
 
2、 进度预测
 
3、 变更请求
 
4、 项目管理计划更新
 
5、 项目文件更新
 
6、 组织过程资产更新
 
 
 
 
 
 
 
四、项目成本管理
 
 
 
 
过程名
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、制定成本管理计划（规划成本）
 
 
1、 项目管理计划
 
2、 项目章程
 
3、 事业环境因素
 
4、 组织过程资产
 
 
1、 专家判断
 
2、 分析技术
 
3、 会议
 
 
1、成本管理计划
 
 
2、成本估算
 
 
 
 
1、 成本管理计划
 
2、 人力资源管理计划
 
3、 范围基准
 
4、 项目进度计划
 
5、 风险登记册
 
6、 组织过程资产
 
7、 事业环境因素
 
 
1、 专家判断
 
2、 类比估算
 
3、 参数估算
 
4、 自下而上估算
 
5、 三点估算
 
6、 储备分析
 
7、 质量成本
 
8、 项目管理软件
 
9、 卖方投标分析
 
10、群体决策技术
 
 
1、 活动成本估算
 
2、 估算依据
 
3、 项目文件更新
 
 
 
 
3、成本预算（制定预算）
 
 
1、 成本管理计划
 
2、 范围基准
 
3、 活动成本估算
 
4、 活动依据
 
5、 项目进度计划
 
6、 资源日历
 
7、 风险登记册
 
8、 协议
 
9、 组织过程资产
 
 
1、 成本汇总
 
2、 储备分析
 
3、 专家判断
 
4、 资金限制平衡
 
5、 参数模型
 
 
1、成本基准
 
2、项目资金需求
 
3、项目文件更新
 
 
4、成本控制
 
 
1、 项目管理计划
 
2、 项目资金需求
 
3、 工作绩效数据
 
4、 组织过程资产
 
 
1、 挣值管理
 
2、 预测
 
3、 完工尚需绩效指数
 
4、 绩效审查
 
5、 项目管理软件（PM软件）
 
6、 储备分析
 
 
1、 工作绩效信息
 
2、 成本预测
 
3、 变更请求
 
4、 项目文件更新
 
5、 组织过程资产更新
 
6、 项目管理计划更新
 
 
 
 
 
 
 
 
 
五、项目质量管理
 
 
过程名
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、规划质量管理
 
 
 
 
1、 项目管理计划
 
2、 干系人登记册
 
3、 风险登记册
 
4、 需求文件
 
5、 事业环境因素
 
6、 组织过程资产
 
 
1、 成本效益分析
 
2、 质量成本法
 
3、 七种基本质量工具
 
4、 标杆对照
 
5、 实验设计
 
6、 统计抽样
 
7、 其他质量管理工具
 
8、 会议
 
 
1、 质量管理计划
 
2、 过程改进计划
 
3、 质量测量指标
 
4、 质量核对单
 
5、 项目文件更新
 
 
2、实施质量保证
 
 
1、 质量管理计划
 
2、 过程改进计划
 
3、 质量测量指标
 
4、 质量控制测量结果
 
5、 项目文件
 
 
1、 质量审计
 
2、 过程分析
 
3、 质量管理与控制工具
 
 
1、 变更请求
 
2、 项目管理计划更新
 
3、 项目文件更新
 
4、 组织过程资产更新
 
 
3、质量控制（控制质量）
 
 
1、 项目管理计划
 
2、 质量测量指标
 
3、 质量核对单
 
4、 单工作绩效数据
 
5、 批准的变更请求
 
6、 可交付成果
 
7、 项目文件
 
8、 组织过程资产
 
 
1、 七种基本质量工具
 
2、 统计抽样
 
3、 检查
 
4、 审查已批准的变更请求
 
 
1、 质量控制测量结果
 
2、 确认的变更
 
3、 核实的可交付成果
 
4、 工作绩效信息
 
5、 变更请求
 
6、 项目文件更新
 
7、 项目管理计划更新
 
8、 组织过程资产更新
 
 
 
 
 
 
 
六、项目人力资源管理
 
 
 
 
过程名称
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、编写人力资源计划（规划人力资源管理）
 
 
1、 项目管理计划
 
2、 活动资源需求
 
3、 事业环境因素
 
4、 组织过程资产
 
 
1、 组织结构图和职位描述
 
2、 人际交住
 
3、 组织理论
 
4、 专家判断
 
5、 会议
 
 
1、人力资源管理计划
 
 
2、组建项目团队
 
 
1、 人力资源管理计划
 
2、 事业环境因素
 
3、 组织过程资产
 
 
1、 事先分派
 
2、 谈判
 
3、 招募
 
4、 虚拟团队
 
5、 多维决策分析
 
 
1、 项目人员分配表
 
2、 资源日历
 
3、 项目管理计划更新
 
 
3、建设项目团队
 
 
1、 人力资源计划
 
2、 项目人员分配表
 
3、 资源日历
 
 
1、 人际关系技能
 
2、 培训
 
3、 团队建设活动
 
4、 基本规则
 
5、 集中办公
 
6、 认可与奖励
 
7、 人事测评工具
 
 
1、 团队绩效评估
 
2、 事业环境因素更新
 
 
4、管理项目团队
 
 
1、 人力资源管理计划
 
2、 项目人员分配表
 
3、 团队绩效评估
 
4、 问题日志
 
5、 绩效报告
 
6、 组织过程资产
 
 
1、 观察和交谈
 
2、 项目绩效评估
 
3、 冲突管理
 
4、 人际关系技能
 
 
1、 变更请求
 
2、 项目管理计划更新
 
3、 项目文件更新
 
4、 事业环境因素更新
 
5、 组织过程资产更新
 
 
 
 
 
 
 
七、项目沟通管理
 
 
 
 
过程名称
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、制订沟通管理计划（规划沟通管理）
 
 
1、 项目管理计划
 
2、 干系人登记册
 
3、 事业环境因素
 
4、 组织过程资产
 
 
1、 分析沟通需求
 
2、 信息传递方法的选择
 
 
1、 项目沟通管理计划
 
2、 其他文档的更新
 
 
2、管理沟通
 
 
 
 
1、 项目沟通管理计划
 
2、 工作绩效报告
 
3、 组织过程资产
 
4、 事业环境因素
 
 
1、 沟通渠道的选择
 
2、 信息传递方式的选择
 
3、 信息管理系统
 
4、 绩效报告
 
 
1、 项目沟通
 
2、 项目管理计划更新
 
3、 其他项目计划更新
 
4、 组织过程资产更新
 
 
3、控制沟通
 
 
1、 项目管理计划
 
2、 项目沟通
 
3、 问题日志
 
4、 工作绩效数据
 
5、 组织过程资产
 
 
1、 信息管理系统
 
2、 专家判断
 
3、 会议
 
 
 
 
1、 工作绩效信息
 
2、 变更请求
 
3、 项目管理计划更新
 
4、 其他项目计划更新
 
5、 组织过程资产更新
 
 
 
 
 
 
 
八、项目采购管理
 
 
 
 
过程名称
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、编制采购计划（规划采购）
 
 
1、 项目管理计划
 
2、 需求文档
 
3、 风险登记册
 
4、 活动资源要求
 
5、 项目进度
 
6、 活动成本估算
 
7、 干系人登记册
 
8、 事业环境因素
 
9、 组织过程资产
 
 
1、 自制外购分析
 
2、 专家判断
 
3、 市场调研
 
4、 会议
 
 
1、 采购管理计划
 
2、 采购工作说明书
 
3、 采购文件
 
4、 供方选择标准
 
5、 自制外购决策
 
6、 变更申请
 
7、 项目文件更新
 
 
2、实施采购
 
 
1、 采购管理计划
 
2、 采购文件
 
3、 供方选择标准
 
4、 卖方建议书
 
5、 项目文件
 
6、 自制外购决策
 
7、 采购工作说明书
 
8、 组织过程资产
 
 
1、 投标人会议
 
2、 建议书评价技术
 
3、 独立估算
 
4、 专家判断
 
5、 刊登广告
 
6、 分析技术
 
7、 采购谈判
 
 
1、 选择的卖方
 
2、 合同
 
3、 资源日历
 
4、 变更请求
 
5、 项目管理计划更新
 
6、 项目文件更新
 
 
3、控制采购
 
 
1、 项目管理计划
 
2、 采购文件
 
3、 合同
 
4、 批准的变更请求
 
5、 工作绩效报告
 
6、 工作绩效数据
 
 
1、 合同变更控制系统
 
2、 检查与审计
 
3、 采购绩效审查
 
4、 报告绩效
 
5、 支付系统
 
6、 索赔管理
 
7、 记录管理系统
 
 
1、 工作绩效信息
 
2、 变更请求
 
3、 项目管理计划更新
 
4、 项目文件更新
 
5、 组织过程资产更新
 
 
4、结束采购
 
 
1、 合同
 
2、 合同收尾程序
 
3、 项目管理计划
 
4、 采购文件
 
 
1、 采购审计
 
2、 采购谈判
 
3、 记录管理系统
 
 
1、 合同收尾
 
2、 组织过程资产更新
 
 
 
 
 
九、项目风险管理
 
 
 
 
过程名称
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、规划风险管理
 
 
1、 项目管理计划
 
2、 项目章程
 
3、 干系人登记册
 
4、 事业环境因素
 
5、 组织过程资产
 
 
1、 分析技术
 
2、 专家判断
 
3、 会议
 
 
1、风险管理计划
 
 
2、识别风险
 
 
1、 风险管理计划
 
2、 成本管理计划
 
3、 进度管理计划
 
4、 质量管理计划
 
5、 人力资源管理计划
 
6、 范围基准
 
7、 活动成本估算
 
8、 活动持续时间估算
 
9、 干系人登记册
 
10、项目文件
 
11、采购文件
 
12、事业环境因素
 
13、组织过程资产
 
 
1、 文档审查
 
2、 信息收集技术
 
3、 核对单分析
 
4、 假设分析
 
5、 图解分析
 
6、 SWOT分析
 
7、 专家判断
 
 
 
 
1、 风险登记册
 
 
3、实施定性风险分析
 
 
1、 风险管理计划
 
2、 范围基准
 
3、 风险登记册
 
4、 事业环境因素
 
5、 组织过程资产
 
 
1、 风险概率和影响评价
 
2、 概率和影响矩阵
 
3、 风险数据质量评估
 
4、 风险种类
 
5、 风险紧急度评估
 
6、 专家判断
 
 
1、 风险登记册更新
 
2、 假设条件日志更新
 
 
4、实施定量风险分析
 
 
1、 风险管理计划
 
2、 成本管理计划
 
3、 进度管理计划
 
4、 风险登记册
 
5、 事业环境因素
 
6、 组织过程资产
 
 
1、 数据收集和表示技术
 
2、 定量分析和建模技术
 
3、 专家判断
 
 
1、项目的概率分布
 
2、实现成本和实现目
 
标的概率
 
3、量化风险优先级清单
 
4、定量风险结果的趋势
 
 
5、规划风险应对
 
 
1、 风险管理计划
 
2、 风险登记册
 
 
1、 消极风险或威胁的应对策略
 
2、 积极风险或机会的应对策略
 
3、 应急响应策略
 
4、 专家判断
 
 
1、项目管理计划更新
 
2、项目文件更新
 
 
6、控制风险
 
 
1、 项目管理计划
 
2、 风险登记册
 
3、 工作绩效数据
 
4、 工作绩效报告
 
 
1、 风险再评估
 
2、 风险审计
 
3、 偏差和趋势分析
 
4、 技术绩效测量
 
5、 储备分析。6、会议
 
 
1、 工作绩效信息
 
2、 变更请求
 
3、 项目管理计划更新
 
4、 项目文件更新
 
5、 组织过程资产更新
 
十、项目干系人管理
 
 
过程名称
 
 
输入
 
 
工具和技术
 
 
输出
 
 
1、识别干系人
 
 
 
 
1、 项目章程
 
2、 采购文件
 
3、 事业环境因素
 
4、 组织过程资产
 
 
1、 会议
 
2、 专家判断
 
3、 干系人分析
 
 
1、干系人登记册
 
 
2、编制干系人管理计划（规划干系人）
 
 
1、 项目管理计划
 
2、 干系人登记册
 
3、 事业环境因素
 
4、 组织过程资产
 
 
1、 会议
 
2、 专家判断
 
3、 分析技术
 
 
1、 干系人管理计划
 
2、 项目文件更新
 
 
3、管理干系人参与（管理干系人）
 
 
1、 干系人管理计划
 
2、 沟通管理计划
 
3、 变更日志
 
4、 组织过程资产
 
 
1、 沟通方法
 
2、 人际关系技能
 
3、 管理技能
 
 
1、 问题日志
 
2、 请求变更
 
3、 项目管理计划更新
 
4、 项目文件更新
 
5、 组织过程资产更新
 
 
4、控制干系人参与
 
 
1、 项目管理计划
 
2、 问题日志
 
3、 工作绩效数据
 
4、 项目文件
 
 
1、 信息管理系统
 
2、 专家判断
 
3、 会议
 
 
1、 工作绩效信息
 
2、 纠正措施
 
3、 变更请求
 
4、 项目管理计划更新
 
5、 组织过程资产更新
 
6、 项目文件更新
 
 

http://blog.csdn.net/pipisorry/article/details/39088003 
 
基本输入输出和文件输入输出
 
文件名和文件对象
 
本节介绍所举的例子都是传递的文件名，也可以传递已经打开的文件对象.
 
例如对于load和save函数来说，如果使用文件对象的话，可以将多个数组储存到一个npy文件中：
 
>>> a = np.arange(8)
>>> b = np.add.accumulate(a)
>>> c = a + b
>>> f = file("result.npy", "wb")
>>> np.save(f, a) # 顺序将a,b,c保存进文件对象f
>>> np.save(f, b)
>>> np.save(f, c)
>>> f.close()
>>> f = file("result.npy", "rb")
>>> np.load(f) # 顺序从文件对象f中读取内容
array([0, 1, 2, 3, 4, 5, 6, 7])
>>> np.load(f)
array([ 0,  1,  3,  6, 10, 15, 21, 28])
>>> np.load(f)
array([ 0,  2,  5,  9, 14, 20, 27, 35])
 
文件对象写入时的注意事项
 
numpy.savetxt(fname, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\n’, header=’‘, footer=’‘, comments=’#‘)
 Save an array to a text file.
 
np.savetxt(输出文件名,矩阵名)
 
输出文件名应为二进制写入：
 
doc_word_mat_file = open('./filename.txt', 'wb')
 
否则出错：
 
    savetxt(doc_word_mat_file, doc_word_mat) ...     fh.write(asbytes(format % tuple(row) + newline))
 TypeError: must be str, not bytes
 
所以推荐不要使用文件对象写入，用文件名写入
 
皮皮blog
 
 
 
numpy数组输出选项设置
 
在屏幕上输出数组：print(mat1)
 
Text formatting options
 
set_printoptions([precision, threshold, ...])
Set printing options.
get_printoptions()
Return the current print options.
set_string_function(f[, repr])
Set a Python function to be used when pretty printing arrays.
numpy数组打印效果设置
 
多维数组强制打印全部输出
 
如果一个数组用来打印太大了，NumPy自动省略中间部分而只打印角落。禁用NumPy的这种行为并强制打印整个数组，你可以设置printoptions参数来更改打印选项。
 
np.set_printoptions(threshold=np.NaN)
 
 
 
threshold : int, optional   Total number of array elements which trigger summarizationrather than full repr (default 1000).
 
使用set_printoptions设置输出精度
 
np.set_printoptions(precision=3)
print(x)
# [ 0.078  0.48   0.413  0.83   0.776  0.102  0.513  0.462  0.335  0.712]
 
但是怎么没办法输出原本数据的最精确精度，如有的数据是10位小数，有的是8位，输出不好控制precision为多少好。精度过高就会出错。
 
这时可以使用array.astype(str)转换成字符串输出。如
 
[['40.731354990929475' '-74.00363118575608']
   ['40.731508' '-74.0031859561163']]
 
suppress消除小的数字使用科学记数法
 
y=np.array([1.5e-10,1.5,1500])
print(y)
# [  1.500e-10   1.500e+00   1.500e+03]
np.set_printoptions(suppress=True)
print(y)
# [    0.      1.5  1500. ]
 
在本地应用打印选项 中， 你可以使用 contextmanager ...
 
formatter参数允许你指定一个格式为每个类型的函数(注意结尾补0了)
 
np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
print(x)
 
[ 0.078 0.480 0.413 0.830 0.776 0.102 0.513 0.462 0.335 0.712]
 
奇怪的方式
 
print(np.char.mod('%4.2f', eigen_value))
 
[Pretty-printing of numpy.array][numpy.array的效果]
 
numpy输出精度局部控制
 
@contextmanager
def np_printoptions(*args, **kwargs):
    '''
    numpy本地应用打印选项,如：
    with np_printoptions(precision=3, suppress=True):
        print(x1)
    '''
    original = np.get_printoptions()
    np.set_printoptions(*args, **kwargs)
    yield
    np.set_printoptions(**original)
 
皮皮blog
 
 
 
 
 
numpy文件存取
 
NumPy提供了多种文件操作函数方便我们存取数组内容。
 
文件存取的格式：二进制和文本。二进制格式的文件又分为NumPy专用的格式化二进制类型和无格式类型。
 
Numpy binary files (NPY, NPZ)
 
load(file[, mmap_mode, allow_pickle, ...])
Load arrays or pickled objects from .npy, .npz or pickled files.
save(file, arr[, allow_pickle, fix_imports])
Save an array to a binary file in NumPy .npy format.
savez(file, *args, **kwds)
Save several arrays into a single file in uncompressed .npz format.
savez_compressed(file, *args, **kwds)
Save several arrays into a single file in compressed .npz format.
The format of these binary file types is documented inhttp://docs.scipy.org/doc/numpy/neps/npy-format.html
 
numpy.load和numpy.save函数（推荐在不需要查看保存数据的情况下使用）
 
以NumPy专用的二进制类型保存数据，这两个函数会自动处理元素类型和shape等信息，使用它们读写数组就方便多了，但是numpy.save输出的文件很难和其它语言编写的程序读入：
 
 
 
>>> np.save("a.npy", a)
>>> c = np.load( "a.npy" )
>>> c
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
 
 
Note:
 
1. 文件要保存为.npy文件类型，否则会出错
 
2. 保存为numpy专用二进制格式后，就不能用notepad++打开（乱码）看了，这是相对tofile内建函数不好的一点
 
numpy.savez函数
 
如果你想将多个数组保存到一个文件中的话，可以使用numpy.savez函数。savez函数的第一个参数是文件名，其后的参数都是需要保存的数组，也可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为arr_0, arr_1, ...。savez函数输出的是一个压缩文件(扩展名为npz)，其中每个文件都是一个save函数保存的npy文件，文件名对应于数组名。load函数自动识别npz文件，并且返回一个类似于字典的对象，可以通过数组名作为关键字获取数组的内容：
 
 
 
>>> a = np.array([[1,2,3],[4,5,6]])
>>> b = np.arange(0, 1.0, 0.1)
>>> c = np.sin(b)
>>> np.savez("result.npz", a, b, sin_array = c)
>>> r = np.load("result.npz")
>>> r["arr_0"] # 数组a
array([[1, 2, 3],
       [4, 5, 6]])
>>> r["arr_1"] # 数组b
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])
>>> r["sin_array"] # 数组c
array([ 0.        ,  0.09983342,  0.19866933,  0.29552021,  0.38941834,
        0.47942554,  0.56464247,  0.64421769,  0.71735609,  0.78332691])
 
 
如果你用解压软件打开result.npz文件的话，会发现其中有三个文件：arr_0.npy， arr_1.npy， sin_array.npy，其中分别保存着数组a, b, c的内容。
 
皮皮blog
 
 
 
 
 
 
 
 
 
numpy读取文本文件Text files
 
loadtxt(fname[, dtype, comments, delimiter, ...])
Load data from a text file.
savetxt(fname, X[, fmt, delimiter, newline, ...])
Save an array to a text file.
genfromtxt(fname[, dtype, comments, ...])
Load data from a text file, with missing values handled as specified.
fromregex(file, regexp, dtype)
Construct an array from a text file, using regular expression parsing.
fromstring(string[, dtype, count, sep])
A new 1-D array initialized from raw binary or text data in a string.
ndarray.tofile(fid[, sep, format])
Write array to a file as text or binary (default).
ndarray.tolist()
Return the array as a (possibly nested) list.
numpy.savetxt和numpy.loadtxt（推荐需要查看保存数据时使用）
 
使用numpy.savetxt和numpy.loadtxt可以读写1维和2维的数组：
 
np.loadtxt(FILENAME, dtype=int, delimiter=' ')
 
numpy.loadtxt(fname, dtype=<type 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)
 
使用结构数组读入文件
 persontype = np.dtype({'names':['name', 'age', 'weight', 'height'],
                        'formats':['S32','i', 'f', 'f']})
 data = np.loadtxt(f, delimiter=",", dtype=persontype)
 
np.savetxt("a.txt",a, fmt="%d",delimiter=",")
 
>>> a = np.arange(0,12,0.5).reshape(4,-1)
>>> np.savetxt("a.txt", a) # 缺省按照'%.18e'格式保存数据，以空格分隔
>>> np.loadtxt("a.txt")

>>> np.savetxt("a.txt", a, fmt="%d", delimiter=",") #改为保存为整数，以逗号分隔
>>> np.loadtxt("a.txt",delimiter=",") # 读入的时候也需要指定逗号分隔
array([[  0.,   0.,   1.,   1.,   2.,   2.],
       [  3.,   3.,   4.,   4.,   5.,   5.],
       [  6.,   6.,   7.,   7.,   8.,   8.],
       [  9.,   9.,  10.,  10.,  11.,  11.]])
 
Note:savetxt缺省按照'%.18e'格式保存数据， 可以修改保存格式为‘%.8f'(小数点后保留8位的浮点数)， ’%d'(整数)等等
 
np.savetxt保存list或者ndarray
 
np.savetxt('nationwide_add.csv', add_list, fmt='%s', encoding='utf-8', delimiter='\t')
 
可以保存中文，但是其中的None也变成了字符串“None”而不是真的空。所以建议使用pd.DataFrame(add_list).to_csv('nationwide_add.csv', sep='\t', header=False, index=False)。
 
np.savetxt保存中文字符串数组
 
实际上是不可以的，因为默认是wb格式保存，这样就是保存为bytes，py3中的str又是unicode，这样就算保存下来了，也并看不了保存下来的中文是什么。
 
如：
 
s = np.array([['工', '1'], ['q', '1']])
print(s)
s = np.char.encode(s,'utf-8')
np.savetxt('/tmp/1.txt', s, fmt='%s')
 
文件中只会这样显示：b'\xe5\xb7\xa5' b'1'
 b'q' b'1'
 
所以有中文的话，而且实在想看文件中的内容，只有使用普通保存方法保存了：with open() as f: f.write(lines)什么的。
 
[Write numpy unicode array to a text file]
 
loadtxt出错
 
1 numpy.loadtxt读入的字符串总是bytes格式，总是在前面加了一个b
 
原因：np.loadtxt and np.genfromtxt operate in byte mode, which is the default string type in Python 2. But Python 3 uses unicode, and marks bytestrings with this b.  numpy.loadtxt中也声明了：Note that generators should return byte strings for Python 3k.
 
解决：使用numpy.loadtxt从文件读取字符串，最好使用这种方式np.loadtxt(filename, dtype=bytes).astype(str)
 
['b' character added when using numpy loadtxt]
 
[numpy.loadtxt]
 
总结：
 
载入txt文件：numpy.loadtxt()/numpy.savetxt()
 
智能导入文本/csv文件：numpy.genfromtxt()/numpy.recfromcsv()
 
高速，有效率但numpy特有的二进制格式：numpy.save()/numpy.load()
 
2 ValueError: Wrong number of columns at line 78446
 
原因是数据问题，可能前面的数据都是3列而78446却是2或4列等等。
 
查看数据nl data_test6.txt | grep -C 3 78446
 
numpy.genfromtxt
 
import numpy as np
 np.genfromtxt('filename', dtype= None)
 # array([(1, 2.0, 'buckle_my_shoe'), (3, 4.0, 'margery_door')],
 #  dtype=[('f0', '<i4'), ('f1', '<f8'), ('f2', '|S14')])
 
皮皮blog
 
 
 
 
 
Raw binary files
 
fromfile(file[, dtype, count, sep])
Construct an array from data in a text or binary file.
ndarray.tofile(fid[, sep, format])
Write array to a file as text or binary (default).
 
 
tofile和fromfile数组内建函数（not recommend）
 
 
 
使用数组的方法函数tofile可以方便地将数组中数据以二进制的格式写进文件。tofile输出的数据没有格式，因此用numpy.fromfile读回来的时候需要自己格式化数据：
 
 
 
>>> a = np.arange(0,12)
>>> a.shape = 3,4
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> a.tofile("a.bin")
>>> b = np.fromfile("a.bin", dtype=np.float) # 按照float类型读入数据
>>> b # 读入的数据是错误的
array([  2.12199579e-314,   6.36598737e-314,   1.06099790e-313,
         1.48539705e-313,   1.90979621e-313,   2.33419537e-313])
>>> a.dtype # 查看a的dtype
dtype('int32')
>>> b = np.fromfile("a.bin", dtype=np.int32) # 按照int32类型读入数据
>>> b # 数据是一维的
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
>>> b.shape = 3, 4 # 按照a的shape修改b的shape
>>> b
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
 
 
Note:
 
1. 读入的时候设置正确的dtype和shape才能保证数据一致。并且tofile函数不管数组的排列顺序是C语言格式的还是Fortran语言格式的，统一使用C语言格式输出。
 
2. sep关键字参数:此外如果fromfile和tofile函数调用时指定了sep关键字参数的话，数组将以文本格式输入输出。{这样就可以通过notepad++打开查看, 不过数据是一行显示，不便于查看}
 
user_item_mat.tofile(user_item_mat_filename, sep=' ')
 
皮皮blog
 
 
 
 
 
 
 
 
 
String formatting
 
array2string(a[, max_line_width, precision, ...])
Return a string representation of an array.
array_repr(arr[, max_line_width, precision, ...])
Return the string representation of an array.
array_str(a[, max_line_width, precision, ...])
Return a string representation of the data in an array.
Memory mapping files
 
memmap
Create a memory-map to an array stored in a binary file on disk.
 
 
Base-n representations
 
 
binary_repr(num[, width])
Return the binary representation of the input number as a string.
base_repr(number[, base, padding])
Return a string representation of a number in the given base system.
 
Data sources
 
DataSource([destpath])
A generic data source file (file, http, ftp, ...).
 
 
from:http://blog.csdn.net/pipisorry/article/details/39088003
 
ref: [numpy Input and output]
 
 

 
 
 
 
 
 
 
一.什么是IO
 
 

 
      Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。  
 
       Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。
 
　　流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。 
       Java IO模型  :
       Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。
 
 
 
 
 
 
二.数据流的基本概念
 
 

        数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据，这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说，看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。不管写入时是将数据分多次写入，还是作为一个整体一次写入，读取时的效果都是完全一样的。 
 
      “流是磁盘或其它外围设备中存储的数据的源点或终点。”
 
    在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？
 
     在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:
 
         标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。
 
    流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。
 
 
 
总结的基本概念如下：
 
 
1) 数据流：
 
    一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。
 
  
 
2) 输入流（Input  Stream）：
 
      程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道
 

      
 
 
 3) 输出流：
 

     程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道。
 
         
 
采用数据流的目的就是使得输出输入独立于设备。
 
Input  Stream不关心数据源来自何种设备（键盘，文件，网络）
 Output  Stream不关心数据的目的是何种设备（键盘，文件，网络）
 
4) 数据流分类：
 

 流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种：
 

  1)  字节流：数据流中最小的数据单元是字节
 

  2)  字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。
 
 
 
 
 
 
 
三. 标准I/O
 
 

 
      Java程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。
 
1. 命令行参数
 
public class TestArgs {
	public static void main(String[] args) {
		for (int i = 0; i < args.length; i++) {
			System.out.println("args[" + i + "] is <" + args[i] + ">");
		}
	}
}
 
运行命令：java Java C VB
 运行结果：
 args[0] is <Java>
 args[1] is <C>
 args[2] is <VB>
 
 
 
2. 标准输入，输出数据流
 
java系统自带的标准数据流：java.lang.System:
 
java.lang.System 
public final class System  extends Object{ 
   static  PrintStream  err;//标准错误流（输出）
   static  InputStream  in;//标准输入(键盘输入流)
   static  PrintStream  out;//标准输出流(显示器输出流)
}
 
 
 
注意：
 （1）System类不能创建对象，只能直接使用它的三个静态成员。
 （2）每当main方法被执行时,就自动生成上述三个对象。
 
 
1) 标准输出流 System.out
 
   System.out向标准输出设备输出数据，其数据类型为PrintStream。方法：
 

       Void print(
 参数)
 

       Void println(
 参数)
 
2)标准输入流 System.in
 
    System.in读取标准输入设备数据（从标准输入获取数据，一般是键盘），其数 据类型为InputStream。方法：
 

         int read()
   //返回ASCII码。若,返回值=-1，说明没有读取到任何字节读取工作结束。
 

          int read(byte[] b)//
 读入多个字节到缓冲区b中返回值是读入的字节数
 

 例如：
 
 
 
import java.io.*;
public class StandardInputOutput {
	public static void main(String args[]) {
		int b;
		try {
			System.out.println("please Input:");
			while ((b = System.in.read()) != -1) {
				System.out.print((char) b);
			}
		} catch (IOException e) {
			System.out.println(e.toString());
		}
	}
}
 
 

 等待键盘输入，键盘输入什么，就打印出什么：
 

 
 
 
 
3)标准错误流
 
   System.err输出标准错误，其数据类型为PrintStream。可查阅API获得详细说明。
 
    标准输出通过System.out调用println方法输出参数并换行，而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法，包括输出参数类型为boolean、char、int、long、float和double。同时，也重载实现 了输出参数类型为char[]、String和Object的方法。其中，print（Object）和println（Object）方法在运行时将调 用参数Object的toString方法。
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class StandardInputOutput {
	public static void main(String args[]) {
		String s;
		// 创建缓冲区阅读器从键盘逐行读入数据
		InputStreamReader ir = new InputStreamReader(System.in);
		BufferedReader in = new BufferedReader(ir);
		System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"
				+ "\nWindows系统: ctrl-z 退出");
		try {
			// 读一行数据，并标准输出至显示器
			s = in.readLine();
			// readLine()方法运行时若发生I/O错误，将抛出IOException异常
			while (s != null) {
				System.out.println("Read: " + s);
				s = in.readLine();
			}
			// 关闭缓冲阅读器
			in.close();
		} catch (IOException e) { // Catch any IO exceptions.
			e.printStackTrace();
		}
	}
}
 
 
 
 
 
四.java.IO层次体系结构
 
 

 
     在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了
 
      Java I/O主要包括如下几个层次，包含三个部分：
 
   1.流式部分――IO的主体部分；
 
   2.非流式部分――主要包含一些辅助流式部分的类，如：File类、RandomAccessFile类和FileDescriptor等类；
 
   3.其他类--文件读取部分的与安全相关的类，如：SerializablePermission类，以及与本地操作系统相关的文件系统的类，如：FileSystem类和Win32FileSystem类和WinNTFileSystem类。
 
   主要的类如下：
 
     1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。
 
     2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。
 
     3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。
 
     Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。
 
     4. Reader（文件格式操作）：抽象类，基于字符的输入操作。
 
     5. Writer（文件格式操作）：抽象类，基于字符的输出操作。
 
     6. RandomAccessFile（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。
 
 
 
     Java中IO流的体系结构如图：
 
     
 
 
 

   
 
 
 
 
  
 
   
 
 
   
五. 非流式文件类--File类
 
   

  
 
 
 
 

  在Java语言的java.io包中，由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。
 
 
 

   
 
 
 

  作用：File类主要用于命名文件、查询文件属性和处理文件目录。 
  
public    class   File   extends Object 
    implements Serializable,Comparable
{}
 
 
 
 
 
 File类共提供了三个不同的构造函数，以不同的参数形式灵活地接收文件和目录名信息。构造函数：
 

 1）File (String   pathname)   
 

      例:File  f1=new File("FileTest1.txt"); //创建文件对象f1，f1所指的文件是在当前目录下创建的FileTest1.txt
 

 2）File (String  parent  ,  String child)
 

      例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意：D:\\dir1目录事先必须存在，否则异常
 

 3）File (File    parent  , String child)
 
      例:File  f4=new File("\\dir3");
 
           File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建
 

         一个对应于某磁盘文件或目录的File对象一经创建， 就可以通过调用它的方法来获得文件或目录的属性。    
 

        1）public boolean exists( ) 判断文件或目录是否存在
 
        2）public boolean isFile( ) 判断是文件还是目录 
 
        3）public boolean isDirectory( ) 判断是文件还是目录
 
        4）public String getName( ) 返回文件名或目录名
 
        5）public String getPath( ) 返回文件或目录的路径。
 
        6）public long length( ) 获取文件的长度 
 
        7）public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。 
 

        File类中还定义了一些对文件或目录进行管理、操作的方法，常用的方法有：
 
        1） public boolean renameTo( File newFile );    重命名文件
 
        2） public void delete( );   删除文件
 
        3）  public boolean mkdir( ); 创建目录
 
  
 

 例子：
 
 
 
 
 
 
import java.io.File;
import java.io.IOException;
public class TestFile {
	public static void main(String args[]) throws IOException {
		File dir = new File("\\root");
		File f1 = new File(dir, "fileOne.txt");
		File f2 = new File(dir, "fileTwo.java");
		// 文件对象创建后，指定的文件或目录不一定物理上存在
		if (!dir.exists())
			dir.mkdir();
		if (!f1.exists())
			f1.createNewFile();
		if (!f2.exists())
			f2.createNewFile();
		System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath());
		System.out.println("f1 Canread=" + f1.canRead());
		System.out.println("f1's len= " + f1.length());
		String[] FL;
		int count = 0;
		FL = dir.list();
		for (int i = 0; i < FL.length; i++) {
			count++;
			System.out.println(FL[i] + "is in \\root");
		}
		System.out.println("there are" + count + "file in //root");
	}

}
 
 
 
 
 
说明：File类的方法:
 (1) exists()测试磁盘中指定的文件或目录是否存在
 (2) mkdir()创建文件对象指定的目录（单层目录）
 (3) createNewFile()创建文件对象指定的文件
 
 
(4) list()返回目录中所有文件名字符串
 
 
 
  
 
 
  
六. Java.IO流类库
 
  

 
 
 
1. io流的四个基本类
 
      java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：
 
基本数据流的I/O
 
 
 
 
输入/输出
 
 
字节流
 
 
字符流
 
 
输入流
 
 
Inputstream
 
 
Reader
 
 
输出流
 
 
OutputStream
 
 
Writer
 
 

  
 

 IO框架：
 
 
 
    
 
 
 
 Java中其他多种多样变化的流均是由它们派生出来的:
 
 
 
 
 
      JDK1.4版本开始引入了新I/O类库，它位于java.nio包中，新I/O类库利用通道和缓冲区等来提高I/O操作的效率。
 
      在java.io包中， java.io.InputStream 表示字节输入流， java.io.OutputStream表示字节输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类之后才能实现一定的功能。
 
 
 
2. io流的具体分类
 
一、按I/O类型来总体分类：
 
     1. Memory 1）从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream
                    2）从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream
      2.Pipe管道  实现管道的输入和输出（进程间通信）: PipedReader、PipedWriter、PipedInputStream、PipedOutputStream
      3.File 文件流。对文件进行读、写操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream
      4. ObjectSerialization 对象输入、输出 ：ObjectInputStream、ObjectOutputStream
      5.DataConversion数据流 按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream
      6.Printing 包含方便的打印方法 ：PrintWriter、PrintStream
      7.Buffering缓冲  在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream
      8.Filtering 滤流，在数据进行读或写时进行过滤：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过
      9.Concatenation合并输入 把多个输入流连接成一个输入流 ：SequenceInputStream
     10.Counting计数  在读入数据时对行记数 ：LineNumberReader、LineNumberInputStream
     11.Peeking Ahead 通过缓存机制，进行预读 ：PushbackReader、PushbackInputStream
     12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换（Stream到Reader,Writer的转换类）：InputStreamReader、OutputStreamWriter
 
二、按数据来源（去向）分类： 
 1、File（文件）： FileInputStream, FileOutputStream, FileReader, FileWriter 
 2、byte[]：ByteArrayInputStream, ByteArrayOutputStream 
 3、Char[]: CharArrayReader, CharArrayWriter 
 4、String: StringBufferInputStream, StringReader, StringWriter 
 5、网络数据流：InputStream, OutputStream, Reader, Writer 
 
 
 
 
 
 
 
 
七. 字节流InputStream/OutputStream
 
 

 
 1. InputStream抽象类 
 
      InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。 继承自InputStream  的流都是向程序中输入数据的，且数据单位为字节（8bit）；
 
InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法： 
 　　（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。
 　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的 
 　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。 
 　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用， 
 　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取 
 　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭. 
 
         主要的子类：
 
        
 
         1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作     
 　　  2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用 
 　　  3） StringBufferInputStream：把一个String对象作为InputStream 
 　　  4） PipedInputStream：实现了pipe的概念，主要在线程中使用 
 　　  5） SequenceInputStream：把多个InputStream合并为一个InputStream 
 
 
 
 2．OutputStream抽象类 
 
　　OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。 
 　　1. public void write(byte b[ ])：将参数b中的字节写到输出流。 
 　　2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。 
 　　3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。 
 　　4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。 
 　　5. public void close( ) : 关闭输出流并释放与流相关的系统资源。 
 
 
 
       主要的子类：
 
        
 
      1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中 
       2) FileOutputStream：把信息存入文件中 
       3) PipedOutputStream：实现了pipe的概念，主要在线程中使用 
       4) SequenceOutputStream：把多个OutStream合并为一个OutStream 
 
流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。
 
3. 文件输入流： FileInputStream类
 
      FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。
 
 
 
 

  
 
作用：以文件作为数据输入源的数据流。或者说是打开文件，从文件读数据到内存的类。
 使用方法(1)    
    File  fin=new File("d:/abc.txt"); 
   FileInputStream in=new FileInputStream( fin);
 
 
 
使用方法(2)
    FileInputStream  in=new  FileInputStream(“d: /abc.txt”);
 
程序举例：
 将InputFromFile.java的程序的内容显示在显示器上
 
 
 
 
import java.io.IOException;
import java.io.FileInputStream;
;
public class TestFile {
	public static void main(String args[]) throws IOException {
		try{	
		       FileInputStream rf=new   FileInputStream("InputFromFile.java");
		       int n=512;   byte  buffer[]=new  byte[n];   
		       while((rf.read(buffer,0,n)!=-1)&&(n>0)){
		           System.out.println(new String(buffer) );
		        }
		        System.out.println();
		        rf.close();
		} catch(IOException  IOe){	    
		      System.out.println(IOe.toString());
		}

	}

}
 
 
 
4.文件输出流:FileOutputStream类
 
　  作用：用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件
 
      FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。 
 　　创建一个文件流对象有两种方法： 
 　　方式1： 
 　　 File   f=new  File (“d:/myjava/write.txt ");
         FileOutputStream  out= new FileOutputStream (f);
 　　方式2： 
 　　FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt "); 
 　　方式3：构造函数将 FileDescriptor()对象作为其参数。 
 　　FileDescriptor() fd=new FileDescriptor(); 
 　　FileOutputStream f2=new FileOutputStream(fd); 
 　　方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。 
 　　FileOutputStream f=new FileOutputStream("d:/abc.txt",true); 
 　　注意： （1）文件中写数据时，若文件已经存在，则覆盖存在的文件；（2）的读/写操作结束时，应调用close方法关闭流。 
 
 
 
 
 

  程序举例：
  使用键盘输入一段文章，将文章保存在文件write.txt中
 
 
 
 
 
 
import java.io.IOException;
import java.io.FileOutputStream;
public class TestFile {
	public static void main(String args[]) throws IOException {
		try {
			System.out.println("please Input from      Keyboard");
			int count, n = 512;
			byte buffer[] = new byte[n];
			count = System.in.read(buffer);
			FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");
			wf.write(buffer, 0, count);
			wf.close(); // 当流写操作结束时，调用close方法关闭流。
			System.out.println("Save to the write.txt");
		} catch (IOException IOe) {
			System.out.println("File Write Error!");
		}
	}

}
 
 
5. FileInputStream流和FileOutputStream的应用
 
 

 利用程序将文件file1.txt 拷贝到file2.txt中。 
 
import java.io.File;
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.FileInputStream;

public class TestFile {
	public static void main(String args[]) throws IOException {
		try {
			File inFile = new File("copy.java");
			File outFile = new File("copy2.java");
			FileInputStream finS = new FileInputStream(inFile);
			FileOutputStream foutS = new FileOutputStream(outFile);
			int c;
			while ((c = finS.read()) != -1) {
				foutS.write(c);
			}
			finS.close();
			foutS.close();
		} catch (IOException e) {
			System.err.println("FileStreamsTest: " + e);
		}
	}

}
 
 
 
 
 
 
6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream
         
 
 
 
 

       
 
 
 
       计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。
 
 
BufferedInputStream: BufferedInputStream比FileInputStream多了一个缓冲区。它提供了一个缓冲数组，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快。BufferedInputStream的默认缓冲区大小是8192字节。当每次读取的数据量很小时，FileInputStream每次都是从硬盘读入，而BufferedInputStream大部分是从缓冲区读入。读取内存速度比读取硬盘速度快得多，因此BufferedInputStream效率高。
 
 
例如：BUFFER_SIZE < 8192时候，BufferedInputStream性能是很高。
 
 
BufferedInputStream  bufferedInput = new BufferedInputStream(new FileInputStream(fileA));
byte[] buffer = new byte[BUFFER_SIZE];
int len;
while ((len = bufferedInput.read(buffer)) > 0){
    System.out.println(new String(buffer, 0, len));
}
 
 
BUFFER_SIZE > 8192时候, FileInputStream和BufferedInputStream两者效率就没有明显差别了。
 
 
BufferedOutputStream :执行wirte时先写入缓冲区，待缓冲区写满后，系统再写入输出设备。
 
 
 
 
 

 1）将文件读入内存：
 
 
 
将BufferedInputStream与FileInputStream相接
 
 
  FileInputStream in = new  FileInputStream( “file1.txt ” );
 
 
  BufferedInputStream bin = new  BufferedInputStream( in); 
 
 
2）将内存写入文件：
 
 
将BufferedOutputStream 与 FileOutputStream相接:
 
 
String fileB = "/Users/huangguisu/b.txt";
 FileOutputStream out = new FileOutputStream(fileB);
 BufferedOutputStream bOut = new BufferedOutputStream(out);
 byte[] buffer = {0x1,0x2,0x3};
 bOut.write(buffer);
 bOut.flush();
 bOut.close();
 
 

 3）键盘输入流读到内存
 

 将
 BufferedReader
 与
 标准的数据流
 相接 
 

  InputStreamReader 
 sin = new InputStreamReader (
 System.in) ；
 

 BufferedReader bin = new       BufferedReader(
 sin);
 
import java.io.*;

public class ReadWriteToFile {
	public static void main(String args[]) throws IOException {
		InputStreamReader sin = new InputStreamReader(System.in);
		BufferedReader bin = new BufferedReader(sin);
		FileWriter out = new FileWriter("myfile.txt");
		BufferedWriter bout = new BufferedWriter(out);
		String s;
		while ((s = bin.readLine()).length() > 0) {
			bout.write(s, 0, s.length());
		}

	}
}
 
程序说明：
 从键盘读入字符，并写入到文件中BufferedReader类的方法：String readLine()
 作用：读一行字符串，以回车符为结束。
 BufferedWriter类的方法：bout.write(String s,offset,len)
 作用：从缓冲区将字符串s从offset开始，len长度的字符串写到某处。
 
 
 
 
 
 
 
八. 字符流Writer/Reader
 
 

 
        Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。
 
1. Reader抽象类
 
    用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
 
       
 
        1) FileReader :与FileInputStream对应  
            主要用来读取字符文件，使用缺省的字符编码，有三种构造函数： 
 　　    (1）将文件名作为字符串 ：FileReader f = new FileReader(“c:/temp.txt”); 
 　　    (2）构造函数将File对象作为其参数。 
 　　            File f=new file(“c:/temp.txt”); 
 　　            FileReader f1=new FileReader(f); 
 　　   (3)  构造函数将FileDescriptor对象作为参数 
 　　          FileDescriptor() fd = new FileDescriptor() 
 　　          FileReader f2=new FileReader(fd); 
                (1) 用指定字符数组作为参数：CharArrayReader(char[]) 
                (2) 将字符数组作为输入流:CharArrayReader(char[], int, int) 
 　         读取字符串，构造函数如下： public StringReader(String s); 
         2) CharArrayReader：与ByteArrayInputStream对应  
 　　3) StringReader : 与StringBufferInputStream对应 
 　　4) InputStreamReader 
 　　      从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is); 
 　　5) FilterReader: 允许过滤字符流 
 　　      protected filterReader(Reader r); 
 　　6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。 
 　　   Public BufferReader(Reader r); 
 
      主要方法：
 
      (1)  public int read() throws IOException; //读取一个字符，返回值为读取的字符 
 
　　(2)  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量*/ 
 　　(3)  public abstract int read(char cbuf[],int off,int len) throws IOException; 
 　　/*读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现*/ 
 
2. Writer抽象类
 
     写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 其子类如下：
 
    
 
      1） FileWrite: 与FileOutputStream对应  
 　　将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。 
 　　Public FileWrite(file f); 
 　　2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。 
　　    Public CharArrayWrite(); 
　　3) PrintWrite:生成格式化输出 
　　    public PrintWriter(outputstream os); 
　　4) filterWriter:用于写入过滤字符流 
　　    protected FilterWriter(Writer w); 
　　5) PipedWriter：与PipedOutputStream对应   
 
      6) StringWriter：无与之对应的以字节为导向的stream  
 
      主要方法：
 
　　(1)  public void write(int c) throws IOException； //将整型值c的低16位写入输出流 
　　(2)  public void write(char cbuf[]) throws IOException； //将字符数组cbuf[]写入输出流 
　　(3)  public abstract void write(char cbuf[],int off,int len) throws IOException； //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流 
　　(4)  public void write(String str) throws IOException； //将字符串str中的字符写入输出流 
　　(5)  public void write(String str,int off,int len) throws IOException； //将字符串str 中从索引off开始处的len个字符写入输出流 
　　(6)  flush( ) //刷空输出流，并输出所有被缓存的字节。 
　　(7)close()    关闭流 public abstract void close() throws IOException
 
 
 
 
 
3 .InputStream与Reader差别 OutputStream与Writer差别
 
 
 
InputStream和OutputStream类处理的是字节流，数据流中的最小单位是字节(8个bit)
 Reader与Writer处理的是字符流，在处理字符流时涉及了字符编码的转换问题
 
import java.io.*;
public class EncodeTest {
    private static void readBuff(byte [] buff) throws IOException {
       ByteArrayInputStream in =new ByteArrayInputStream(buff);
        int data;
        while((data=in.read())!=-1)   System.out.print(data+"  ");
        System.out.println();     in.close();     }

   public static void main(String args[]) throws IOException {
       System.out.println("内存中采用unicode字符编码：" );
       char   c='好';
       int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;
       System.out.println(""+lowBit+"   "+highBit);
       String s="好";
       System.out.println("本地操作系统默认字符编码：");
       readBuff(s.getBytes());
       System.out.println("采用GBK字符编码：");
       readBuff(s.getBytes("GBK"));
       System.out.println("采用UTF-8字符编码：");      
       readBuff(s.getBytes("UTF-8"));      }
}
 

 Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符，然后在内存中为其分配内存
 
Writer类能够将内存中的Unicode字符转换为其他编码类型的字符，再写到输出流中。
 
 
 
4、BufferedInputStream 和BufferedReader区别
 
首先虽然都作为一个包装类，但是BufferedReader针对字符流，BufferedInputStream针对字节流
 
BufferedInputStream在实现的时候是在自身read方法中提供缓存，是一次取1024或更多字节然后再慢慢读，一个个的返回，它并没有实现读一行的方法
 
BufferedReader在实现时通过提供一个readLine方法，使用数组或者stringBuilder存储一行数据，并一次性返回
 
 
 
 
 
九. FileWriter类(字符输出流类)
 
 

构造方法：FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话，并创建。
 
               如： FileWriter fw = new FileWriter("C:\\1.txt");
 
                 FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。
 
               如：FileWriter fw = new FileWriter("C:\\1.txt",ture); //表示在fw对文件再次写入时，会在该文件的结尾续写，并不会覆盖掉。
 
主要方法： 
 
        void write(String str)   //写入字符串。当执行完此方法后，字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。
 
        viod flush()                //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。
 
        viod close()               //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后，再写入或者刷新的话，会抛IOException异常。
 
 
 
十. 如何选择IO流
 
 

  
1、确定是数据源和数据目的（输入还是输出）
 
              源:输入流 InputStream Reader
               目的:输出流 OutputStream Writer
 
2、明确操作的数据对象是否是纯文本
 
             是:字符流Reader，Writer
              否:字节流InputStream，OutputStream
 
3、明确具体的设备。
 
       是硬盘文件：File++：
               读取：FileInputStream,, FileReader,
                写入：FileOutputStream，FileWriter
       是内存用数组
               是byte[]：ByteArrayInputStream, ByteArrayOutputStream
               是char[]：CharArrayReader, CharArrayWriter
               是String：StringBufferInputStream(已过时，因为其只能用于String的每个字符都是8位的字符串), StringReader, StringWriter
               是网络用Socket流： 输入socket.getOutputStream()      输出socket.getInputStream()
              是键盘：用System.in（是一个InputStream对象）读取，用System.out（是一个OutoutStream对象）打印
 
4、是否需要转换流
 
            是，就使用转换流，从Stream转化为Reader，Writer：InputStreamReader，OutputStreamWriter 
 
5、是否需要缓冲提高效率
 
        是就加上Buffered：BufferedInputStream, BufferedOuputStream, BuffereaReader, BufferedWriter
    
 
6、是否需要格式化输出
 
 
 
例如：将一个文件中数据存储到另一个文件中。JAVA的文件读取主要有字节流读取和字符流读取两种方式，字节流可以既可以操作文本文件，也可以操作非文本文件，如一些二进制数据（图片，视频，对象），而字符流只能操作文本。
     
 
将一个文件中数据存储到另一个文件中：
 
1） 数据源和数据目的：读取流，InputStream/Reader  输出：OutputStream/Writer
2）是否纯文本：是！可以选择Reader Writer和InputStream/OutputStream。 
3）设备：是硬盘文件。Reader体系中可以操作文件的对象是 FileReader FileWriter。
               FileReader fr = new FileReader("a.txt");  
               FileWriter fw = new FileWriter("b.txt"); 
4）是否需要提高效率：是，加Buffer
             BufferedReader bfr = new BufferedReader(new FileReader("a.txt");  );  
             BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt");  ); 
 
package com.javademo.demo.io;
import java.io.*;

public class IoFileDemo {
    private static int BUFFER_SIZE = 1024;
    public static void main(String[] args) throws Exception {
        IoFileDemo  ioFileDemo = new IoFileDemo();
        String  fileA = "/Users/huangguisu/a.txt";
        String  fileB = "/Users/huangguisu/b.txt";
        ioFileDemo.copyFileWithBufferStream(fileA, fileB);

    }

    /**
     * 字符流读取：只能操作文本文件
     * @param srcFile
     * @throws IOException
     */
    public String readFile(String srcFile)  throws IOException {
        FileReader fr = new FileReader(srcFile);//读取流
        //不要直接用String直接拼接文本。。效率太低，每次要new新对象，用StringBuilder，StringBuffer都可以
        StringBuffer sb = new StringBuffer();
        char[] buf = new char[10];
        int len;
        //读取文件并把它存入buf中，用len返回读到字符的个数，一直读到结尾
        while ((len = fr.read(buf)) != -1) {
            //buf字符数组里仍有空白没有读入的位置，所以不要直接new String(buf);
            String str = new String(buf,0,len);
            sb.append(str);
        }
        fr.close();
        return  sb.toString();

    }

    /**
     * 字符流读取和写入：只能操作文本
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithString(String srcFile, String dstFile)  throws IOException {
        FileReader fr = new FileReader(srcFile);//读取流
        FileWriter fw = new FileWriter(dstFile);//输出流
        char[] buf = new char[10];
        int len;
        //读取文件并把它存入buf中，用len返回读到字符的个数，一直读到结尾
        while ((len = fr.read(buf)) != -1) {
            //buf字符数组里仍有空白没有读入的位置，所以不要直接fw.write(buf);可以直接使用fw.write(buf, 0, len);
            String str = new String(buf,0,len);
            fw.write(str);
        }
        fr.close();
        fw.close();

    }

    /**
     * 使用buffer读取和写入字符流：：只能操作文本
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithBufferedString(String srcFile, String dstFile)  throws IOException {
        FileReader fr = new FileReader(srcFile);//读取流
        FileWriter fw = new FileWriter(dstFile);//输出流
        //使用Buffer提高效率
        BufferedReader bfr = new BufferedReader(fr);
        BufferedWriter bfw = new BufferedWriter(fw);

        String str = null;
        int j = 1;
        while ((str = bfr.readLine()) != null) {
            System.out.println("第" + j + "行内容：" + str);
            bfw.write(str);
            bfw.newLine();//跨平台的换行符
            j++;
        }
        bfr.close();
        bfw.close();
        fr.close();
        fw.close();


    }

    /**
     * 例:将一个二进制数据（图片，视频，对象）文件中数据存储到另一个文件中，只能用xxxStream.
     * 当然也可以读取文本文件。
     * 字节输入流和输出流
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithStream(String srcFile, String dstFile)  throws IOException {
        FileInputStream finS = new FileInputStream(srcFile);
        FileOutputStream foutS = new FileOutputStream(dstFile);
        int c;
        while ((c = finS.read()) != -1) {
            foutS.write(c);
        }
        //或者
        /*
        byte[] buffer = new byte[1024];
        int len;
        while ((len = finS.read(buffer)) > 0){
            foutS.write(buffer, 0, len);
            len.flush();
        }
        */
        finS.close();
        foutS.close();
    }

    /**
     * 使用Buffer
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithBufferStream(String srcFile, String dstFile) throws IOException{
        FileInputStream finS = new FileInputStream(srcFile);
        FileOutputStream foutS = new FileOutputStream(dstFile);
        BufferedInputStream  bufferedInput = new BufferedInputStream(finS);
        BufferedOutputStream bufferedOutput = new BufferedOutputStream(foutS);
        byte[] buffer = new byte[BUFFER_SIZE];
        int len;
        while ((len = bufferedInput.read(buffer)) > 0){
            bufferedOutput.write(buffer, 0, len);
            bufferedOutput.flush();
        }

        bufferedInput.close();
        bufferedOutput.close();
        finS.close();
        foutS.close();
    }

    /**
     * BufferedReader则是比InputStreamReader更高级,它封裝了StreamReader类,一次读取取一行的字符
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithBufferStream2(String srcFile, String dstFile)  throws IOException {
        FileInputStream finS = new FileInputStream(srcFile);
        FileOutputStream foutS = new FileOutputStream(dstFile);

        InputStreamReader inputStreamReader = new InputStreamReader(finS,"utf8");
        OutputStreamWriter outputStreamWriter = new  OutputStreamWriter(foutS, "utf8");
        BufferedReader brRead = new BufferedReader(inputStreamReader);
        BufferedWriter brWriter = new BufferedWriter(outputStreamWriter);
        String line = null;
        while((line= brRead.readLine()) != null){
            System.out.println(line);
            brWriter.write(line);
            brWriter.newLine();//跨平台的换行符
            brWriter.flush();//刷新流
        }
        brRead.close();
        brWriter.close();
        finS.close();
        foutS.close();

    }


}
 
 
 
7、网络（socket）数据交互：
 
package com.javademo.demo.socket;

import java.io.*;
import java.net.Socket;

public class SocketClient {
    public static void main(String args[]) throws Exception{
        //1、创建客户端Socket，指定服务器地址和端口
        Socket socket = new Socket("127.0.0.1",10000);
        //2、获取输出流，向服务器端发送信息：由Socket对象得到输出流
        OutputStream output = socket.getOutputStream();//字节输出流
        //构造PrintWriter对象：将输出流包装成打印流
        PrintWriter printWriter = new PrintWriter(output);
        printWriter.write("{'user':'hgs'}");
        printWriter.flush();


        //3、获取输入流，并读取服务器端的响应信息：由Socket对象得到输入流
        InputStream inputStream = socket.getInputStream();
        //构造相应的BufferedReader对象
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String info = null;
        while((info = bufferedReader.readLine()) != null){
            System.out.println("Hello,我是客户端，服务器说："+info);
        }

        //4、由系统标准输入设备构造BufferedReader对象
        BufferedReader stdIn = new BufferedReader( new InputStreamReader(System.in));
        String readline;
        readline= stdIn.readLine(); //从系统标准输入读入一字符串
        //若从标准输入读入的字符串为 "ok"则停止循环
        while(!readline.equals("ok")){
            //将从系统标准输入读入的字符串输出到Server
            printWriter.println(readline);
            //刷新输出流，使Server马上收到该字符串
            printWriter.flush();
            //在系统标准输出上打印读入的字符串
            System.out.println("Client:"+readline);
            //从Server读入一字符串，并打印到标准输出上
            System.out.println("Server:"+bufferedReader.readLine());
            readline = stdIn.readLine(); //从系统标准输入读入一字符串
        }

    }
}
 
 
 
 
 
11. IOException异常类的子类
 
 

1.public class  EOFException ：
    非正常到达文件尾或输入流尾时，抛出这种类型的异常。
 2.public class FileNotFoundException：
    当文件找不到时，抛出的异常。
 3.public class InterruptedIOException：
    当I/O操作被中断时，抛出这种类型的异常。
 



  
 
 
 
感谢您的支持，我会继续努力的! 扫码打赏，你说多少就多少
 
 

          
 
 
 
 
 
 
 

记录下一点自己的心得体会，分享给大家，有不足之处，望指教。
 
第一阶段：假想阶段
 
 
本阶段是整个软件开发的开始阶段，输入可以是为了提高工作效率的某个好的想法或者是公司领导为了帮助管理发出的命令。输出就是业务需求文档，英文称为Business Requirement Document。这个文档的文字描述的抽象层次很高，比如业务人员说我需要一个软件，能够实现无纸化办公，能够管理合同，管理客户信息，能够在登录时选择角色，选择显示语言，登录成功后自动列出登录人的当前要做的任务项，等等。这个文档主要来自业务人员，所以主要完成业务概念的描述。
 
第二阶段：需求开发阶段
 
 
本阶段的主要工作是基于业务需求文档进一步分析业务人员的真实需求，输入是假想阶段的业务需求文档，输出是功能说明文档，英文称为Funtion Specification。功能说明文档与业务需求文档的主要区别是业务需求文档主要描述业务概念，而功能说明描述的是信息技术概念，此文档的主要功能是完成从业务概念到信息技术概念的匹配和对齐，在保证实现业务人员真实想法的同时还要结合信息技术保证系统功能的逻辑合理性和优化性。可以说通常业务需求文档描述的一个点到这里都会扩展成为一个面。作者认为本阶段的工作至关重要，这个阶段的工作输出会直接影响到下面的设计阶段和实现阶段的工作。所以本阶段需要很多重要角色的参与，之前提到过的有软件产品设计师，软件开发架构师，软件开发负责人，软件测试负责人和业务负责人。这些角色要共同齐心合力完成一份高质量的功能说明文档。
 
第三阶段：设计阶段
 
 
本阶段的输入是功能说明文档，输出是软件架构设计文档，硬件架构设计文档，测试计划文档。这三份文档可以同时进行，值得一提的是软件架构设计和硬件架构设计通常是同时考虑完成的，没有绝对的谁先完成谁后完成，并且都可以再细分。硬件设计可以分为概要设计和详细设计，概要设计通常要描述出有几个环境，每个环境有几台服务器，使用的是虚拟服务器还是物理服务器，每个服务器的作用，分别在哪个级别的安全区域，防火墙分布，负载均衡设备的分布，数据库产品信息，是单实例还是集群；详细设计除了要描述出这些信息还要描述出每台服务器的硬件配置信息，地址，开放的端口，HTTP请求或者其他类型的请求的走向，是单方向还是双方向，每台服务器上运行的操作系统，应用服务器的产品信息和版本信息，防火墙的设置，负载均衡设备的设置，数据库实例名称，软件的所有组件在每个应用服务器上的分布信息等。
 
软件设计可以分为概要设计和详细设计，概要设计通常要描述出有几个主要组成部分，每个部分的存在形式和功能。举个简单的例子，有这样一个系统，它包括业务子系统，存储子系统，打印子系统，银行对接子系统，政府对接子系统；存在的形式可能是Java开发的独立系统，操作硬件设备的服务接口，外部机构官方提供的对外公开的Web Service接口，外部机构官方提供的对外公开的官网。详细设计通常要描述出各个子系统的对接形式，通信协议，权限控制。比如是基于TCP/IP协议的数据库层面的对接，还是基于TCP/IP协议的socket形式的对接，还是基于HTTP协议的web service形式的对接；当然如果对方的存在形式不容易实现对接可以在子系统内部做适当的转换处理，比如说对方是公开出来的网站。对于每个子系统的内部通常要描述出权限控制机制，系统的分解和集成机制，实现技术的组成；权限控制要结合具体的系统分析判断；系统的分解和集成通常要结合实现技术考虑，模块和层次的划分都有成熟的可供参考的原则和解决方案；值得一提的是展现层的设计，输出应该包括动态形式的原型系统和静态形式的文档，前者的重点是软件的行为定义，后者的重点是软件的业务逻辑定义；实现技术部分要把所有用到的运行时环境，编程语言，第三方类库描述清楚。作者不主张在这个阶段对类和成员的定义已经类之间的调用做出规定，这个层次的问题留给实现阶段来考虑。所以在本阶段作者更多地是关注架构模式和框架模式的考虑，对于设计模式的考虑则留给实现阶段。
 
测试计划分为功能测试计划，性能测试计划，安全测试计划。通常要描述出测试案例，测试环境的组建，测试工具，测试技术。每个测试的话题都可以作为一个专业的方向单独拿出来描述，限于篇幅，这里就不多说了。
 
第四阶段：实现阶段
 
 
如果设计阶段的工作做得足够充分，那么这个阶段的工作将变得容易得多。这个阶段的输入是设计文档。输出是源代码和构建出来的软件安装包。源代码的书写必须遵循统一的规范，必须遵循设计阶段定义的统一的架构，必须达到规定的安全标准，用合理的方式实现设计文档所设计的功能。
 
第五阶段：质量检查阶段
 
 
这个阶段的输入是准备测试的系统和测试案例。输出是缺陷记录和缺陷报告。
 
第六阶段：部署阶段
 
 
这个阶段的输入是可供部署的软件安装包和部署文档。输出是可供用户使用的业务系统，备份和恢复计划。
 
总结：
 
我们可以这样看待一个业务软件，对于一个业务软件有业务线，软件线，硬件线三条线，业务想法由软件来实现，软件需要运行在硬件上。