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笔记(六)的更多相关文章

  1. Java笔记(六)……程序流程控制

    判断结构 三种结构: 1: if(条件表达式) 2: { 3: 执行语句; 4: } 5:  6: if(条件表达式) 7: { 8: 执行语句; 9: } 10: else 11: { 12: 执行 ...

  2. java之jvm学习笔记六-十二(实践写自己的安全管理器)(jar包的代码认证和签名) (实践对jar包的代码签名) (策略文件)(策略和保护域) (访问控制器) (访问控制器的栈校验机制) (jvm基本结构)

    java之jvm学习笔记六(实践写自己的安全管理器) 安全管理器SecurityManager里设计的内容实在是非常的庞大,它的核心方法就是checkPerssiom这个方法里又调用 AccessCo ...

  3. Java IO学习笔记六:NIO到多路复用

    作者:Grey 原文地址:Java IO学习笔记六:NIO到多路复用 虽然NIO性能上比BIO要好,参考:Java IO学习笔记五:BIO到NIO 但是NIO也有问题,NIO服务端的示例代码中往往会包 ...

  4. Typescript 学习笔记六:接口

    中文网:https://www.tslang.cn/ 官网:http://www.typescriptlang.org/ 目录: Typescript 学习笔记一:介绍.安装.编译 Typescrip ...

  5. java笔记整理

    Java 笔记整理 包含内容     Unix Java 基础, 数据库(Oracle jdbc Hibernate pl/sql), web, JSP, Struts, Ajax Spring, E ...

  6. Java笔记 —— 继承

    Java笔记 -- 继承 h2{ color: #4ABCDE; } a{ text-decoration: none!important; } a:hover{ color: red !import ...

  7. Java 笔记 —— java 和 javac

    Java 笔记 -- java 和 javac h2{ color: #4ABCDE; } a{ text-decoration: none !important; } a:hover{ color: ...

  8. 《Java笔记——基础语法》

    Java笔记--基础语法       一.字符串的拼接: 例如: System.out.println(""+"");     二.换行语句: 例如: Syst ...

  9. Effective Java笔记一 创建和销毁对象

    Effective Java笔记一 创建和销毁对象 第1条 考虑用静态工厂方法代替构造器 第2条 遇到多个构造器参数时要考虑用构建器 第3条 用私有构造器或者枚举类型强化Singleton属性 第4条 ...

  10. 《MFC游戏开发》笔记六 图像双缓冲技术:实现一个流畅的动画

    本系列文章由七十一雾央编写,转载请注明出处.  http://blog.csdn.net/u011371356/article/details/9334121 作者:七十一雾央 新浪微博:http:/ ...

随机推荐

  1. lstm作的第一首诗,纪念

    黄獐春风见破黛,十道奇昌犹自劳. 开领秦都色偏早,未知长柳是来恩. 争时欲下花木湿,早打红筵枝上香. 酣质矫胶麦已暮,丝窗瑞佩满含龙. 感觉有点意思哈,花木对应枝上,还有点对仗的意味. 于是接着又弄了 ...

  2. ssh登录时不校验被登录机器的方法

    在linux的用户目录下的.ssh文件下,touch config:注意config的权限控制,-rw-r--r--. 配置内容: cat config: Host * StrictHostKeyCh ...

  3. python中a=a+2与a+=2的区别

    1.a=a+2,表示一个新的对象,新的对象名字还是a,但是指向的内存地址已经变了 >>> a=2 >>> id(a) 140406287260016 >> ...

  4. 禁用Clusterware在系统启动后自己主动启动

    以下是禁用及启用Clusterware随系统启动而自己主动启动的方法 10g下我们用例如以下方法: 禁用Clusterware随系统启动而自己主动启动 /etc/init.d/init.crs dis ...

  5. DataSource是什么

    public interface DataSource 该工厂用于提供到此 DataSource 对象表示的物理数据源的连接.作为 DriverManager(二者区别:http://tobylxy. ...

  6. 富文本编辑器 - RichEditor

    基本功能 RichEditor 是一个继承自 WebView 的自己定义 view,枚举类型 Type 定了它所支持的排版格式: public enum Type { BOLD, ITALIC, SU ...

  7. 【BZOJ3566】[SHOI2014]概率充电器 期望+树形DP

    [BZOJ3566][SHOI2014]概率充电器 Description 著名的电子产品品牌 SHOI 刚刚发布了引领世界潮流的下一代电子产品——概率充电器:“采用全新纳米级加工技术,实现元件与导线 ...

  8. scrollify 全屏滚动插件

    使用 1.引入文件 <script src="js/jquery.min.js"> </script> <script src="js/jq ...

  9. flume采集微信小程序数据

    flume采集微信小程序数据 flume收集前端埋点数据[1]POST请求http://f.x.com:50000数据格式: JsonArray数据格式示例:[{ "headers" ...

  10. TCP/IP笔记之OSI和TCP/IP