Java笔记（六）
IO流：
字符流和字节流：
字符流两个基类： InputStream OutputStream
字节流两个基类： Reader Writer
FileWriter:
import java.io.FileWriter;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException {
//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件
//而且该文件被创建到指定目录下，如果该目录下已有同名文件，将被覆盖
//该步就是在明确数据要存放的目的地
FileWriter fw = new FileWriter("F:\\demo.txt"); //调用write方法，将字符串写入到流中
fw.write("abcde"); //刷新流对象中的缓冲区数据
//将数据刷到目的地中
fw.flush(); //关闭流资源，但是关闭之前会刷新一次内部的缓冲区数据
//将数据刷到目的地中
//和flush区别：flush刷新后，流可以继续使用；close刷新后，会将流关闭
fw.close();
}
}
IO异常处理方式：
import java.io.FileWriter;
import java.io.IOException; public class Demo{
public static void main(String[] args) {
FileWriter fw = null;
try{
fw = new FileWriter("F:\\demo.txt");
fw.write("abcdefg");
}catch(IOException e){
System.out.println(e.toString());
}finally{
if(fw != null){
try{
fw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
}
文件的续写：
import java.io.FileWriter;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException {
//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写
FileWriter fw = new FileWriter("F:\\demo.txt", true);
fw.write("haha");
fw.close();
}
}
文件的读取方式（一）：
import java.io.FileReader;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException {
//创建一个文件读取流对象，和指定名称的文件相关联
//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
FileReader fr = new FileReader("F:\\demo.txt"); //调用读取流对象的read方法
//read():一次读一个字符，而且会自动往下读
int ch = 0;
while((ch = fr.read()) != -1){
System.out.print((char)ch);
}
}
}
文件的读取方式（二）：
import java.io.FileReader;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("F:\\demo.txt"); //定义一个字符数组，用于存储读到的字符
//该read(char[])返回的是读到字符的个数
char[] buf = new char[1024];
int num = 0;
while((num = fr.read(buf)) != -1){
System.out.println(new String(buf, 0, num));
}
fr.close();
}
}
复制文件：
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; public class Demo{
public static void main(String[] args){
copy();
}
public static void copy(){
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("F:\\demo.txt");
fw = new FileWriter("F:\\demo_copy.txt");
char[] buf = new char[1024];
int len = 0;
while((len = fr.read(buf)) != -1){
fw.write(buf, 0, len);
}
}catch(IOException e){
throw new RuntimeException("读写失败");
}finally{
if(fr != null){
try{
fr.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
if(fw != null){
try{
fw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
}
BufferedWriter：
缓冲区的出现是为了提高流的操作效率而出现的，所以在创建缓冲区前，必须要先有流对象。
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException {
//创建一个字符写入流对象
FileWriter fw = new FileWriter("F:\\demo.txt"); //为了提高字符写入流效率，加入缓冲技术
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
BufferedWriter bufw = new BufferedWriter(fw);
for(int i = 0; i < 5; i++){
bufw.write("abcd" + i);
bufw.newLine(); //等同于bufw.write("\r\n");且跨平台
bufw.flush();
} //关闭缓冲区，就是在关闭缓冲区中的流对象
bufw.close();
}
}
BufferedReader：
该缓冲区提供了一个一次读一行的方法readLine，方便用于对文本数据的获取。当返回null时，表示读到文件的末尾。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException {
//创建一个读取流对象和文件相关联
FileReader fr = new FileReader("F:\\demo.txt"); //为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数
BufferedReader bufr = new BufferedReader(fr); String line = null;
while((line = bufr.readLine()) != null){
System.out.println(line);
}
bufr.close();
}
}
通过缓冲区复制一个文件：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; public class Demo{
public static void main(String[] args) {
BufferedReader bufr = null;
BufferedWriter bufw = null;
try{
bufr = new BufferedReader(new FileReader("F:\\demo.txt"));
bufw = new BufferedWriter(new FileWriter("F:\\demo_copy.txt"));
String line = null;
while((line = bufr.readLine()) != null){
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}catch(IOException e){
throw new RuntimeException("读写失败");
}finally{
if(bufr != null){
try{
bufr.close();
}catch(IOException e){
throw new RuntimeException("读取关闭失败");
}
}
if(bufw != null){
try{
bufw.close();
}catch(IOException e){
throw new RuntimeException("写入关闭失败");
}
}
}
}
}
模拟BufferedReader：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; class MyBufferedReader{
private FileReader f;
MyBufferedReader(FileReader f){
this.f = f;
}
public String myReadLine() throws IOException{
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch = f.read()) != -1){
if(ch == '\r')
continue;
else if(ch == '\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length() != 0){
return sb.toString();
}
return null;
}
public void myClose() throws IOException{
f.close();
}
} public class Demo{
public static void main(String[] args) throws IOException {
MyBufferedReader mybuf = new MyBufferedReader(new FileReader("F:\\demo.txt"));
String line = null;
while((line = mybuf.myReadLine()) != null){
System.out.println(line);
}
mybuf.myClose();
}
}
LineNumberReader：
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader; public class Demo{
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("F:\\demo.txt");
LineNumberReader num = new LineNumberReader(fr);
num.setLineNumber(100);
String line = null;
while((line = num.readLine()) != null){
System.out.println(num.getLineNumber() + ": " + line);
}
num.close();
}
}
输出结果：
101: abcd0
102: abcd1
103: abcd2
104: abcd3
105: abcd4
模拟LineNumberReader：
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader; class MyBufferedReader{
private FileReader f;
MyBufferedReader(FileReader f){
this.f = f;
}
public String myReadLine() throws IOException{
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch = f.read()) != -1){
if(ch == '\r')
continue;
else if(ch == '\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length() != 0){
return sb.toString();
}
return null;
}
public void myClose() throws IOException{
f.close();
}
} class MyLineNumberReader extends MyBufferedReader{
private int lineNum;
MyLineNumberReader(FileReader r) {
super(r);
}
public String myReadLine() throws IOException{
lineNum++;
return super.myReadLine();
}
public void setLineNumber(int lineNum){
this.lineNum = lineNum;
}
public int getLineNumber(){
return lineNum;
}
} public class Demo{
public static void main(String[] args) throws IOException {
MyLineNumberReader myline = new MyLineNumberReader(new FileReader("F:\\demo.txt"));
String line = null;
myline.setLineNumber(100);
while((line = myline.myReadLine()) != null){
System.out.println(myline.getLineNumber() + ": " + line);
}
myline.myClose();
}
}
字节流读写操作：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException{
readFile_03();
}
public static void writeFile() throws IOException{
FileOutputStream f = new FileOutputStream("F:\\demo.txt");
f.write("ztq".getBytes());
//不需要刷新
f.close();
}
public static void readFile_01() throws IOException{
FileInputStream f = new FileInputStream("F:\\demo.txt");
int ch = 0;
while((ch = f.read()) != -1){
System.out.print((char)ch);
}
f.close();
}
public static void readFile_02() throws IOException{
FileInputStream f = new FileInputStream("F:\\demo.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = f.read(buf)) != -1){
System.out.println(new String(buf, 0, len));
}
f.close();
}
//字节流特有的读文件方法
public static void readFile_03() throws IOException{
FileInputStream f = new FileInputStream("F:\\demo.txt"); //定义一个大小刚好的数组，不用循环
byte[] buf = new byte[f.available()];
f.read(buf);
System.out.println(new String(buf));
}
}
复制一个图片：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException{
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("F:\\pic.jpg");
fos = new FileOutputStream("F:\\pic_copy.jpg");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1){
fos.write(buf, 0, len);
}
}catch(IOException e){
throw new RuntimeException("复制文件失败");
}finally{
if(fis != null){
try{
fis.close();
}catch(IOException e){
throw new RuntimeException("读取流关闭失败");
}
}
if(fos != null){
try{
fos.close();
}catch(IOException e){
throw new RuntimeException("写入流关闭失败");
}
}
}
}
}
字节流的缓冲区：
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class Demo{
public static void main(String[] args) throws IOException{
BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("F:\\pic.jpg"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("F:\\pic_copy.jpg"));
int ch = 0;
while((ch = bufis.read()) != -1){
bufos.write(ch);
}
bufis.close();
bufos.close();
}
}
模拟字节流的缓冲区：
注：11111111提升到int型还是-1，因为在8个1的前面补的全是1。要是在前面补0，既可以保留原字节数据不变，又可以避免-1的出现。
11111111 11111111 11111111 11111111 &
00000000 00000000 00000000 11111111
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream; class MyBufferedInputStream{
private InputStream in;
private int count = 0, pos = 0;
private byte[] buf = new byte[1024];
MyBufferedInputStream(InputStream in){
this.in = in;
}
public int myRead() throws IOException{
if(count == 0){
count = in.read(buf);
if(count < 0) return -1;
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b & 0xff;
}
else if(count > 0){
byte b = buf[pos];
count--;
pos++;
return b & 0xff;
}
return -1;
}
public void myClose() throws IOException{
in.close();
}
} public class Demo{
public static void main(String[] args) throws IOException{
MyBufferedInputStream mybfis = new MyBufferedInputStream(new FileInputStream("F:\\pic.jpg"));
BufferedOutputStream bfos = new BufferedOutputStream(new FileOutputStream("F:\\pic_copy.jpg"));
int ch = 0;
while((ch = mybfis.myRead()) != -1){
bfos.write(ch);
}
mybfis.myClose();
bfos.close();
}
}
读取键盘录入：
通过键盘录入数据，当录入一行数据后，就将该行数据进行打印。如果录入的数据是over，那么停止录入。
import java.io.IOException;
import java.io.InputStream; public class Demo{
public static void main(String[] args) throws IOException{
InputStream in = System.in;
StringBuilder sb = new StringBuilder();
while(true){
int ch = in.read();
if(ch == '\r')
continue;
else if(ch == '\n'){
String s = sb.toString();
if("over".equals(s))
break;
System.out.println(s);
sb.delete(0, sb.length());
}
else{
sb.append((char)ch);
}
}
}
}
读取转换流：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader; public class Demo{
public static void main(String[] args) throws IOException{
//获取键盘录入对象
InputStream in = System.in; //将字节流对象转成字符流对象，使用转换流。InputStreamReader
InputStreamReader isr = new InputStreamReader(in); //为了提高效率，将字符串进行缓冲区技术高效操作。BufferedReader
BufferedReader bufr = new BufferedReader(isr); String line = null;
while((line = bufr.readLine()) != null){
if("over".equals(line)) break;
System.out.println(line.toUpperCase());
}
bufr.close();
}
}
写入转换流：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter; public class Demo{
public static void main(String[] args) throws IOException{
//键盘录入常见写法
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out)); String line = null;
while((line = bufr.readLine()) != null){
if("over".equals(line)) break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
流操作的基本规律：
1.（1）明确源和目的
源：输入流。InputStream Reader
目的：输出流。 OutputStream Writer
（2）操作的数据是否是纯文本
是：字符流。
否：字节流。
（3）当体系明确后，再明确要是用哪个具体的对象。通过设备来进行区分。
源设备：内存、硬盘、键盘
目的设备：内存、硬盘、控制台
通常涉及到字符编码转换时，需要用到转换流。
异常的日志信息：
import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date; public class Demo{
public static void main(String[] args){
try{
int[] arr = new int[2];
System.out.println(arr[3]);
}catch(Exception e){
try{
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
PrintStream ps = new PrintStream("F:\\exception.log");
ps.println(s);
System.setOut(ps);
}catch(IOException ex){
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}
将系统信息存储到文件中：
import java.io.IOException;
import java.io.PrintStream;
import java.util.Properties; public class Demo{
public static void main(String[] args) throws IOException{
Properties pro = System.getProperties();
pro.list(new PrintStream("F:\\properties.txt"));
}
}
Java笔记（六）的更多相关文章
- Java笔记(六)……程序流程控制
判断结构 三种结构: 1: if(条件表达式) 2: { 3: 执行语句; 4: } 5: 6: if(条件表达式) 7: { 8: 执行语句; 9: } 10: else 11: { 12: 执行 ...
- java之jvm学习笔记六-十二(实践写自己的安全管理器)(jar包的代码认证和签名) (实践对jar包的代码签名) (策略文件)(策略和保护域) (访问控制器) (访问控制器的栈校验机制) (jvm基本结构)
java之jvm学习笔记六(实践写自己的安全管理器) 安全管理器SecurityManager里设计的内容实在是非常的庞大,它的核心方法就是checkPerssiom这个方法里又调用 AccessCo ...
- Java IO学习笔记六：NIO到多路复用
作者:Grey 原文地址:Java IO学习笔记六:NIO到多路复用 虽然NIO性能上比BIO要好,参考:Java IO学习笔记五:BIO到NIO 但是NIO也有问题,NIO服务端的示例代码中往往会包 ...
- Typescript 学习笔记六：接口
中文网:https://www.tslang.cn/ 官网:http://www.typescriptlang.org/ 目录: Typescript 学习笔记一:介绍.安装.编译 Typescrip ...
- java笔记整理
Java 笔记整理 包含内容 Unix Java 基础, 数据库(Oracle jdbc Hibernate pl/sql), web, JSP, Struts, Ajax Spring, E ...
- Java笔记 —— 继承
Java笔记 -- 继承 h2{ color: #4ABCDE; } a{ text-decoration: none!important; } a:hover{ color: red !import ...
- Java 笔记 —— java 和 javac
Java 笔记 -- java 和 javac h2{ color: #4ABCDE; } a{ text-decoration: none !important; } a:hover{ color: ...
- 《Java笔记——基础语法》
Java笔记--基础语法 一.字符串的拼接: 例如: System.out.println(""+""); 二.换行语句: 例如: Syst ...
- Effective Java笔记一 创建和销毁对象
Effective Java笔记一 创建和销毁对象 第1条 考虑用静态工厂方法代替构造器 第2条 遇到多个构造器参数时要考虑用构建器 第3条 用私有构造器或者枚举类型强化Singleton属性 第4条 ...
- 《MFC游戏开发》笔记六 图像双缓冲技术：实现一个流畅的动画
本系列文章由七十一雾央编写,转载请注明出处. http://blog.csdn.net/u011371356/article/details/9334121 作者:七十一雾央 新浪微博:http:/ ...
随机推荐
- 【Todo】Tomcat与Jetty的比较 以及Tomcat架构的学习
主要参考这篇文章: http://blog.csdn.net/qing_2012/article/details/8276789 然后Tomcat原理的介绍,可以看这篇文章: http://www.i ...
- Testing Is the Engineering Rigor of Software Development
Testing Is the Engineering Rigor of Software Development Neal Ford DEVELOPERS LOVE TO USE TORTURED M ...
- Java菜鸟到大牛学习路线培训教程
第1阶段(Java程序员) - Java语言基础 - 101 JavaSE -01-常见Dos命令.Java历史.Java跨平台.配置Path环境变量.第一个HelloWorld例子 -02-配置JA ...
- Android二维码工具zxing使用
二维码在我们生活中随处可见.在我眼里简直能够用"泛滥"来形容啦.那怎样在我们Android项目中扫描识别二维码或生成二维码图片呢? 我们通常使用的开源框架是zxing.在githu ...
- vue 避免渲染时闪烁
<!DOCTYPE html> <html lang="zh"> <head> <meta charset="UTF-8&quo ...
- Andriod三步学会安卓自己定义视图及其属性
第一步:自己定义属性 第二步:自己定义控件解析属性 watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcm5adW9adW8=/font/5a6L5L2T/fo ...
- angular ui $modal 使用 option
$modal是一个可以迅速创建模态窗口的服务,创建部分页,控制器,并关联他们 $modal仅有一个方法open(options) templateUrl:模态窗口的地址 template:用于显示ht ...
- javascript点滴积累
1. javascript中的array, set, map 均为数据容器,使用iterable内置的forEach方法 var a = ['A', 'B', 'C'];a.forEach(funct ...
- mysql启动warning: World-writable config file
如果在启动warning: World-writable config file /home/mysql/my.cnf is ignored原因:my.cnf的读取权限进行了设置,不允许World-w ...
- live555直播
http://www.cppblog.com/tx7do/archive/2014/05/31/207155.aspx http://blog.csdn.net/sunkwei/article/det ...