黑马程序员——I/O流（一）

——- android培训、java培训、期待与您交流！ ———-

字符流

代码示例：

/*
* 先以操作文件为主来演示
*
* 需求：在硬盘上，创建一个文件并写入一些数据。
*
* 找到一个专门用于操作文件的Writer子类对象。FileWriter。  后缀名是父类名。前缀名是该流对象的功能。
*
*/
import java.io.*;
import java.util.*;

public class Demo {
public static void main(String[] args) throws IOException {
// 创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
// 而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
// 其实该步就是在明确数据要存放的目的地。
FileWriter fw = new FileWriter("demo.txt");// 会抛出IOException异常

// 调用writer方法，将字符串写入到流中。(注意，数据存在流中，还没有存储到demo.txt文件中)
fw.write("abcdef");

// 刷新流对象中的缓冲中的数据
// 将数据刷到目的地中。（数据存储到了demo.txt文件中）
// fw.flush();

// 关闭流资源，但是关闭之前会刷新一次内部缓冲区中的数据。
// 将数据刷到目的地中（将数据存到demo.txt文件中）
// 和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭
fw.close();

}
}

IO流异常处理的规范

/*
* IO异常的处理方式
*/
import java.io.*;
import java.util.*;

public class Demo {
public static void main(String[] args) {
FileWriter fw = null;//fw不能定义在try中，那样会导致fw.close
//无法关闭流，因为定义在try中的fw是局部变量
try {
fw = new FileWriter("Demo.txt");
fw.write("abcdefgh");
} catch (IOException e) {
System.out.println(e.toString());
} finally {
if (fw != null)//如果fw不为空，则关闭流。如果try中的
//fw = new FileWriter("KKK:\\Demo.txt")
//那么会抛出异常(找不到KKK:\这个盘符)，
//当抛出异常后fw值为null，fw为空就不能调用close
try {
fw.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}

}
}

字符流的两种读取方式（读取单个字符、读取字符数组）

代码示例：

/*
* 第一种方式：演示对已有文件的读取，读取单个字符
*/
import java.io.*;
import java.util.*;

public class Demo {
public static void main(String[] args) {
// 创建一个文件读取流对象，和指定名称的文件相关联。
// 要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
FileReader fr = null;
try {
fr = new FileReader("D:\\java\\javaCode\\Demo\\src\\Demo.java");

// 调用读取流对象的read方法
// read()：一次读一个字符。而且会自动往下读，当读取到没有文件时，返回-1

int ch = 0;
while ((ch = fr.read()) != -1) {
System.out.print((char) ch);
}

/*
//这种读取方式也可以，但是比较麻烦
while (true) {
int ch = fr.read();
if (ch == -1)
break;
System.out.println((char) ch);
}
*/
} catch (IOException e) {
System.out.println(e.toString());
} finally {
if (fr != null)
try {
fr.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}

}
}

/*
* 第二种方式：通过字符数组进行读取
*/
import java.io.*;
import java.util.*;

public class Demo {
public static void main(String[] args) {
FileReader fr = null;
try {
fr = new FileReader("D:\\java\\javaCode\\Demo\\src\\Demo.java");

// 定义一个字符数组。用于存储读到的字符。
// 该read(char[])返回的是读到字符个数。
// 数组的大小最好定义成1024的整数倍
char[] chs = new char[1024];

int num = 0;
while ((num = fr.read(chs)) != -1) {// 如果还有数据则继续读取，并存入到字符数组中。如果没有数据则然会-1，则不再执行
System.out.print(new String(chs, 0, num));// 将字符数组转换成字符串的时候，从第一个字符开始转换，一直转换到num则不再转换
//如：一个字符数组长度char[1024]，num的值为5，那么，new String(chs,0,num)只将前5个字符转换成字符串
}

} catch (IOException e) {
System.out.println(e.toString());
} finally {
if (fr != null)
try {
fr.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}

}
}

使用字符流，复制一个文件

/*
* 将D盘一个文本复制到C盘。
*
* 复制的原理：
*      其实就是将D盘下的文件数据存储到C盘的一个文件中。
*
* 步骤：
*      1，在C盘创建一个文件，用于存储D盘文件中的数据。
*      2，定义读取流和D盘文件相关联。
*      3，通过不断的读写完成数据存储。
*      4，关闭资源。
*/
import java.io.*;
import java.util.*;

public class Demo {
public static void main(String[] args) {
// function1();
function2();
}

// 第一种方式：读一个字符存一个字符
public static void function1() {
FileReader fr = null;
FileWriter fw = null;
try {
// 需要读取的文件
fr = new FileReader("D:\\java\\javaCode\\Demo\\src\\Demo.java");
// 在c盘中创建一个文件
fw = new FileWriter("C:\\copyDemo1.txt");

int len = 0;
while ((len = fr.read()) != -1) {
fw.write(len);
}
} catch (IOException e) {
throw new RuntimeException("读取失败");
} finally {
if (fr != null)// 如果fr已经创建了对象，则关闭流
try {
fr.close();
} catch (IOException e) {
throw new RuntimeException("读取失败");
}
if (fw != null)// 如果fw已经创建了对象，则关闭流
try {
fw.close();
} catch (IOException e) {
throw new RuntimeException("读取失败");
}
}
}

// 第二种方式：通过字符数组进行读取
public static void function2() {
// 要读取的文件
FileReader fr = null;
// 在c盘中创建一个文件
FileWriter fw = null;
try {
fr = new FileReader("D:\\java\\javaCode\\Demo\\src\\Demo.java");
fw = new FileWriter("C:\\copyDemo2.txt");

char[] chs = new char[1024];
int len = 0;
while ((len = fr.read(chs)) != -1) {
fw.write(chs, 0, len);// 装入的字符数为chs数组中的字符个数，这样节省内存空间
}

} catch (IOException e) {
throw new RuntimeException("读取失败");
} finally {
if (fr != null)// 如果fr已经创建了对象，则关闭流
try {
fr.close();
} catch (IOException e) {
throw new RuntimeException("关闭FileReader流失败");
}
if (fw != null)// 如果fw已经创建了对象，则关闭流
try {
fw.close();
} catch (IOException e) {
throw new RuntimeException("关闭FileWriter流失败");
}
}
}
}

字符读取流缓冲区

缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须先有流对象。

该缓冲区提供了一次读一行的方法 readline，方便于对文本数据的获取。

当返回null时，表示读到文件末尾

readLine方法返回的时候，只返回回车符之前的数据内容。并不返回回车符。

代码示例：

import java.io.*;
import java.util.*;
public class Demo {
public static void main(String[] args) throws IOException{
//创建一个读取流对象和文件相关联
FileReader fr = new FileReader("D:\\java\\javaCode\\Demo\\src\\Demo.java");

//为了提高字符写入流效率。加入了缓冲技术。将字符读取流对象作为参数，传递给缓冲对象的构造函数
BufferedReader bufr = new BufferedReader(fr);

String line = null;
while((line=bufr.readLine())!=null){
print(line);
}

bufr.close();
}
public static void print(Object obj){
System.out.println(obj);
}
}

模拟BufferedReader类中特有方法readLine

/*
* 练习：
*      模拟BufferedReader类中特有方法readLine。
*
*          明白了BufferedReader类中特有方法readLine的原理后，
*          可以自定义一个类中包含一个功能和readLine一致的方法。
*          来模拟一下BufferedReader
*
*   本示例中采用了装饰设计模式
*/
import java.io.*;
import java.util.*;

class MyBufferedReader extends Reader{
private Reader r;

public MyBufferedReader(Reader r) {
this.r = r;
}

// 可以一次读一行数据得到方法
public String myReadLine() throws IOException {

// 定义一个临时容器。原BufferedReader封装的是字符数组。
// 为了方便演示。定义一个StringBuilder容器。因为最终还是要将数据变成字符串
StringBuilder sb = new StringBuilder();
int ch = 0;
while ((ch = r.read()) != -1) {
if ((char) ch == '\r') {
continue;
}
if ((char) ch == '\n') {//  读取到换行\n时，才往回返
return sb.toString();
} else
sb.append((char) ch);
}
if(sb.length()!=0)//如果容器中还存在元素，则返回元素。例如：当读取的某行字符串没有换行\n时，那么就读取不到换行符，导致没有返回那一行数据，
//而此处做判断就是为了返回没有换行的字符串
return sb.toString();
return null;
}
public void myClose() throws IOException{
r.close();
}

//覆盖Reader类中的抽象方法
public int read(char[] cbuf, int off, int len) throws IOException {
return r.read(cbuf,off, len);
}

//覆盖Reader类中的抽象方法
public void close() throws IOException {
r.close();
}
}

public class Demo {
public static void main(String[] args) throws IOException {
MyBufferedReader bufr = new MyBufferedReader(new FileReader("D:\\java\\javaCode\\Demo\\src\\Demo.java"));
String line = null;
while((line = bufr.myReadLine())!=null){
print(line);
}
bufr.myClose();
}

public static void print(Object obj) {
System.out.println(obj);
}
}

装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有对象的功能，并提供加强功能。即，自定义的类称为装饰类。

装饰类通常会通过构造方法接收被装饰类的对象。并基于被装饰的对象的功能，提供更强更全的功能。

装饰类因为增强已有对象，具备的功能和已有对象的功能是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

装饰类比继承灵活，避免了继承体系的臃肿，并降低了类与类之间的关系

代码示例：

/*
* 装饰设计模式：
*      当想要对已有的对象进行功能增强时，
*      可以定义类，将已有对象传入，基于已有对象的功能，并提供加强功能。
*      那么自定义的该类称为装饰类
*
* 装饰类通常会通过构造方法接收被装饰的对象。
* 并基于被装饰对象的功能，提供更强的功能
*/
import java.io.*;

class Person {
public void chiFan() {
System.out.println("吃饭");
}
}

class SuperPerson extends Person{//继承Person是因为是因为该类中的功能和Person中的功能是相同的。只不过提供了更强的功能。  如superChifan方法

private Person p;

public
121f2
SuperPerson(Person p) {
this.p = p;
}

public void superChiFan() {//提供增强的吃饭功能
System.out.println("开胃酒");
p.chiFan();
System.out.println("甜点");
System.out.println("抽根烟");
}
}

public class Demo {
public static void main(String[] args) throws IOException {
Person p = new Person();
// p.chifan();
SuperPerson sp = new SuperPerson(p);
sp.superChiFan();
}
}

自定义LineNumberReader对象

/*
使用装饰模式模拟LineNumberReader中的readLine原理
*/

import java.io.*;
import java.util.*;

class MyLineNumberReader extends MyBufferedReader{
private int lineNumber;
public MyLineNumberReader(Reader r) {
super(r);
}

public String myReadLine() throws IOException {
lineNumber++;
return super.myReadLine();
}

public void setLineNumber(int lineNumber) {
this.lineNumber = lineNumber;
}

public int getLineNumber() {
return lineNumber;
}
}

class MyBufferedReader extends Reader{
private Reader r;

public MyBufferedReader(Reader r) {
this.r = r;
}

// 可以一次读一行数据得到方法
public String myReadLine() throws IOException {

// 定义一个临时容器。原BufferedReader封装的是字符数组。
// 为了方便演示。定义一个StringBuilder容器。因为最终还是要将数据变成字符串
StringBuilder sb = new StringBuilder();
int ch = 0;
while ((ch = r.read()) != -1) {
if ((char) ch == '\r') {
continue;
}
if ((char) ch == '\n') {
return sb.toString();
} else
sb.append((char) ch);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
public void myClose() throws IOException{
r.close();
}

/*
覆盖Reader类中的抽象方法
*/
public int read(char[] cbuf, int off, int len) throws IOException {
return r.read(cbuf,off, len);
}

public void close() throws IOException {
r.close();
}
}

public class Demo {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader(
"D:\\java\\javaCode\\Demo\\src\\Demo.java");
MyLineNumberReader mlnr = new MyLineNumberReader(fr);
String line = null;
mlnr.setLineNumber(100);
while ((line = mlnr.myReadLine()) != null) {
print(mlnr.getLineNumber()+"::"+line);
}
}

public static void print(Object obj) {
System.out.println(obj);
}
}

字节流：

代码示例：

/*
* 字节流的方法使用
*/
import java.io.*;
import java.util.*;
public class Demo {
public static void main(String[] args) throws IOException {
//      writeFile();
//      readFile_1();
//      readFile_2();
readFile_3();
}

//使用字节数组的方式，读取Demo.java文件中的内容，并打印到控制台。这时字节数组长度正好是Demo.java文件的长度
public static void readFile_3() throws IOException{
FileInputStream fis = new FileInputStream("D:\\java\\javaCode\\Demo\\src\\Demo.java");

//      int len = fis.available();
byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不再用循环了
fis.read(buf);
print(new String(buf));
fis.close();
}

//读取Demo.java文件中的内容，并打印到控制台。使用字节数组的方式读
public static void readFile_2() throws IOException{
FileInputStream fis = new FileInputStream("D:\\java\\javaCode\\Demo\\src\\Demo.java");

byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1){
print(new String(buf, 0, len));
}
fis.close();
}

//读取Demo.java文件中的内容，并打印到控制台。读一个打印一个
public static void readFile_1() throws IOException{
FileInputStream fis = new FileInputStream("D:\\java\\javaCode\\Demo\\src\\Demo.java");
int ch = 0;
while((ch=fis.read())!=-1){
System.out.print((char)ch);
}
fis.close();
}

//往demo.txt文件中写入abcdef
public static void writeFile() throws IOException{
FileOutputStream fos = new FileOutputStream("demo.txt");
fos.write("abcdef".getBytes());//将字符串变成字节数组
fos.close();

}

public static void print(Object obj) {
System.out.println(obj);
}
}

演示字节流缓冲区复制一个图片

/*
* 通过缓冲区，演示图片的复制。
*
* BufferedOutputStream
* BufferedInputStream
*/
import java.io.*;
import java.util.*;

public class Demo {
public static void main(String[] args)throws IOException{
long start = System.currentTimeMillis();
copy();
long end = System.currentTimeMillis();
print(end - start);

}

//通过字节流的缓冲区完成复制
public static void copy()throws IOException{
BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("C:\\1.png"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("C:\\2.png"));

int len = 0;

while((len = bufis.read())!=-1){
bufos.write(len);
}

bufos.close();
bufis.close();
}

public static void print(Object obj) {
System.out.println(obj);
}
}

自定义BuffreaderInputStream类

代码示例：

/*
* 模拟BuffreaderInputStream，
* 定义一个自己的MyBufferedInputStream
*/
import java.io.*;
import java.util.*;

class MyBufferedInputStream {
private FileInputStream fis;
private byte[] buf = new byte[1024];
private int count = 0, index = 0;

public MyBufferedInputStream(FileInputStream fis) {
this.fis = fis;
}

//一次读一个字节，从缓冲区（字节数组）获取
public int myRead() throws IOException {

if (count == 0) {

//通过fis对象读取硬盘上数据，存储到bs中
count = fis.read(buf);//抓一批数据存入byte数组
if (count < 0)
return -1;
index = 0;
byte b = buf[index];  //获取数组中角标为index的数值
count--;
index++;
return b&255;  //返回角标为index的字节码。
/*
由于返回值类型是int,byte提升为int，如：byte类型的的负一11111111提升为int类型 还是负一 等于11111111-11111111-11111111-11111111，
这样导致int类型的值是-1，最终导致一开始读取数据时，就读到了-1。而导致没有成功写入文件。
我们希望得到int的值是00000000-00000000-00000000-11111111，
这样数据才不会有错误，所以在byte提升为int之前，先 & 11111111。既:b&255。这样才可以得到我们所希望的值
*/
} else if(count>0){
byte b = buf[index];
count--;
index++;
return b&255;
}
return -1;
}
public void myClose() throws IOException{
fis.close();
}
}

public class Demo {
public static void main(String[] args) throws IOException {
MyBufferedInputStream mbis = new MyBufferedInputStream(new FileInputStream("d:\\2.png"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\1.png"));
int by = 0;
while((by=mbis.myRead())!=-1){
bos.write(by);
}
bos.close();
mbis.myClose();
}

public static void print(Object obj) {
System.out.println(obj);
}
}

键盘录入

System.in:对应的标准输入设备：键盘。

System.out:对应的标准输出设备：控制台。

System.in:属于InputStream类型

System.out:属于OutputStream类型

代码示例：

import java.io.*;
import java.util.*;

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 str = null;
while((str = bufr.readLine())!= null){
if(str.equals("over"))
break;
print(str.toUpperCase());
}
}

public static void print(Object obj) {
System.out.println(obj);
}
}

/*
* System.out:对应的标准输出设备：控制台。
* System.in:对应的标准输入设备：键盘。
*
* 将标准输入设备和输出设备，转换成字符流，
* 并将输入的结果打印在控制台上，直到输入over时，
* 才结束输入
*
*/
import java.io.*;
import java.util.*;

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);
//键盘的最常见写法
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//将标准输入设备转换成字符流

//      OutputStream os = System.out;
//      OutputStreamWriter osw = new OutputStreamWriter(os);
//      BufferedWriter bufw = new BufferedWriter(osw);

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));//将标准输出设备转换成字符流

String str = null;
while((str = bufr.readLine())!= null){
if(str.equals("over"))
break;
bufw.write(str.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufw.close();

}

public static void print(Object obj) {
System.out.println(obj);
}
}

操作流的基本规律

流操作的基本规律：

通过三个明确来完成。

1，明确源和目的。

源：输入流。InputStream Reader

目的：输出流。OutputStream Writer

2，明确操作的数据是否是纯文本

是：字符流

不是：字节流

3，当体系明确后，再明确要使用哪个具体的对象。

通过设备来进行区分：

源设备：内存、硬盘、键盘。

目的设备：内存、硬盘、控制台。

代码示例：

/*
扩展：想把录入的数据按照指定的编码表(UTF-8)，将数据存储到文件中

目的：
OutPutStream    Writer

明确是不是操作文本文件：是！Writer。

明确设备：硬盘，一个文件。使用FileWriter
但是FileWriter是使用默认编码表。GBK

但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
所以需要用到的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且是可以操作文本的字节输出流。FileOutputStream

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

需要提高效率吗？需要！BufferedWriter
BufferedWriter bufw = new BufferedWriter(osw);

所以记住，转换流什么时候使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，需要用到转换流
*/
import java.io.*;
import java.util.*;
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(new FileOutputStream("demo.txt"), "UTF-8"));

String line = null;
while ((line = bufr.readLine()) != null) {//当输入"你好"时，utf-8编码产生的文件中，一个字符占3个字节（"你好"共6字节）。
//如果将编码改为GBK，那么一个字符占2个字节("你好"共4个字节)。
//使用FileInputStream方法是无法直接读取utf-8编码中"你好"的，因为默认的是GBK编码，无法读取utf-8编码。
//需要使用转换流，将FileInputStream也指定为utf-8才可以读取
if (line.equals("over"))
break;
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}

public static void print(Object obj) {
System.out.println(obj);
}
}

改变默认输入输出设备

/*

改变标准输入输出设备
System.setIn(InputStream in);
System.setOut(PrintStream out);

*/

import java.io.*;
import java.util.*;
public class Demo {
public static void main(String[] args) throws IOException {
//修改输入设备。默认的输入设备是键盘，现在改为一个文件。相当于读取文件中的内容
System.setIn(new FileInputStream("D:\\java\\javaCode\\Demo\\src\\Demo.java"));
//修改输出设备。默认的输出设备是控制台，现在改为一个文件。平时是输出到控制台，现在是输出到一个txt文件中
System.setOut(new PrintStream("demo.txt"));

//键盘输入最常见的写法。因为默认的输入设备改为了一个文件，所以此处相当于读取一个文件中的内容
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//输出到控制台中。但是因为默认输出设备修改为输出到一个文件中，所以输出的结果会保留在demo.txt文件中
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

String line = null;
while ((line = bufr.readLine()) != null) {
if (line.equals("over"))
break;
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}

异常日记

/*
* 将异常的日记信息。既：把异常给存放到一个文件中
*/
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

public class Demo {
public static void main(String[] args) throws IOException {
try {
int[] arr = new int[3];
arr[3] = 3;
} catch (Exception e) {
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
String str = sdf.format(date);

PrintStream ps = new PrintStream("D:\\haha.txt");//要打印到haha.txt文件中

System.setOut(ps);//将默认的输出设备(控制台)改为一个haha.txt文件

System.out.println(str);//输出语句，结果不是输出到控制台，而是输出到haha.txt文件中

e.printStackTrace(ps);//方法接收的参数为：printStackTrace(PrintStream)
}
}
}

/*
有专门弄日记信息的软件：log4j
*/