31.Java中的字符流【20220806】

最新推荐文章于 2024-05-03 16:12:22 发布

guizhaiteng

最新推荐文章于 2024-05-03 16:12:22 发布

阅读量103

点赞数

分类专栏： java基础学习笔记文章标签： java java入门 java基础 java自学 java面试

本文链接：https://blog.csdn.net/guizhaiteng/article/details/126191560

版权

java基础学习笔记专栏收录该内容

39 篇文章 2 订阅

订阅专栏

字符流--每一次读写一个字符，一个字符等于2个字节，16位2进制数据，只能读写文本类型的文件。

字符流相关的操作类

字符输出流---Writer类---抽象类---不能new---子类

FileWriter类

FileWriter类的构造方法
FileWriter(File file) 给一个File对象构造一个FileWriter对象。
FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。
FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
FileWriter(String fileName, boolean append)给一个String对象构造一个是否允许追加FileWriter对象。

package com.wangxing.test1;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestFileWriter {
	public static void main(String[] args)throws Exception {
		String filepath="F:"+File.separator+"mytest"+File.separator+"test1.txt";
		File file=new File(filepath);
		//FileWriter类的构造方法
		//FileWriter(File file) 给一个File对象构造一个FileWriter对象。 
		FileWriter  wtiter1=new FileWriter(file);
		Writer  wtiter11=new FileWriter(file);
		//FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。 
		FileWriter  wtiter2=new FileWriter(file,true);
		Writer  wtiter22=new FileWriter(file,true);
		//FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
		FileWriter  wtiter3=new FileWriter(filepath);
		Writer  wtiter33=new FileWriter(filepath);
		//FileWriter(String fileName, boolean append)给一个String对象构造一个是否允许追加FileWriter对象。
		FileWriter  wtiter4=new FileWriter(filepath,true);
		Writer  wtiter44=new FileWriter(filepath,true);
	}
}

FileWriter类的实例方法
   void   write(char[] cbuf) 写入一个字符数组。
   void   write(char[] cbuf, int off, int len) 写入字符数组的一部分。
   void   write(int c) 写一个字符
   void   write(String str) 写一个字符串
   void   write(String str, int off, int len) 写一个字符串的一部分。
   void   close() 关闭流，先刷新。
   void   flush() 刷新流。

package com.wangxing.test1;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestFileWriter2 {
	public static void main(String[] args)throws Exception {
		String filepath="F:"+File.separator+"mytest"+File.separator+"test1.txt";
		File file=new File(filepath);
		//FileWriter类的实例方法
		//void	write(char[] cbuf) 写入一个字符数组。 
		/*
		String info1="hello.world";
		FileWriter  out1=new FileWriter(file);
		out1.write(info1.toCharArray());
		out1.flush();
		out1.close();
		*/
		
		//void	write(char[] cbuf, int off, int len) 写入字符数组的一部分。
		/*
		String info1="hello.world";
		FileWriter  out1=new FileWriter(file);
		char chararray[]=info1.toCharArray();
		out1.write(chararray,6,5);
		out1.flush();
		out1.close();
		*/
		
		//void	write(int c) 写一个字符 
		/*
		FileWriter  out1=new FileWriter(file);
		out1.write(100);
		out1.flush();
		out1.close();
		*/
		/*
		String info1="hello.world";
		FileWriter  out1=new FileWriter(file);
		char chararray[]=info1.toCharArray();
		for(int i=0;i<chararray.length;i++){
			out1.write(chararray[i]);
		}
		out1.flush();
		out1.close();
		*/
		
		//void	write(String str) 写一个字符串 
		/*
		String info1="hello.nihao";
		FileWriter  out1=new FileWriter(file);
		out1.write(info1);
		out1.flush();
		out1.close();
		*/
		//void	write(String str, int off, int len) 写一个字符串的一部分。 
		String info1="hello.nihao";
		FileWriter  out1=new FileWriter(file);
		out1.write(info1,0,5);
		out1.flush();
		out1.close();
		//void	flush() 刷新流。 
		//void	close() 关闭流，先刷新。 
	}
}

字符输入流---Reader类---抽象类---不能new---子类

FileReader类

FileReader类的构造方法
FileReader(File file) 给一个File对象构造一个FileReader对象。
FileReader(String fileName) 给一个String对象构造一个FileReader对象。

package com.wangxing.test1;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestFileReader {
	public static void main(String[] args)throws Exception {
		String  filepath="F:"+File.separator+"mytest"+File.separator+"test1.txt";
		File  file  = new File(filepath);
		//FileReader类的构造方法
		//FileReader(File file) 给一个File对象构造一个FileReader对象。 
		FileReader   in1=new FileReader(file);
		Reader   in11=new FileReader(file);
		//FileReader(String fileName) 给一个String对象构造一个FileReader对象。
		FileReader   in2=new FileReader(filepath);
		Reader   in22=new FileReader(filepath);
	}
}

FileReader类的实例方法
int   read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
int   read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void   close() 关闭流并释放与之相关联的任何系统资源。

package com.wangxing.test1;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestFileReader2 {
	public static void main(String[] args)throws Exception {
		String  filepath="F:"+File.separator+"mytest"+File.separator+"test1.txt";
		File  file  = new File(filepath);
		//FileReader类的实例方法
		//int	read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
		/*
		FileReader  in=new FileReader(file);
		char  chararray[]=new char[(int)file.length()];
		int len=in.read(chararray);
		String  info=new String(chararray,0,len);
		in.close();
		System.out.println("info=="+info);
		*/
		
		//int	read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
		/*
		FileReader  in=new FileReader(file);
		int temp=in.read();
		in.close();
		System.out.println(temp);
		*/
		FileReader  in=new FileReader(file);
		char chararray[]=new char[(int)file.length()];//保存数据的字符数组
		int temp=0; //读取来的每一个字符
		int index=0;//数组下标
		while((temp=in.read())!=-1){
			chararray[index]=(char)temp;
			index++;
		}
		String  info=new String(chararray,0,index);
		in.close();
		System.out.println("info=="+info);
		//void	close() 关闭流并释放与之相关联的任何系统资源。 
	}
}

BufferedWriter类

BufferedWriter类的构造方法
BufferedWriter(Writer out)通过字符输出流的对象创建BufferedWriter

package com.wangxing.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestBufferedWriter {
	public static void main(String[] args)throws Exception {
		String  filepath="F:"+File.separator+"mytest"+File.separator+"test2.txt";
		File  file=new File(filepath);
		//BufferedWriter类的构造方法
		//BufferedWriter(Writer  out)通过字符输出流的对象创建BufferedWriter
		Writer  out=new FileWriter(file);
		BufferedWriter  bufferedout=new BufferedWriter(out);
	}
}

BufferedWriter类的实例方法
   void   newLine() 写一行行分隔符。
   void   write(char[] cbuf) 写入字符数组。
   void   write(int c) 写一个字符
   void   write(String s) 写一个字符串。
   void   close() 关闭流，先刷新。
   void   flush() 刷新流。

package com.wangxing.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestBufferedWriter2 {
	public static void main(String[] args)throws Exception {
		String  filepath="F:"+File.separator+"mytest"+File.separator+"test2.txt";
		File  file=new File(filepath);
		//BufferedWriter类的实例方法
		//void	write(char[] cbuf) 写入字符数组。
		/*
		String info="nihao,zhangsan";
		Writer  out=new FileWriter(file);
		BufferedWriter  bufferedout=new BufferedWriter(out);
		bufferedout.write(info.toCharArray());
		bufferedout.close();
		out.close();
		*/
		//void	write(int c) 写一个字符 
		/*
		String info="nihao,lisi";
		Writer  out=new FileWriter(file);
		BufferedWriter  bufferedout=new BufferedWriter(out);
		char  chararray[]=info.toCharArray();
		for(char value:chararray){
			bufferedout.write(value);
		}
		bufferedout.close();
		out.close();
		*/
		
		//void	write(String s) 写一个字符串。 
		/*
		String info="nihao,wangwu";
		Writer  out=new FileWriter(file);
		BufferedWriter  bufferedout=new BufferedWriter(out);
		bufferedout.write(info);
		bufferedout.close();
		out.close();
		*/
		
		//void newLine()写出行分隔符。 
		String info1="hello,lisi";
		String info2="nihao,wangwu";
		Writer  out=new FileWriter(file);
		BufferedWriter  bufferedout=new BufferedWriter(out);
		bufferedout.write(info1);
		bufferedout.newLine();
		bufferedout.write(info2);
		bufferedout.close();
		out.close();
		//void	close() 关闭流，先刷新。 
		//void	flush() 刷新流。 
	}
}

BufferedReader类

BufferedReader类构造方法
BufferedReader(Reader in)通过字符输入流对象创建一个BufferedReader

package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestBufferedReader {
	public static void main(String[] args)throws Exception{
		String  filepath="F:"+File.separator+"mytest"+File.separator+"test2.txt";
		File  file=new File(filepath);
		//BufferedReader类构造方法
		//BufferedReader(Reader in)通过字符输入流对象创建一个BufferedReader
		Reader in=new FileReader(file);
		BufferedReader  bufferedin=new BufferedReader(in);
	}
}

BufferedReader类实例方法
int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾则为-1。
int int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close() 关闭流并释放与之相关联的任何系统资源。
String readLine() 读一行文字。

package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestBufferedReader2 {
	public static void main(String[] args)throws Exception{
		String  filepath="F:"+File.separator+"mytest"+File.separator+"test2.txt";
		File  file=new File(filepath);
		//BufferedReader类实例方法
		//int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
		/*
		Reader  in=new FileReader(file);
		BufferedReader  bufferedin=new BufferedReader(in);
		char  chararray[]=new char[(int)file.length()];
		int temp=0;
		int index=0;
		while((temp=bufferedin.read())!=-1){
			chararray[index]=(char)temp;
			index++;
		}
		bufferedin.close();
		in.close();
		String info=new String(chararray,0,index);
		System.out.println(info);
		*/
		//int int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
		/*
		Reader  in=new FileReader(file);
		BufferedReader  bufferedin=new BufferedReader(in);
		char  chararray[]=new char[(int)file.length()];
		int len=bufferedin.read(chararray);
		bufferedin.close();
		in.close();
		String info=new String(chararray,0,len);
		System.out.println(info);
		*/
		
		//String readLine() 读一行文字。
		/*
		Reader  in=new FileReader(file);
		BufferedReader  bufferedin=new BufferedReader(in);
		String info1=bufferedin.readLine();
		bufferedin.close();
		in.close();
		System.out.println(info1);
		*/
		Reader  in=new FileReader(file);
		BufferedReader  bufferedin=new BufferedReader(in);
		String tempinfo=null;
		while((tempinfo=bufferedin.readLine())!=null){
			System.out.println(tempinfo);
		}
		bufferedin.close();
		in.close();
		//void	close() 关闭流并释放与之相关联的任何系统资源。 
	}
}

OutputStreamWriter类

OutputStreamWriter类构造方法
OutputStreamWriter(OutputStream out)将字节输出流转换成字符输出流

package com.wangxing.test3;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class TestOutputStreamWriter {
	public static void main(String[] args)throws Exception {
		String filepath="F:"+File.separator+"mytest"+File.separator+"test3.txt";
		File  file=new File(filepath);
		//OutputStreamWriter类构造方法
		//OutputStreamWriter(OutputStream out)将字节输出流转换成字符输出流
		OutputStream out=new FileOutputStream(file);
		OutputStreamWriter  outwriter=new OutputStreamWriter(out);
	}
}

OutputStreamWriter类实例方法
   void   write(char[] cbuf) 写入一个字符数组。
   void   write(char[] cbuf, int off, int len) 写入字符数组的一部分。
   void   write(int c) 写一个字符
   void   write(String str) 写一个字符串
   void   write(String str, int off, int len) 写一个字符串的一部分。
   void   close() 关闭流，先刷新。
   void   flush() 刷新流。

package com.wangxing.test3;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class TestOutputStreamWriter2 {
	public static void main(String[] args)throws Exception {
		String filepath="F:"+File.separator+"mytest"+File.separator+"test3.txt";
		File  file=new File(filepath);
		//字节流写出数据，需要将字符串转换成字节数组
		/*
		String  info="test.hello";
		OutputStream out=new FileOutputStream(file);
		out.write(info.getBytes());
		out.close();
		*/
		
		String  info="zhangsan.hello";
		OutputStream out=new FileOutputStream(file);
		OutputStreamWriter  outputstreamwriter=new OutputStreamWriter(out);
		outputstreamwriter.write(info);
		outputstreamwriter.close();
		out.close();
	}
}

InputStreamReader类【字节输入流转成字符输入流】

InputStreamReader类构造方法
InputStreamReader(InputStream in)字节输入流转成字符输入流

package com.wangxing.test3;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
public class TestInputStreamReader {
	public static void main(String[] args) throws Exception{
		String filepath="F:"+File.separator+"mytest"+File.separator+"test3.txt";
		File  file=new File(filepath);
		//InputStreamReader类构造方法
		//InputStreamReader(InputStream in)字节输入流转成字符输入流
		InputStream in=new FileInputStream(file);
		InputStreamReader inputstreamReader=new InputStreamReader(in);
	}
}

InputStreamReader类实例方法
int read()读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close() 关闭流并释放与之相关联的任何系统资源。

package com.wangxing.test3;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
public class TestInputStreamReader2 {
	public static void main(String[] args) throws Exception{
		String filepath="F:"+File.separator+"mytest"+File.separator+"test3.txt";
		File  file=new File(filepath);
		/*
		InputStream  in=new FileInputStream(file);
		byte bytearray[]=new byte[(int)file.length()];
		int len=in.read(bytearray);
		in.close();
		String info=new String(bytearray,0,len);
		System.out.println(info);
		*/
		
		InputStream  in=new FileInputStream(file); //字节流
		InputStreamReader  reader1=new InputStreamReader(in);//字符流
		BufferedReader  buff=new BufferedReader(reader1);
		String info=buff.readLine();
		buff.close();
		reader1.close();
		in.close();
		System.out.println(info);
	}
}

通过BufferedReader读取键盘输入的数据

Scanner的nextLine()方法为什么可以读取键盘输入？？？？
因为Scanner对象在创建的时候使用了System.in,System.in默认就是键盘输入。
只要在创建BufferedReader对象的时候，使用System.in就可以完成键盘输入。
BufferedReader(Reader in)参数是Reader字符输入流
System.in----InputStream类型字节输入流
解决问题的关键就是将InputStream类型字节输入流转换成Reader字符输入流。

package com.wangxing.test3;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
public class TestInputStreamReader2 {
	public static void main(String[] args) throws Exception{
		//使用BufferedReader类替换Scanner类的读取键盘输入的操作
		//Scanner类的键盘输入使用的是System.in
		//System.in这个变量是InputStream类型是字节流
		//如果要用BufferedReader类替换Scanner类，
		//那么就需要将System.in这个变量表示的字节流,转换成字符流？
		//InputStreamReader可以完成这个操作，InputStreamReader类专门用来将字节流转换成字符流
		InputStreamReader  inputStreamReader=new InputStreamReader(System.in);
		BufferedReader  bufferedreader=new BufferedReader(inputStreamReader);
		System.out.println("请输入姓名:");
		String name=bufferedreader.readLine();
		System.out.println("姓名是=="+name);
		bufferedreader.close();
		inputStreamReader.close();
	}
}