黑马程序员---java基础---5IO流

最新推荐文章于 2022-02-20 23:23:01 发布

简a零度

最新推荐文章于 2022-02-20 23:23:01 发布

阅读量724

点赞数

本文链接：https://blog.csdn.net/u012421922/article/details/17788475

版权

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

IO流

(1)IO流的分类：

A:流向

输入流读取数据

输出流写入数据

B:数据

字节流

字符流

如果别人没有问你是按照什么类型来划分IO流，一般指的都是按数据分。

什么时候使用字符流?

如果用记事本打开文件，数据是可以被读懂的，就可以用字符流。

否则，全部使用字节流。

(2)IO流的抽象基类：

字节流：

输入流 InputStream

输出流 OutputStream

字符流：

输入流 Reader

输出流 Writer

(3)IO流体系：

字节流：

输入流 InputStream

FileInputStream

输出流 OutputStream

FileOutputStream

字符流：

输入流 Reader

FileReader

输出流 Writer

FileWriter

(4)字符流FileWriter

操作步骤：

A:创建字符输出流对象

B:调用write方法

C:关闭流

FileWriter fw = new FileWriter("fw.txt");

fw.write("hello,IO");

fw.flush();

fw.close();

问题：

A:创建字符输出流对象做了几件事情?

三件。A:创建了字符输出流对象

B:调用了系统功能创建了文件

C:把字符流对象指向这个文件

B:为什么需要刷新流?

刷新该流的缓冲。

C:为什么需要关闭流?

A:告诉jvm，fw对象是一个垃圾了。

B:通知系统，去释放跟该资源相关的内容。

D:刷新和关闭的区别是什么?

A:close():先刷新缓冲区，在关闭流。流对象不可以继续使用。

B:flush:刷新缓冲区，流对象还可以继续使用。

E:如何实现数据的换行?

FileWriter写数据，如何换行呢?

不同的系统，换行符号不一样。

windows系统：\r\n

linux系统：\n

mac系统：\r

不同的软件，针对换行的识别不同。

F:如何实现数据的追加写入?

使用带两个参数的构造方法：

* FileWriter(String fileName, boolean append)

(5)字符流FileReader

操作步骤：

A:创建字符输入流对象

B:调用read方法

C:关闭流

FileReader fr = new FileReader("fw.txt");

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

			//方式2
			char[] chs = new char[1024];
			int len = 0;
			while((len=fr.read(chs))!=-1)
			{
				System.out.print(new String(chs,0,len));
			}

			fr.close();

问题：

可不可以两种读取方式同时写?

不可以，除非重写再创建一次。

public class Demo1 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	FileReader fr=new FileReader("d:\\a.txt");
	//目的源，写入文件对象
	FileWriter fw=new FileWriter("e:\\b.txt");
	//定义字符
	 int ch=0;
	 //判断，不等于-1就读取
	 while((ch=fr.read())!=-1){
	 //复制，写入
		 fw.write(ch);
	 }
	####这里重写创建一次 FileWriter fw=new FileWriter("e:\\b.txt");
	//定义字符数组
	 char[] chs=new char[1024];
	 //定义长度
	 int len=0;
	 //长度不等于-1就读写
	 while((len=fr.read(chs))!=-1){
	 //复制，写入
		 fw.write(chs,0,len);
	 }
	 //关闭流
	fr.close();
	fw.close();
}
}

1:字符流复制文本文件

A:基本流

FileReader

int read():一次读取一个字符

int read(char[] chs):一次读取一个字符数组

FileWriter:

write(int ch):一次写一个字符

write(char[] chs ,int index, int len):一次写一个字符数组的一部分

B:高效流

BufferedReader

int read():一次读取一个字符

int read(char[] chs):一次读取一个字符数组

特殊：

String readLine():一次读取一行数据

BufferedWriter:

write(int ch):一次写一个字符

write(char[] chs ,int index, int len):一次写一个字符数组的一部分

特殊：

newLine():写一个换行符

		需求：把c盘目录下a.txt复制到d盘目录下b.txt
1.package cn.itcast;

//导包
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo1 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	FileReader fr=new FileReader("d:\\a.txt");
	//目的源，写入文件对象
	FileWriter fw=new FileWriter("e:\\b.txt");
	//定义字符
	 int ch=0;
	 //判断，不等于-1就读取
	 while((ch=fr.read())!=-1){
	 //复制，写入
		 fw.write(ch);
	 }
	 //关闭流
	fr.close();
	fw.close();
}
}
2.package cn.itcast;

//导包
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo1 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	FileReader fr=new FileReader("d:\\a.txt");
	//目的源，写入文件对象
	FileWriter fw=new FileWriter("e:\\b.txt");
	//定义字符数组
	 char[] chs=new char[1024];
	 //定义长度
	 int len=0;
	 //长度不等于-1就读写
	 while((len=fr.read(chs))!=-1){
	 //复制，写入
		 fw.write(chs,0,len);
	 }
	  //关闭流
	fr.close();
	fw.close();
}
}
3.
//导包
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;



public class Demo1 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	BufferedReader br=new BufferedReader(new FileReader("d:\\a.txt"));
	//目的源，写入文件对象
	BufferedWriter bw=new  BufferedWriter(new FileWriter("e:\\b.txt"));
	//定义一个字符
	 int ch=0;
	 //判断字符不等于-1时就读取
	 while((ch=br.read())!=-1){
	 //复制，写入
		 bw.write(ch);
	 }
	  //关闭流
	br.close();
	bw.close();
}
}
4.package cn.itcast;
//导包
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;



public class Demo1 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	BufferedReader br=new BufferedReader(new FileReader("d:\\a.txt"));
	//目的源，写入文件对象
	BufferedWriter bw=new  BufferedWriter(new FileWriter("e:\\b.txt"));
	//定义字符数组
	char[] chs=new char[1024];
	//定义数组长度
	 int len=0;
	 //判断
	 while((len=br.read(chs))!=-1){
		 bw.write(chs,0,len);
	 }
	  //关闭流
	br.close();
	bw.close();
}
}
5.package cn.itcast;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;




public class Demo1 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	BufferedReader br=new BufferedReader(new FileReader("d:\\a.txt"));
	//目的源，写入文件对象
	BufferedWriter bw=new  BufferedWriter(new FileWriter("e:\\b.txt"));
	 String line=null;
	 while((line=br.readLine())!=null){
		 bw.write(line);
	 }
	  //关闭流
	br.close();
	bw.close();
}
}


2:字节流复制二进制文件(掌握)
	A:基本流
		FileInputStream:
			int read():一次读取一个字节
			int read(byte[] bys):一次读取一个字节数组

		FileOutputStream:
			write(int by):一次写一个字节
			write(byte[] bys,int index,int len):一次写一个字节数组
	B:高效流
		BufferedInputStream:
			int read():一次读取一个字节
			int read(byte[] bys):一次读取一个字节数组

		BufferedOutputStream:
			write(int by):一次写一个字节
			write(byte[] bys,int index,int len):一次写一个字节数组
	
	C:请把四种都练习一遍。
		需求：把c盘目录下a.mp3复制到d盘目录下b.mp3
1.package cn.itcast;
//导包
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo2 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	FileInputStream fis=new FileInputStream("d:\\a.mp4");
	//目的源，写入文件对象
	FileOutputStream fos=new FileOutputStream("e:\\b.mp4");
	//定义字节
	int by=0;
	//判断
	while((by=fis.read())!=-1){
		fos.write((char)by);
	}
	 //关闭流
	fos.close();
	fis.close();
}
}
2.package cn.itcast;
//导包
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo2 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	FileInputStream fis=new FileInputStream("d:\\a.mp4");
	//目的源，写入文件对象
	FileOutputStream fos=new FileOutputStream("e:\\b.mp4");
	//定义字节数组
	byte[] bys = new byte[1024];
	int len = 0;
	//判断
	while((len=fis.read(bys))!=-1){
		System.out.print(new String(bys,0,len));
	}
	 //关闭流
	fos.close();
	fis.close();
}
}
3.package cn.itcast;
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;



public class Demo2 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	BufferedInputStream bis=new BufferedInputStream(new FileInputStream("d:\\a.mp4"));
	//目的源，写入文件对象
	BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("e:\\b.mp4"));
	//定义字节
	int by=0;
	//判断
	while((by=bis.read())!=-1){
	bos.write(by);
	}
	 //关闭流
	bos.close();
	bis.close();
}
}
4package cn.itcast;
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;



public class Demo2 {
public static void main(String[] args) throws IOException {
	//开始源，读取源文件对象
	BufferedInputStream bis=new BufferedInputStream(new FileInputStream("d:\\a.mp4"));
	//目的源，写入文件对象
	BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("e:\\b.mp4"));
	//定义字节数组
	byte[] bys=new byte[1024];
	int len=0;
	//判断
	while((len=bis.read(bys))!=-1){
	bos.write(bys,0,len);
	}
	 //关闭流
	bos.close();
	bis.close();
}
}




  package cn.javastudy.day1117.homework;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
public class CopyFolder2 {
	/**
	 * 数据源：d:\\张三
	 * 目的地： e:\\李四
	 * 
	 * 需求：将数据源复制到目的地，并将数据源下所有的以.java结尾的文件全都换成以.jad结尾
	 * 
	 * 分析：
	 *  1.创建数据源
	 *  2.获取所有包含文件和文件夹的file数组
	 *  3.遍历数组，判断数组元素是不是文件
	 *  4.复制、改名
	 *   4.1先复制，后改名
	 *   4.2先改名，后复制
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		baseCode();

	}

	private static void baseCode() throws IOException {
		//创建文件对象
		File file1=new File("d:\\张三");
		
		//获取满足以.java结尾的文件数组
		File[] arrayFile=file1.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				return new File(dir, name).isFile() && name.endsWith(".java");
			}
		});
		
		//创建目的地文件夹对象
		File file2=new File("e:\\李四");
		if (!file2.exists()) {
			file2.mkdir();
		}
		
		//遍历数组
		for (File f1 : arrayFile) {
			//获取s数据源文件的名字
			String name=f1.getName();
			//改数据源名
			String newname=name.replace(".java", ".jad");
			
			//替换
			File ff1=new File(file1,newname);
			
			f1.renameTo(ff1);
			
			
			
			
			
			//创建数据源
			BufferedReader br=new BufferedReader(new FileReader(ff1));
			
			//创建目的地
			BufferedWriter bw=new BufferedWriter(new FileWriter(new File(file2,newname)));
			
			//读写操作
			String line=null;
			while((line=br.readLine())!=null){
				
				bw.write(line);
				bw.newLine();
				bw.flush();
				
			}
			
			bw.close();
			br.close();
			
		}
			
	}
}

打印流

(1)打印流分为字节打印流和字符打印流。PrintStream,PrintWriter

(2)打印流的特点:

A:可以打印任意类型的数据。

B:如果启动了自动刷新,在使用println,format,printf这几个方法的时候，会自动刷新。

并换行。

C:打印流是可以直接操作文件的。

哪些流对象是可以直接操作文件?

看其构造方法，如果同时有File和String类型的参数，那么该流对象就是可以直接操作文件的。

	看其构造方法，如果同时有File和String类型的参数，那么该流对象就是可以直接操作文件的。
	(3)案例：复制文本文件。
		需求：把项目路径下的HelloWorld.java复制到项目路径下Copy.java中

		BufferedReader br = new BufferedReader(new FileReader("HelloWorld.java"));
		PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"),true);

		String line = null;
		while((line=br.readLine())!=null)
		{
			pw.println(line);
		}

		pw.close();
		br.close();

2:序列化流

(1)为了把对象写入文本文件，或者在网络中传输，就必须实现序列化接口。

这个接口是一个标记接口，不需要实现任何方法。

(2)序列化流对象

ObjectInputStream:

Object readObject()

ObjectOutputStream:

void writeObject(Object obj)

(3)如何使用?

如果你看到了某个类实现了序列化接口，那么该类的对象就可以被序列化流操作，

也可以在网络中传输，并且，你还应该知道点击鼠标给出序列化id值，就可以解决

黄色警告线问题。

(4)什么是序列化?什么是反序列化?(面试题)

序列化:把对象按照流写入文件或者在网络中传输

反序列化:把文件中或者网络中传输的序列化数据还原成对象

3:Properties

(1)是Map集合，它的父亲是Hashtable。键和值都是字符串。而且可以和IO流结合。

(2)特殊功能：

String getProperty(String key)

Object setProperty(String key, String value)

Set<String> stringPropertyNames()

(3)和IO流集合的功能：

load():把文件中的键值对数据加载到Properties集合中

store():把Properties集合中的数据写入到文本文件

(4)案例：

查找user.txt中是否有键为lisi的，如果有，则修改其值为20

4:转换流

(1)字符流 = 字节流 + 编码表

(2)标准的流

输入流：System.in

输出流：System.out

(3)转换流的使用?

有些时候，我们可能需要把字节流转换成字符流使用，因为想使用特殊功能readLine()。

有些时候，我们也可能把字符数据写到控制台，也就是从字符流到字节流。

所以，java就提供了相应的转换流。

基本格式：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));