Java中输入(读)输出(写)流

一、输入输出流

输入输出流–读写文件
输入—从文件中获取数据到自己的程序中接受处理【读】
输出—从自己的程序中处理好的数据保存在文件中【写】
流—–数据的移动轨迹

二、流的分类

按照每一次的移动轨迹将流分为输入流、输出流
按照每一次读\写数据量的大小将流分为：字节流字符流
字节流：每一次可以读写一个字节的数据量，一个字节就是8位2进制，可以处理任何类型的文件【文本、图片、视频···等】
字符流：每一次可以读写一个字符的数据量，一个字符就是16位2进制，只能处理文本类型
详细划分：字节输入流字节输入流字符输入流字符输出流

二.字节流相关类的使用

字节输出流—OutputStream—抽象类—不能new—子类

1.FileOutputStream类
FileOutputStream类构造方法：
   FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。
   FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流
   FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。
   FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流。
例如：
package com.wangxing.test2;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class FileOutputStreamTest1 {

	public static void main(String[] args) throws FileNotFoundException {
		//字节输出流---OutputStream---抽象类---不能new---子类
		//子类-1.FileOutputStream类
		//FileOutputStream类构造方法：
		//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
		//创建file对象作为读\写的指定路径
		String filepath="E:"+File.separator+"wangxingPeiXun"+File.separator+"java后端"+File.separator+"java基础"+File.separatorChar+"20211116java_16"+File.separator+"file2.txt";
		File file=new File(filepath);
		//注意此时创建输出流对象时会自动生成没有的这个文件或文件夹，如果报错就是路径错误
		//FileOutputStream ou1t1=new FileOutputStream(file);
		//System.out.println(file.exists());//true
		//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
		//FileOutputStream out2=new FileOutputStream(file,true);
		//System.out.println(file.exists());//true
		//FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。  
		//FileOutputStream out3=new FileOutputStream(filepath);
		//System.out.println(file.exists());//true
		//FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流。
		FileOutputStream out4=new FileOutputStream(filepath,true);
		System.out.println(file.exists());
	}
}
FileOutputStream类实例方法:
   void   write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
   void   write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
   void   write(int b) 将指定的字节写入此文件输出流。
   void   close() 关闭此文件输出流并释放与此流相关联的任何系统资源。
例如：
package com.wangxing.test2;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest2 {
	public static void main(String[] args) throws Exception {
		String filepath="E:"+File.separator+"wangxingPeiXun"+File.separator+"java后端"+File.separator+"java基础"+File.separatorChar+"20211116java_16"+File.separator+"file2.txt";
		File file=new File(filepath);
		FileOutputStream out=new FileOutputStream(file,true);
		//FileOutputStream类实例方法:
		//void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
		String str="holle,world";
		byte[] arr=str.getBytes();
		//out.write(arr);
		//void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此		文件输出流。 
		out.write(arr, 0, arr.length);//holle,world
		out.write(arr, 6, arr.length-6);//world
		//void	write(int b) 将指定的字节写入此文件输出流。 
		out.write(104);
		out.close();
		//void	close() 关闭此文件输出流并释放与此流相关联的任何系统资源。
	}
}
2.DataOutputStream类
DataOutputStream类的构造方法
   DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
DataOutputStream类的实例方法
   void   writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。
   void   writeByte(int v) 将 byte作为1字节值写入底层输出流。
   void   writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
   void   writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，       然后写入该 long值基础输出流作为8字节的数量，高字节。
   void   writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入       该 int值基础输出流作为一个4字节的数量，高字节。
   void   writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。
   void   writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。
   void   writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。
   void   writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流
   void   flush() 刷新此数据输出流。
   void   close() 关闭此输出流并释放与此流相关联的任何系统资源。
例如：
package com.wangxing.test2;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
public class DateOutputStreamTest1 {
	public static void main(String[] args) throws Exception {
		// DataOutputStream类的构造方法
		// DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211116java_16" + File.separator + "fileDtaoutStream.txt";
		File file = new File(path);
		FileOutputStream outfile = new FileOutputStream(file,true);
		DataOutputStream out = new DataOutputStream(outfile);
		// DataOutputStream类的实例方法
		boolean flag = true;
		int int1 = 1001;
		char char1 = 'a';
		double doblle1 = 12.5;
		String str = "fxt";
		//void writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。
		out.writeBoolean(flag);
		//void writeByte(int v) 将 byte作为1字节值写入底层输出流。
		out.writeByte(int1);
		// void writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
		out.writeChar(int1);
		//void writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类
		//Double ， 然后写入该 long值基础输出流作为8字节的数量，高字节。
		out.writeDouble(doblle1);
		//void writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入
		//该 int值基础输出流作为一个4字节的数量，高字节。
		out.writeFloat((float)doblle1);
		//void writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。
		out.writeFloat(int1);
		//void writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。
		out.writeFloat(int1);
		//void writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。
		out.writeShort(int1);
		//void writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流
		//使用这个表示写出的数据编码格式为utf-8格式，
		out.writeUTF(flag+","+str+","+char1+","+doblle1+","+int1);
		//void close() 关闭此输出流并释放与此流相关联的任何系统资源。
		out.flush();
		out.close();
		outfile.close();
		//void flush() 刷新此数据输出流。	
	}
}
优点:可以直接写出基本数据类型的数据和String，且不需要转换成字节数组
缺点:保存到文件中的数据是乱码

3.序列化–将一个java对象转换成2进制流数据过程
因为我们做操作的java对象可能需要在多台计算机之间传递。
   如何实现序列化？
   1.为被序列化的java对象的生成类实现一个序列化接口【Serializable】
   public interface Serializable
   特殊—-该接口中一个方法都没有。
   类的序列化由实现java.io.Serializable接口的类启用。
   不实现此接口的类将不会使任何状态序列化或反序列化。
   可序列化类的所有子类型都是可序列化的。
   2.通过java提供ObjectOutputStream类的writeObject(Object obj)
   ObjectOutputStream的构造方法
   ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
   实例方法
   void   writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
例如：
package com.wangxing.test3;

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class ObjectOutputStreamTest {
	public static void main(String[] args) throws Exception {
		//ObjectOutputStream继承了outputstream接口同时继承了Objectoutstream
		//ObjectOutputStream的构造方法
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211116java_16" + File.separator + "ObjectoutStream.txt";
		File file=new File(path);
		OutputStream  out=new FileOutputStream(file);
		//ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。 
		ObjectOutputStream out1=new ObjectOutputStream(out);
		//实例方法中继承了ObjectOutput的方法所以多了一个这个方法
		//可以将对象转换成2进制
		//void	writeObject(Object obj) 将指定的对象写入ObjectOutputStream。 
		Student student=new Student();
		out1.writeObject(student);
		out.close();
		out1.close();
	}
}

字节输入流—InputStream—抽象类–不能new—子类

1.FileInputStream类
FileInputStream类构造方法：
FileInputStream(File file) 通过File对象创建一个字节输入流
FileInputStream(String name) 通过String对象创建一个字节输入流
例如：

package com.wangxing.test2;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class FileIntputStreamTest1 {
	public static void main(String[] args) throws FileNotFoundException{
		String filepath="E:"+File.separator+"wangxingPeiXun"+File.separator+"java后端"+File.separator+"java基础"+File.separatorChar+"20211116java_16"+File.separator+"file2.txt";
		File file=new File(filepath);
		//字节输入流---InputStream---抽象类---不能new---子类
		//1.FileInputStream类
		//FileInputStream类构造方法：
		//FileInputStream(File file) 通过File对象创建一个字节输入流
		FileInputStream in=new FileInputStream(file);
		//FileInputStream(String name) 通过String对象创建一个字节输入流
		FileInputStream in2=new FileInputStream(filepath);
	}
}

FileInputStream类实例方法
   int   read() 从该输入流读取一个字节的数据。
   返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
   int   read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
   返回值:读取的总字节数，如果到达文件末尾返回-1
   void   close() 关闭此文件输入流并释放与流相关联的任何系统资源。
例如：

package com.wangxing.test2;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileIntputStreamTest2 {
	public static void main(String[] args) throws IOException{
		String filepath="E:"+File.separator+"wangxingPeiXun"+File.separator+"java后端"+File.separator+"java基础"+File.separatorChar+"20211116java_16"+File.separator+"file2.txt";
		File file=new File(filepath);
		FileInputStream in=new FileInputStream(file);
		//FileInputStream类实例方法
		//int	read() 从该输入流读取一个字节的数据。 返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
		//在FileIntputStreamTest字节输入输出流中想要输出输入指定的数据，必须以字节数组的形式
		/*int munstr=in.read();
		byte by=(byte)munstr;
		String str=String.valueOf(by);
		System.out.println(str);
		in.close();
		*/
		//创建一个保存每次取出int类型数据的变量
		int shuju=0;
		//创建一个数组的索引下标
		int index=0;
		//创建一个存放每次取出保存所有的字节数据
		byte[] bytearr=new byte[(int)file.length()];
		while((shuju=in.read())!=-1){
			bytearr[index]=(byte)shuju;
			index++;
		}
		String info=new String(bytearr,0,bytearr.length);
		System.out.println(info);
		in.close();
		
		//int	read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。返回值:读取的总字节数， 如果到达文件末尾返回-1
		//创建一个存放每次取出保存所有的字节数据
		/*byte[] bytearr=new byte[(int)file.length()];
		int lenght=in.read(bytearr);
		String info=new String(bytearr,0,lenght);
		System.out.println(info);*/
		in.close();
		//void	close() 关闭此文件输入流并释放与流相关联的任何系统资源。 
	}
}

2.DataInputStream类
DataInputStream类构造方法
   DataInputStream(InputStream in)创建使用指定的底层InputStream的DataInputStream。
DataInputStream类实例方法
   boolean   readBoolean()
   byte   readByte()
   char   readChar()
   double   readDouble()
   float   readFloat()
   int   readInt()
   long   readLong()
   short   readShort()
   String   readUTF()
   void   close()
例如：

package com.wangxing.test2;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;

public class DataInputStreamTest {
	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211116java_16" + File.separator + "fileDtaoutStream.txt";
		File file = new File(path);
		FileInputStream filein=new FileInputStream(file);
		//DataInputStream类构造方法
		//DataInputStream(InputStream  in)创建使用指定的底层InputStream的DataInputStream。
		DataInputStream in=new DataInputStream(filein);
		//DataInputStream类实例方法
		//boolean	readBoolean() 
		//byte	readByte() 
		//char	readChar() 
		//double	readDouble() 
		//float	readFloat() 
		//int	readInt() 
		//long	readLong() 
		//short	readShort() 
		//String	readUTF() 
		//void	close() 
		System.out.println(in.readBoolean());
		in.close();
		filein.close();
	}
}

3.反序列化—将2进制流数据转换成java对象的过程
    需要ObjectInputStream类的Object readObject()方法读取对象。
   ObjectInputStream类的构造方法
   ObjectInputStream(InputStream in)
   ObjectInputStream类的实例方法
   Object   readObject() 从ObjectInputStream读取一个对象。
例如：

package com.wangxing.test3;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;

public class ObjectInputStreamTest {

	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211116java_16" + File.separator + "student.txt";
		File file=new File(path);
		InputStream in=new FileInputStream(file);
		//ObjectInputStream类的构造方法
		//ObjectInputStream(InputStream  in)
		ObjectInputStream in1=new ObjectInputStream(in);
		//ObjectInputStream类的实例方法
		//Object	readObject() 从ObjectInputStream读取一个对象。 
		Object  obj=in1.readObject();
		in1.close();
		in.close();
		Student student=(Student)obj;
		student.getStudent();
	}
}

三、字符流的相关类的使用

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

1.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.test4;

import java.io.File;
import java.io.FileWriter;

public class FileWriterTest {
	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "student.txt";
		File file=new File(path);
		//FileWriter类的构造方法
		//FileWriter(File file) 给一个File对象构造一个FileWriter对象。
		FileWriter write=new FileWriter(file);
		//FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。 
		FileWriter write2=new FileWriter(file,true);
		//FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
		FileWriter write3=new FileWriter("E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "student.txt");
		//FileWriter(String fileName, boolean append)给一个String对象构造一个是否允许追加FileWriter对象。
		FileWriter write4=new FileWriter("E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "student.txt",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.test4;

import java.io.File;
import java.io.FileWriter;

public class FileWriterTest2 {
	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "filewrite.txt";
		File file=new File(path);
		FileWriter out=new FileWriter(file,true);
		//FileWriter类的实例方法
		//void	write(char[] cbuf) 写入一个字符数组。 
		char[] cbuf=new char[]{'a','b','c','d'};
		out.write(cbuf);
		//void	write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
		out.write(cbuf,0,3);
		//void	write(int c) 写一个字符 
		out.write(99);
		//void	write(String str) 写一个字符串 
		String str="holle,world";
		out.write(str);
		//void	write(String str, int off, int len) 写一个字符串的一部分。 
		out.write(str,0,5);
		//void	close() 关闭流，先刷新。 
		out.flush();
		out.close();
		//void	flush() 刷新流。
	
	}
}
2.BufferedWriter类
   BufferedWriter类的构造方法
   BufferedWriter(Writer out)通过字符输出流的对象创建BufferedWriter
   BufferedWriter类的实例方法
   void   newLine() 写一行行分隔符。（相当于换行）
   void   write(char[] cbuf, int off, int len) 写入字符数组的一部分。
   void   write(int c) 写一个字符
   void   write(String s, int off, int len) 写一个字符串的一部分。
   void   close() 关闭流，先刷新。
   void   flush() 刷新流。
例如：
package com.wangxing.test4;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class BufferedWriterTest {
	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "BufferedWriter.txt";
		File file=new File(path);
		FileWriter out=new FileWriter(file,true);
		//BufferedWriter类的构造方法
		//BufferedWriter(Writer  out)通过字符输出流的对象创建BufferedWriter
		BufferedWriter out1=new BufferedWriter(out);
		
		//BufferedWriter类的实例方法
		//void	newLine() 写一行行分隔符。 
		out1.write("Holle,world");
		out1.newLine();
		out1.write("Holle,网星");
		out1.flush();
		out1.close();
		//void	write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
		//void	write(int c) 写一个字符 
		//void	write(String s, int off, int len) 写一个字符串的一部分。 
		//void	close() 关闭流，先刷新。 
		//void	flush() 刷新流。 
	}
}
3.OutputStreamWriter类
OutputStreamWriter类构造方法
OutputStreamWriter(OutputStream out)将字节输出流转换成字符输出流
例如：
package com.wangxing.test4;


import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class OutputStreamWriterTest {

	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "fileoutTowrite.txt";
		File file=new File(path);
		OutputStream out=new FileOutputStream(file);
		//创建字高级节输出流
		DataOutputStream fileout1=new DataOutputStream(out);
		
		//OutputStreamWriter类构造方法
		//OutputStreamWriter(OutputStream out)将字节输出流转换成字符输出流
		//注意这里传入的的字节流的父类所以转换过去也是底层的，而父类中没有高级流新方法，所以想要使用字符高级流还需要将转换好的字符流编程高级
		OutputStreamWriter writeout=new OutputStreamWriter(fileout1);
		String info="hello,world";
		writeout.write(info);
		writeout.flush();
		writeout.close();
	}
}

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

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

import java.io.File;
import java.io.FileReader;

public class FileReaderTest {

	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "filewrite.txt";
		File file=new File(path);
		//FileReader类的构造方法
		//FileReader(File file) 给一个File对象构造一个FileReader对象。 
		FileReader in=new FileReader(file);
		//FileReader(String fileName) 给一个String对象构造一个FileReader对象。
		//FileReader in2=new FileReader(path);
		
		//FileReader类的实例方法
		//int	read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
		System.out.println(in.read());//（a）97返回int型
		//int	read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
		//创建一个保存每次读出的数组
		char[] arr=new char[(int)file.length()];
		//创建数组的索引
		int index=0;
		//创建每次读取保存数据的变量
		int shuju=0;
		while((shuju=in.read())!=-1){
			arr[index]=(char)shuju;
			index++;
		}
		String str=new String(arr);
		System.out.println(str);
		//void	close() 关闭流并释放与之相关联的任何系统资源。 
		in.close();
	}
}
2.BufferedReader类
   BufferedReader类构造方法
   BufferedReader(Reader in)通过字符输入流对象创建一个BufferedReader
   BufferedReader类实例方法
   int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。int       int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
   void   close() 关闭流并释放与之相关联的任何系统资源。
   String   readLine() 读一行文字。
例如：
package com.wangxing.test4;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;

public class BufferedReaderTest {

	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "BufferedWriter.txt";
		File file=new File(path);
		//BufferedReader类构造方法
		//BufferedReader(Reader in)通过字符输入流对象创建一个BufferedReader
		//1.先创建底层字符流对象
		Reader in1=new FileReader(file);
		BufferedReader in=new BufferedReader(in1);
		
		//BufferedReader类实例方法
		//String	readLine() 读一行文字
		String str=in.readLine();
		System.out.println(str);
		//int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。int		int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
		//void	close() 关闭流并释放与之相关联的任何系统资源。 
		in.close();
	}
}
3.InputStreamReader类【字节输入流转成字符输入流】
InputStreamReader类构造方法
InputStreamReader(InputStream in)字节输入流转成字符输入流
例如：
package com.wangxing.test4;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;


public class InputStreamReaderTest {

	public static void main(String[] args) throws Exception {
		String path = "E:" + File.separator + "wangxingPeiXun" + File.separator + "java后端" + File.separator + "java基础"
				+ File.separator + "20211117java_17" + File.separator + "fileoutTowrite.txt";
		File file=new File(path);
		InputStream in2=new FileInputStream(file);
		//创建字高级节输出流
		DataInputStream filein1=new DataInputStream(in2);
		
		//3.InputStreamReader类【字节输入流转成字符输入流】
		//InputStreamReader类构造方法
		//InputStreamReader(InputStream in)字节输入流转成字符输入流
		InputStreamReader readerin=new InputStreamReader(filein1);
		int shuju= readerin.read();
		char[] arr=new char[(int)file.length()];
		arr[0]=(char)shuju;
		String str=new String(arr);
		System.out.println(str);
		readerin.close();
	}
}
问：我们能不能通过BufferedReader读取键盘输入的数据？
答案：不能因为键盘中的使用的输入流System.in属于字节输入流，在System类中in这个静态变量的类型是InputStream类所以他是字节输入流。

问：我们能不能通过BufferedReader读取键盘输入的数据？
答案：可以，只要将System.in–InputStream类型字节输入流转换成Reader类型字符输入流。
例如：
package com.wangxing.test5;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class inputStreamToReader {

	public static void main(String[] args) throws Exception {
		//我们能不能通过BufferedReader读取键盘输入的数据？
		//不能因为键盘中的使用的输入流System.in属于字节输入流，在System类中in这个静态变量的类型是InputStream类所以他是字节输入流。
		/*只要在创建BufferedReader对象的时候，使用System.in就可以完成键盘输入。
		BufferedReader(Reader in)参数是Reader字符输入流
		System.in----InputStream类型字节输入流
		解决问题的关键就是将InputStream类型字节输入流转换成Reader字符输入流。*/
		//将System.in转换成字符输入流
		InputStreamReader in=new InputStreamReader(System.in);
		BufferedReader   bufferread=new  BufferedReader(in);
		System.out.println("请输入您想输入的数据：");
		String str=bufferread.readLine();
		System.out.println("str=="+str);
	}
}

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/79833.html

Java中输入(读)输出(写)流

相关推荐