字符流,打印流的讲解及使用

最新推荐文章于 2022-05-20 13:57:02 发布

骑恐龙去钓鱼

最新推荐文章于 2022-05-20 13:57:02 发布

阅读量481

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_45018290/article/details/107606310

版权

字符流

字符流:只能操作文本文件,其他类型文件,不能操作.局限性很大
JDK中的字符流:字节流+编码表组成而来的

Writer：所以字符输出流的父类

只能写入文本文件
方法都是write
。write(int c)写入单个字符
。write(char[] ch)写入字符数组
。write(char[] ch,int off,int len)写入字节数组的一部分
。write(String str)写入字符串

转换流

OutputStreamWriter转换流，继承Writer，也是字符的输出流
转换:字符流通向字节流的桥梁,字符流转成字节流
字符:查询指定的编码表，变成字节，传递到字节流中

OutputStreamWriter类构造方法
。OutputStreamWriter( OutpUtStream out)传递字节输出流，使用系统默认编码表GBK
。OutputStreamWriter(OutputStream out,String charsetName)传递字节输出流，指定编码表
注意:字符流写入数据,查询编码表,查询完了就完了
。查询编码表后的字节,写入到文件去:方法flush()

public static void main(String[] args) throws IOException{
	writeGBK();
}
/*
*系统默认的编码表GBK
*创建转换流对象,构造方法传递字节输出流
*/
public static void writeGBK() throws IOException{
	//创建转换流对象,构造方法传递字节输出流
	OutputStreamWriter osw =
	new OutputStreamWriter(new FileOutputStream(" gbk.txt"));
	//写入字符串.
	osw. write("你好");
	osw. flush();
	osw.close();
}
/*
*指定的编码表UTF-8
*创建转换流对象,构造方法传递字节输出流,传递编码表名字
*/
public static void writeUTF() throws IOException{
	//创建转换流对象,构造方法传递字节输出流,传递编码表名字
	OutputStreamWriter osw =
	new OutputStreamWriter(new FileOutputStream( "utf.txt"), "utf-8");
	//写入字符串.
	osw. write("你好");
	osw. flush();
	osw.close();
}

Reader：所以字符输入流的父类

只能读取文本文件
方法都是read，读取到文件末尾返回 -1
。int read(int c)读取单个字符
。read(char[] ch)读取字符数组，返回读取到的字符个数;读取到文件末尾返回-1

转换流

InputStreamReader转换流,继承Reader,也是字符的输入流
转换：InputStreamReader是字节流，通向字符流的桥梁，字节转成字符
字符:根据读取的字节,查询编码表转成字符

InputStreamReader构造方法
。InputStreamReader(InputStream in)传递任意字节输入流，系统默认的编码表GBK
。InputStreamReader(InputStream in,String charsetName)传递任意字节输入流，指定编码表

/*
*转换流: InputStreamReader
*读取文本文件，默认的编码表,和指定的编码表
*/
public static void main(String[] args) throws IOException{
	readGBK();
	readUTF();
}
/*
*系统默认的编码表GBK
*创建转换流对象,传递字节输入流
*/
public static void readGBK() throws IOException{
	//创建转换流对象,传递字节输入流
	InputStreamReader isr =
	new InputStreamReader(new FileInputStream("gbk . txt"));
	//读取字符数组
	char[] chs = new char[1024];
	//int变量,保存read()方法的返回值
	int len=0;
	while( (len = isr.read(chs)) !=-1) {
		System. out. println(new String(chs,0,len ) ) ;
	}
	isr. close();
}
/*
*指定编码表UTF-8
*创建转换流对象,传递字节输入流,传递编码表名字
*/
public static void readUTF() throws IOException{
	//创建转换流对象,传递字节输入流，传递编码表
	InputStreamReader isr =
	new InputStreamReader(new FileInputStream("utf. txt"), "UTF-8");
	//读取字符数组
	char[] chs = new char[1024] ;
	//int变量,保存read()方法的返回值
	int len=0;
	while( (len = isr.read(chs)) !=-1) {
		System. out. print1n(new String(chs,B,len ));
	}
	isr. close();
}

FileWriter

写入字符文件的便捷类
FileWriter继承OutputStreamWriter，继承Writer
方便之处，FileWriter类只能使用系统默认的编码表
FileWriter类构造方法：

FileWriter(File file)传递File对象
FileWriter(File file,boolean append)，传递File对象，传递的是true，文件追写
FileWriter(String filename)，传递字符串文件名
FileWriter(String filename,boolean append)，传递字符串文件名

/*
*字符输出流的便捷类,写入数据
*编码表固定,系统默认的
*/
public static void main(String[] args) throws IOException {
	//创建便捷类对象，构造方法传递字符串文件名.
	FileWriter fw = new FileWriter("abc.txt" );
	//写入单个字符
	fw. write(97);
	//字符流写入数据,需要刷新的
	fw. flush();
	//写入字符数组
	char[] ch ="你好,我的程序世界OK" . toCharArray( ) ;
	fw. write(ch);
	fw. flush();
	//写入数组一部分
	fw.write(ch, 2, 3);
	fw. flush();
	//写入字符串
	fw. write("写字符串hehe,嘻嘻");
	fw. flush();
	fw. close();
}

字符输出流的方法flush)和close()区别
。flush() 刷新该流的缓冲,数据从内存刷新到目的文件
。close()关闭流, 关闭之前刷新
。flush() 方法，刷新后，流对象可以继续使用
。close()关闭流也刷新,但是流对象,不能在使用

FileReader

读取字符文件的便捷类
FileReader继承InputStreamReader继承Reader
方便之处，FileReader类只能使用系统默认的编码表
FileReader构造方法

FileReader(File file)传递File类型对象
FileReader(String filename)传递字符串的文件名

/*
*字符输入出流的便捷类,读取数据
*编码表固定,系统默认的
*/
public static void main(String[] args) throws I0Exception{
	// 创建便捷类对象,构造方法传递文件名
	FileReader fr = new FileReader("abc . txt" );
	//变量,保存read()方法的返回值
	int len = 0;
	char[] chs=new char[1024];
	while( (len = fr.read(chs)) !=-1) {
		System. out . print(new SString(chs,0,len);
	}
	fr. close();
}

字符流子类父类的区别

字符输出流
。OutputStreamWriter父类：写入文本文件的时候：指定编码表
。FileWriter子类：写入文本文件的时候，编码表只能使用系统默认的
字符输入流
。InputStreamReader父类：读取文本文件的时候：指定编码表
。FileReader子类：读取文本文件的时候，编码表只能使用系统默认的
字符流应用，一直就是系统默认编码，建议使用子类，需要自己指定，只能使用父类

字符流的缓冲流

BufferedWriter字符输出流的缓冲区流

BufferedWriter类继承Writer，本身也是字符的输出流
对字符，数组，或者是字符串的高效写入
字符输出流缓冲流的最重要的功能

void newLine()写入换行符号
。自己手动使用\r\n实现换行，不推荐使用
。推荐使用newLine()方法，具有平台无关性
。Windows系统换行\r\n,Linex系统换行\n，Max系统换行\r
BufferedWrite类的构造方法
BufferedWriterWriter W)传递任意的字符输出流，传递哪个流，就高效哪个流
。两个选择：FileWriter OutputStreamWriter

/*
*字符输出流的缓冲流,写入文本文件
*写入换行
*/
public static void main(String[] args )throws IOException {
	//创建字符输出流,绑定文件
	FileWriter fw = new FileWriter( "buffer . txt");
	//创建字符输出流的缓冲流,构造方法传递字符输出流
	BufferedWriter bfw =new BufferedWriter(fw);
	bfw. write("第一行");
	//缓冲流对象的方法newLine()换行
	bfw. newLine( );
	bfw. write("第二行");
	bfw. newLine( );
	bfw. write("第三行");
	bfw. close();
}

BufferedReader字符输入流的缓冲区流

BufferedReader类继承Reader,本身是字符输入流
实现字符,数组，行的高效读取
字符输出流缓冲流的最重要的功能

String readLine()读取文本一行，返回字符串
BufferedReader类构造方法
BufferedReader(Reader r)传递任意的字符流，传递谁，就对谁高效
。FileReader类，InputStreamReader

/*
*字符输入流缓冲区,读取文本文件
*按照行来读取
*readLine()方法，读取到文件末尾，返回bull
*readLine()方法读取一行字符串，不包含换行符\r\n
*/
public static void main(String[] args) throws IOException {
	//创建字符输入流,绑定数据源文件
	FileReader fr = new FileReader("buffer. txt");
	//创建字符输入流的缓冲区流
	BufferedReader bfr = new BufferedReader(fr);
	//读取方法readline()读文本行
	String line = null;
	while((line=bfr. readLine())!=null){
	System. out . println(line);
	}
	bfr . close();
}

字符流复制文件问题

只能操作文本文件，局限性很大
不能复制文件，如果需要文件复制，选择字节流

字符流用途案例

提供数据：多个姓名和年龄，存储在文本文件
读取数据，每个人，按照年龄排序，排序后的结果，存储到新的文件中
思想:文本中的数据,读取到集合，对集合中的元素排序，排序后的内容写回到文件中
实现步骤:
1读取文件person. txt
2.文件中的数据,转成Person对象
3.对象多了,存储到集合
4.集合排序Collections.工具类
5.集合中的对象,写回文件中

public static void main(String[ ] args) throws IOException{
	// 读取person.txt,按行读取
	BufferedReader bfr. = new
		BufferedReader( new FileReader("person. txt"));
	//创建List集合,存储多个Person对象
	List<Person> list = new ArrayList<Person>();
	while( (line = bfr. readLine())!=null) {
		//切割方法,分类姓名和年龄
		String[] strs = line.split(" +");// 0索引是姓名,1索引是年龄
		//创建Person对象
		Person p = new Person(strs[0], Integer. parseInt(strs[1]));
		list . add(p);
	}
	bfr.close();
	//集合排序，自定义比较器
	Collections. sort(list，new Comparator<Person>() {
		public int compare(Person p1, Person p2) {
			return p1. getAge() - p2. getAge();
		}
	});
	//字符输出缓冲流
	BufferedWriter bfw = new BufferedWriter(new FileWriter(" personSort .txt"));
	//遍历集合,取出一个Person对象，写入一个
	for(Person p : list) {
		bfw. write(p. getName( )+" "+p. getAge());
		bfw. newLine( ) ;
		bfw. flush();
	}
	bfw. close();
}

打印流

java.io.PrintStream字节输出流
java.io.PrintWriter字符输出流

打印流的特点：
。打印流，只负责数据目的，不负责数据来源
。打印流，永远不会抛出IOException，但可以抛出其它异常例如FileNotFoundException
。打印流，实现了大量的打印方法，print，println
。打印流可以使用自动刷新
PrintWriter构造方法：数据目的
。PrintWriter(File file)数据的目的File对象
。PrintWriter(String filename)数据的目的是字符串文件名
。PrintWriter(OutputStream out)数据目的是字节输出流
。PrintWriter(Writer w)数据目的是字符输出流

public static void main(String[] args) throws IOException {
	method();
	method_2( );
}
/*
*打印流的数据目的是字节输出流
*/
public static void method() throws IOException{
	//创建字节输出流
	File0utputStream fos = new. FileoutputStream("print 。txt" );
	//创建打印流对象，构造方法传递字节输出流
	PrintWriter pw = new PrintWriter(fos);
	//打印流的方法输出println()
	pw. println(100);
	pw. close();
}
/*
*打印流的数据目的是字符输出流
*/
public static void method_2( )throws IOException {
	//创建字符输出流
	FileWriter fw = new FileWriter(" print2. txt");
	//打印流对象,构造方法，传递字符输出流
	PrintWriter pw = new PrintWriter(fw);
	pw. println(true);
	pw. close();
}

打印流可以使用自动刷新
。打印流开启自动刷新，数据的目的必须是流对象
。打印流的构造方法第二参数写true
。必须调用方法：println(),printf(),format()三个中一个，启用自动刷新

public static void main(String[] args) throws IOException {
	method_ 3();
}
/*
*打印流的自动刷新功能
*如果数据目的,不是流对象,能否使用自动刷新呢,不能
*但是可以转换
*FileWriter(String 文件名)
*FileWriter(File file)
*/
public static void method_ 3( )throws IOException {
	//创建打印流对象,输出目的必须是流对象
	PrintWriter pw = new PrintWriter(new FileWriter(" print3. txt"),true);
	PrintWriter pw2 =new PrintWriter(new FileWriter(new File("print3. txt")),true);
	pw. println(200);
	pw.close();
	pw2.close();
}