Reader类
Reader类常用方法
int read( ) 读一个字符
int read(char[] c) 将字符读入数组
read(char[] c,int off,int len) 将字符读入数组的一部分
void close( ) 关闭流
子类InputStreamReader常用的构造方法
InputStreamReader(InputStream in) 创建使用默认字符集InputStreamReader
package demo01;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class InputStreamReaderDemo01 {
public static void main(String[] args) {
//创建File类对象
File file = new File("F:\\demo.txt");
//创建InputStream类对象，但是InputStream是一个抽象类，不能直接创建对象，可以创建它的子类FileInputStream类对象
InputStream is=null;
InputStreamReader ir =null;
try {
is = new FileInputStream(file);
//创建InputStreamReader类对象
ir = new InputStreamReader(is);
//开始读取数据
// int num =ir.read();
// System.out.println((char)num);
int num;
while((num=ir.read())!=-1){
System.out.print((char)num);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
//关闭多个流的原则：先开的后关，后开的先关
if(ir!=null){
try {
ir.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
InputStreamReader(InputStream in,String charsetName) 创建使用命名字符集的ISR
package demo01;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo02 {
public static void main(String[] args) {
InputStreamReader ir = null;
try {
ir = new InputStreamReader(new FileInputStream(
"F:/demo.txt"),"UTF-8");
char[] chars = new char[1024];
//read(char[] ch):从流中读取数据，并将数据存储在ch这个数组中，返回值表示从流中读取的数据个数
int num = ir.read(chars);
System.out.println(System.getProperty("file.encoding"));
// System.out.println(num); //10
//遍历数组chars，获取读取的数据
for(int i =0;i<num;i++){
System.out.print(chars[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(ir!=null){
try {
ir.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileReader类
FileReader类是InputStreamReader的子类
FileReader(File file) 创建一个新的FileReader,给出File读取
FileReader(String name) 创建一个新的 FileReader ，给定要读取的文件的名称。
该类只能按照本地平台的字符编码来读取数据，用户不能指定其他的字符编码类型 System.out.println(System.getProperty("file.encoding")); 获得本地平台的字符编码类型
使用FileReader读取文件
与字节流FileInputStream类实现文本文件读取步骤类似
1.引入相关的类
import java.io.Reader; import java.io.FileReader; Import java.io.IOExceprion;
2.创建FileReader
Reader fr= new FileReader("D:\\myDoc\\简介.txt");
3.读取文本文件的数据
fr.read();
4.关闭相关的流对象
fr.close();
package demo01;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo01 {
public static void main(String[] args) {
//创建FileReader类对象
FileReader fr = null;
try {
fr = new FileReader("F:/demo.txt");
int num =fr.read();
System.out.println((char)num);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
如何提高字符流读取文本文件的效率？
使用FileReader类与BufferedReader类
BufferedReader类
BufferedReader类是Reader类的子类
BufferedReader类带有缓冲区
按行读取内容的readLine()方法
BufferedReader常用的构造方法
BufferedReader(Reader in)
子类BufferedReader特有的方法
readLine()
使用 BufferedReader读文本文件
1.引入相关的类
import java.io.FileReader; import java.io.BufferedReader; import java.io.IOException;
2.构造BufferedReader对象和FileReader对象
Reader fr= new FileReader("C:\\myTest.txt "); BufferedReader br=new BufferedReader(fr);
3.调用read Line()方法读取数据
br.readLine();
4.关闭文件流对象
br.close(); fr.close();
读取包含中文的文本文件时，可能出现中文乱码，怎么办？
使用InputStreamReader并设置编码格式
InputStreamReader fr=new InputStreamReader(fis,"UTF-8");
package demo01;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
public class BufferedReaderDemo01 {
public static void main(String[] args) {
// 创建BufferedReader类对象
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream("F:/demo.txt"), "UTF-8"));
String str;
while((str=br.readLine())!=null){
System.out.println(str);
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Writer类
Writer类常用方法
write(String str) 写一个字符串
write(String str,int off,int len) 写一个字符串的一部分
void close() 关闭流，先刷新
void flush() 刷新流
子类OutputStreamWriter常用的构造方法
OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out,String charsetName)
package demo02;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo01 {
public static void main(String[] args) {
// 创建OutputStreamWriter类对象
OutputStreamWriter osw = null;
try {
osw = new OutputStreamWriter(new FileOutputStream(
"F:/demo.txt", true));
osw.write("hello java");
System.out.println("写入完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FileWriter类
FileWriter类是OutputStreamWriter的子类
FileWriter (File file)
FileWriter (String name)
该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型
使用FileWriter写文件
与字节流FileOutputStream类实现向文本文件写入数据步骤类似
1.引入相关的类
import java.io.Reader; import java.io.FileWriter; import java.io.IOException;
2.创建FileReader对象
Writer fw=new FileWriter("D:\\myDoc\\简介.txt");
3.写文本文件
fw.write();
4.关闭相关的流对象
fw.close();
package demo02;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo01 {
public static void main(String[] args) {
// 创建FileWriter类对象
FileWriter fw =null;
try {
fw = new FileWriter("F:/demo.txt", true);
fw.write("hi,js");
System.out.println("数据写入完毕");
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
如何提高字符流写文本文件的效率？
使用FileWriter类与BufferedWriter类
BufferedWriter类是Writer类的子类
BufferedWriter类带有缓冲区
BufferedWriter常用的构造方法 BufferedWriter(Writer out)
使用 BufferedWriter写文件
1.引入相关的类
import java.io.FileWriter ; import java.io.BufferedWriter ; import java.io.IOException;
2.构造BufferedWriter对象和FileWriter
FileWriter fw=new FileWriter("C:\\myTest.txt"); BufferedWriter bw=new BufferedWriter(fw);
3.调用Writer()方法写数据
bw.writer("hello");
4.流对象的清空和关闭flush()和close()
bw.flush();
fw.close();
package demo02;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class BufferedWriterDemo01 {
public static void main(String[] args) {
// 创建BufferedWriter类对象
BufferedWriter bw =null;
try {
bw = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("F:/demo.txt", true)));
bw.newLine();
bw.write("qwertasdfg");
bw.newLine();
bw.write("qqqqqqqqqqqqqqqqqqqqq");
bw.flush();
System.out.println("数据写入完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
读写二进制文件
DataInputStream类
FileInputStream的子类 与FileInputStream类结合使用读取二进制文件
DataOutputStream类
FileOutputStream的子类 与FileOutputStream类结合使用写二进制文件
使用 DataInputStream 读二进制文件
1.引入相关的类
import java.io.FileInputStream; import java.io.DataInputStream;
2.构造数据输入
FileWriter fw=new FileWriter("C:\\myTest.txt"); BufferedWriter bw=new BufferedWriter(fw);
3.调read()方法写数据
bfeol("hello");
4.流对象的清空和关闭flush()和close()
dis flush();
dis.vclose();
fw.close();
使用 DataOutputStream写二进制文件
DataInputStream类
FileInputStream的子类 与FileInputStream类结合使用读取二进制文件
DataOutputStream类
FileOutputStream的子类 与FileOutputStream类结合使用写二进制文件
使用 DataInputStream 读二进制文件
1.引入相关的类
import java.io.FileOutputStream; import import import java.io.DataOutputStream;
2.构造数据输出流对象
FileOutputStream outFile=new FileOutputStream("C:\\temp.class"); DataOutputStream out=new DataOutputStream(outFile);
3.调write()方法写数据
out.write();
4.关闭数据输出流
out.close();
package demo03;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataInputStreamAndDataOutputStreamDemo01 {
public static void main(String[] args) {
//创建FileInputStream类对象
FileInputStream fis=null;
//创建DataInputStream类对象
DataInputStream dis =null;
//创建FileOutputStream类对象
FileOutputStream fos =null;
//创建DataOutputStream类对象
DataOutputStream dos = null;
try {
fis = new FileInputStream("F:/beautiful.jpg");
dis = new DataInputStream(fis);
fos = new FileOutputStream("F:/girl.jpg");
dos=new DataOutputStream(fos);
int num;
while((num=dis.read())!=-1){
dos.write(num);
}
System.out.println("图片复制完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
dos.close();
fos.close();
dis.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}序列化和反序列化
序列化是将对象的状态写入到特定的流中的过程
反序列化则是从特定的流中获取数据重新构建对象的过程
实现序列化
1.实现Serializable接口
2.创建对象输出流
3.调用writeObject()方法将对象写入文件
4.关闭对象输出流
使用集合保存对象，可以将集合中的所有对象序列化
实现反序列化
1.实现Serializable接口
2.创建对象输入流
3.调用readObject()方法读取对象
4.关闭对象输入流
如果向文件中使用序列化机制写入多个对象，那么反序列化恢复对象时，必须按照写入的顺序读取
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
