05IO流总结

IO流

1.流按操作类型分为两种：

• 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的

• 字符流 : 字符流只能操作纯字符数据，比较方便。

• 字节流的抽象父类：

  • InputStream
  • OutputStream

• 字符流的抽象父类：

  • Reader
    Writer

字节流

2.FileInputStream

read()一次读取一个字节
FileInputStream fis = new FileInputStream("aaa.txt");	//创建一个文件输入流对象,并关联aaa.txt
	int b;													//定义变量,记录每次读到的字节
	while((b = fis.read()) != -1) {							//将每次读到的字节赋值给b并判断是否是-1
		System.out.println(b);								//打印每一个字节
	}

is.close();											//关闭流释放资源

3.FileOutputStream

write()一次写出一个字节
//后面加Ture
FileOutputStream fos = new FileOutputStream("bbb.txt",true);	//如果没有bbb.txt,会创建出一个
	//fos.write(97);						//虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
	fos.write(98);
	fos.write(99);
	fos.close();

4.拷贝图片

• FileInputStream读取
• FileOutputStream写出

FileInputStream fis = new FileInputStream("致青春.mp3");	//创建输入流对象,关联a.jpg
FileOutputStream fos = new FileOutputStream("copy.mp3");//创建输出流对象,关联b.jpg
int b;
while((b = fis.read()) != -1) {
	fos.write(b);
}
fis.close();
fos.close();

5.用数组拷贝图片

• write(byte[] b)
• write(byte[] b, int off, int len)写出有效的字节个数

FileInputStream fis = new FileInputStream("致青春.mp3");
FileOutputStream fos = new FileOutputStream("copy.mp3");
int len;
byte[] arr = new byte[1024 * 8];					//自定义字节数组
while((len = fis.read(arr)) != -1) {
	//fos.write(arr);
	fos.write(arr, 0, len);							//写出字节数组写出有效个字节个数
}
fis.close();
fos.close();

6.BufferedInputStream和BufferOutputStream拷贝

缓冲思想

• 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
• 这是加入了数组这样的缓冲区效果，java本身在设计的时候，
• 也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流

FileInputStream fis = new FileInputStream("致青春.mp3");			//创建文件输入流对象,关联致青春.mp3
BufferedInputStream bis = new BufferedInputStream(fis);			//创建缓冲区对fis装饰
FileOutputStream fos = new FileOutputStream("copy.mp3");		//创建输出流对象,关联copy.mp3
BufferedOutputStream bos = new BufferedOutputStream(fos);		//创建缓冲区对fos装饰
int b;
while((b = bis.read()) != -1) {		
	bos.write(b);
}
bis.close();						//只关装饰后的对象即可
bos.close();

7.flush和close方法的区别

• flush()方法
  • 用来刷新缓冲区的,刷新后可以再次写出
• close()方法
  • 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

8.流的标准处理异常代码1.6版本及其以前

try finally嵌套

FileInputStream fis = null;
	FileOutputStream fos = null;
	try {
		fis = new FileInputStream("aaa.txt");
		fos = new FileOutputStream("bbb.txt");
		int b;
		while((b = fis.read()) != -1) {
			fos.write(b);
		}
	} finally {
		try {
			if(fis != null)
				fis.close();
		}finally {
			if(fos != null)
				fos.close();
		}
	}

9.流的标准处理异常代码1.7版本

try close

try(
		FileInputStream fis = new FileInputStream("aaa.txt");
		FileOutputStream fos = new FileOutputStream("bbb.txt");
		MyClose mc = new MyClose();
	){
		int b;
		while((b = fis.read()) != -1) {
			fos.write(b);
		}
	}

• 原理
  • 在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉

10.图片加密

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.jpg"));

int b;
while((b = bis.read()) != -1) {
	bos.write(b ^ 123);
}

bis.close();
bos.close();

字符流

11.字符流的拷贝

FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");

int ch;
while((ch = fr.read()) != -1) {
	fw.write(ch);
}

fr.close();
fw.close();

12.什么情况下使用字符流

• 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.
• 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流

13.自定义字符数组的拷贝

FileReader fr = new FileReader("aaa.txt");			//创建字符输入流,关联aaa.txt

FileWriter fw = new FileWriter("bbb.txt");			//创建字符输出流,关联bbb.txt
int len;
char[] arr = new char[1024*8];						//创建字符数组
while((len = fr.read(arr)) != -1) {					//将数据读到字符数组中
	fw.write(arr, 0, len);							//从字符数组将数据写到文件上
}

fr.close();											//关流释放资源
fw.close();	

14.带缓冲的字符流

• BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区, 然后逐个返回给程序, 降低读取文件的次数, 提高效率
• BufferedWriter的write()方法写出字符时会先写到缓冲区, 缓冲区写满时才会写到文件, 降低写文件的次数, 提高效率

BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));	//创建字符输入流对象,关联aaa.txt

BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));	//创建字符输出流对象,关联bbb.txt

int ch;				
while((ch = br.read()) != -1) {		//read一次,会先将缓冲区读满,从缓冲去中一个一个的返给临时变量ch
	bw.write(ch);					//write一次,是将数据装到字符数组,装满后再一起写出去
}

br.close();							//关流
bw.close();  

15.readLine()和newLine()方法

• BufferedReader的readLine()方法可以读取一行字符(不包含换行符号)
• BufferedWriter的newLine()可以输出一个跨平台的换行符号"\r\n"

BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
	BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
	String line;
	while((line = br.readLine()) != null) {
		bw.write(line);
		//bw.write("\r\n");					//只支持windows系统
		bw.newLine();						//跨平台的
	}
	br.close();
	bw.close(); 

16.LineNumberReader

LineNumberReader是BufferedReader的子类, 具有相同的功能, 并且可以统计行号

• 调用getLineNumber()方法可以获取当前行号
• 调用setLineNumber()方法可以设置当前行号

LineNumberReader lnr = new LineNumberReader(new FileReader("aaa.txt"));
	String line;
	lnr.setLineNumber(100);									//设置行号
	while((line = lnr.readLine()) != null) {
		System.out.println(lnr.getLineNumber() + ":" + line);//获取行号
	}
lnr.close(); 

17.装饰设计模式

interface Coder {
public void code();
}
class Student implements Coder {
	@Override
	public void code() {
		System.out.println("javase");
		System.out.println("javaweb");
	}
}
class ItcastStudent implements Coder {
	private Student s;						//获取到被包装的类的引用
	public ItcastStudent(Student s) {		//通过构造函数创建对象的时候,传入被包装的对象
		this.s = s;
	}
	@Override
	public void code() {					//对其原有功能进行升级
		s.code();
		System.out.println("数据库");
		System.out.println("ssh");
		System.out.println("安卓");
		System.out.println(".....");
	}
} 

18.使用指定的码表读写字符

• FileReader是使用默认码表读取文件, 如果需要使用指定码表读取, 那么可以使用InputStreamReader(字节流,编码表)
• FileWriter是使用默认码表写出文件, 如果需要使用指定码表写出, 那么可以使用OutputStreamWriter(字节流,编码表)

BufferedReader br = 									//高效的用指定的编码表读
			new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt"), "UTF-8"));
	BufferedWriter bw = 									//高效的用指定的编码表写
			new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt"), "GBK"));
	int ch;
	while((ch = br.read()) != -1) {
		bw.write(ch);
	}
	br.close();
	bw.close();	

其他流

19.序列流

1.什么是序列流

• 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.

2.整合两个: SequenceInputStream(InputStream, InputStream)

FileInputStream fis1 = new FileInputStream("a.txt");			//创建输入流对象,关联a.txt
	FileInputStream fis2 = new FileInputStream("b.txt");			//创建输入流对象,关联b.txt
	SequenceInputStream sis = new SequenceInputStream(fis1, fis2);	//将两个流整合成一个流
	FileOutputStream fos = new FileOutputStream("c.txt");			//创建输出流对象,关联c.txt
int b;
while((b = sis.read()) != -1) {									//用整合后的读
	fos.write(b);												//写到指定文件上
}
sis.close();
fos.close(); 

整合多个: SequenceInputStream(Enumeration)

FileInputStream fis1 = new FileInputStream("a.txt");	//创建输入流对象,关联a.txt
	FileInputStream fis2 = new FileInputStream("b.txt");	//创建输入流对象,关联b.txt
	FileInputStream fis3 = new FileInputStream("c.txt");	//创建输入流对象,关联c.txt
	Vector<InputStream> v = new Vector<>();					//创建vector集合对象
	v.add(fis1);											//将流对象添加
	v.add(fis2);
	v.add(fis3);
	Enumeration<InputStream> en = v.elements();				//获取枚举引用
	SequenceInputStream sis = new SequenceInputStream(en);	//传递给SequenceInputStream构造
	FileOutputStream fos = new FileOutputStream("d.txt");
	int b;
	while((b = sis.read()) != -1) {
		fos.write(b);
	}
	sis.close();
	fos.close();

20.对象操作流

1.什么是对象操作流

• 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.

1.ObjectOutputStream类

public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。序列化

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));

    oos.writeObject(new Student("xiao",15,49));

    oos.close();
}

2.ObjectInputStream类

public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。反序列化

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\a.txt"));

    Object o = ois.readObject();
    ois.close();
    System.out.println(o);
    Student o1 = (Student) o;
    System.out.println(" "+o1.getName()+o1.getAge()+o1.getScore());
}

3.反序列化操作

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Student implements Serializable {
    // 加入序列版本号
    private static final long serialVersionUID = 1L;
    public String name;
    private int age;
    private int score;

4.集合练习

22.打印流的概述和特点

public PrintStream(String fileName)： 使用指定的文件名创建一个新的打印流。

public static void main(String[] args) throws FileNotFoundException {
    System.out.println("在控制台打印！");

    PrintStream ps = new PrintStream("D:\\a.txt");
    ps.write(97);//添加
    ps.write(97);
    ps.println(97);//换行
    ps.println('a');
    System.setOut(ps);//改变打印目的地
    System.out.println("在打印流中");
}
文件夹效果：
aa97
a
在打印流中

21.内存输出流

1.什么是内存输出流

• 该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据

2.使用方式

• 创建对象: new ByteArrayOutputStream()
• 写出数据: write(int), write(byte[])
• 获取数据: toByteArray()

FileInputStream fis = new FileInputStream("a.txt");

ByteArrayOutputStream baos = new ByteArrayOutputStream();
	int b;
	while((b = fis.read()) != -1) {
		baos.write(b);
	}	

//byte[] newArr = baos.toByteArray();				//将内存缓冲区中所有的字节存储在newArr中
//System.out.println(new String(newArr));
System.out.println(baos);
fis.close();

22.打印流

public PrintStream(String fileName)： 使用指定的文件名创建一个新的打印流。

public static void main(String[] args) throws FileNotFoundException {
    System.out.println("在控制台打印！");

    PrintStream ps = new PrintStream("D:\\a.txt");
    ps.write(97);//添加
    ps.write(97);
    ps.println(97);
    ps.println('a');
    System.setOut(ps);//改变打印目的地
    System.out.println("在打印流中");
}
文件夹效果：
aa97
a
在打印流中

23.Properties的特殊功能使用

A:Properties的特殊功能

• public Object setProperty(String key,String value)
• public String getProperty(String key)
• public Enumeration stringPropertyNames()

public static void main(String[] args) throws IOException {
    Properties pp = new Properties();
    pp.load(new FileReader("D:\\score.txt"));
    boolean js = false;
    Set<String> strings = pp.stringPropertyNames();
    for (String key : strings) {
        if (key.equals("lisi")) {
            pp.setProperty("lisi", "100");
            pp.store(new FileWriter("D:\\score.txt"), "");
            js = true;
            System.out.println("修改成功");
        }
    }
    if (!js)
        System.out.println("没有找到");
}