一、输入输出流
输入输出流--读写文件
输入---从文件中获取数据到自己的程序中接受处理【读】
输出---从自己的程序中处理好的数据保存在文件中【写】
流-----数据的移动轨迹
二、流的分类
按照每一次的移动轨迹将流分为输入流、输出流
按照每一次读\写数据量的大小将流分为:字节流 字符流
字节流:每一次可以读写一个字节的数据量,一个字节就是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); } }