javaSE (六)：IO
目录
一、File类
● File类的构造方法
● File类的常用方法
二、输入及输出的概念
三、输入流与输出流
● 流按着数据的传输方向分为：
●从数据流编码格式上划分为：
● InputStream和OutputStream的子类都是字节流
● Reader和Writer的子类都是字符流
四、字节流与字符流
● 字节流中常用类
● 字符流中常用类
五、输入输出节点字节流
●InputStream的基本方法
● OutputStream的基本方法
六、节点流与处理流
● 根据封装类型不同流又分为
● 节点流：
节点流中常用类
● 处理流:
处理流中常用类
①字节流
②字符流
七、输入输出节点字符流
●Reader 的基本方法
●Writer 的基本方法
八、对象输入输出流——对象序列化
一、File类
①File类是java.io包中很重要的一个类；
②File类的对象可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录；
③File对象可以对文件或目录的属性进行操作，如：文件名、最后修改日期、文件大小等；
④File对象无法操作文件的具体数据，即不能直接对文件进行读/写操作。
● File类的构造方法
● File类的常用方法
！！!具体实现可以看下面这段代码:
public class FileDemo1 {
public static void main(String[] args) {
/*
File类：一个File类对象可以表示一个具体的文件或目录
*/
File f1 = new File("D:/demo.txt");
System.out.println(f1.canRead());//是否可以读入
System.out.println(f1.canWrite());//是否可以写入
System.out.println(f1.exists());//判断文件或目录是否存在
System.out.println(f1.getAbsolutePath());//获取文件地址
System.out.println(f1.getName());//获取文件名称
System.out.println(f1.getParent());//获取上一级名称
System.out.println(f1.isDirectory());//是否是一个文件夹
System.out.println(f1.isFile());//是否是一个文件
System.out.println(f1.lastModified());//最后一次修改时间
System.out.println(new Date(1712645438471L));
System.out.println(f1.length());//获取文件内容长度
System.out.println(f1.isHidden());//判断文件是否隐藏
}
}创建文件，删除文件，操作如下：
public class FileDemo2 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:/a.txt");
if (!f1.exists()){
System.out.println(f1.createNewFile());//创建文件
}
System.out.println(f1.delete());//删除文件或文件夹
File file = new File("D:/download");
System.out.println(file.mkdir());//创建单级文件
File file = new File("D:/download/a/b");
System.out.println(file.mkdirs());//创建多级对象
File file = new File("D:/download/a/b");
file.delete();//删除文件夹,先删除最后一级b给定一个文件目录，如何得到该文件下的子集呢？
File file = new File("D:/download/a");
File[] files = file.listFiles();//将子级装进数组里
for (File f : files){
System.out.println(f);
}删除文件时，文件必须是空的。如果该文件里面有内容，就不会删除，可以先进行判断，判断到底是一个文件还是文件夹，是文件直接删除，是文件夹删除该文件夹的子级
操作如下：
public class FileDemo2 {
public static void main(String[] args) throws IOException {
File file = new File("D:/download/a");
// file.delete();//删除文件夹时，文件夹必须是空的
File[] files = file.listFiles();
for (File f : files){
// System.out.println(f);
if (f.isFile()){//如果是文件就直接删除
f.delete();
}else{//如果是文件夹，输出该文件夹的子集删除
f.listFiles();
}
}
}
}
二、输入及输出的概念
● 输入输出（I/O）
把电脑硬盘上的数据读到程序中，称为输入,即input，进行数据的read 操作
从程序往外部设备写数据，称为输出，即output，进行数据的write 操作
三、输入流与输出流
● 流按着数据的传输方向分为：
● 输入流：往程序中读叫输入流。
● 输出流：从程序中往外写叫输出流。
●从数据流编码格式上划分为：
● 字节流
● 字符流
● InputStream和OutputStream的子类都是字节流
可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。
● Reader和Writer的子类都是字符流
主要处理字符或字符串，字符流处理单元为1个字符。 字节流将读取到的字节数据，去指定的编码表中获取对应文字字符。
四、字节流与字符流
● 字节流中常用类
字节输入流 FileInputStream
字节输出流 FileOutputStream
● 字符流中常用类
字符输入流 FileReader
字符输出流 FileWrite
五、输入输出节点字节流
●InputStream的基本方法
①读取一个字节并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。
int read() throws IOException
②读取一系列字节并存储到一个数组buffer，返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
int read(byte[] buffer) throws IOException
关闭流释放内存资源
void close() throws IOException
● OutputStream的基本方法
①向输出流中写入一个字节数据,该字节数据为参数b的第8位
void write(int b) throws IOException
②将一个字节类型的数组中的从指定位置（off）开始到 len个字节写入到输出流
void write(byte[] b, int off, int len) throws IOException
关闭流释放内存资源
void close() throws IOException
① 读入写入一个字节：
public class StreamDemo1 {
public static void main(String[] args) throws IOException {
// 输入 ：从硬盘上把文件读入到程序
// 方式一：
File file = new File("D:/demo.txt");
FileInputStream inputStream = new FileInputStream(file);
// 方式二：
FileInputStream inputStream = new FileInputStream("D:/demo.txt");
// 输出：将程序中的文件输出到另一个盘上
FileOutputStream outputStream = new FileOutputStream("C:/demo.txt");
int b = 0;
while ((b=inputStream.read())!=-1){
System.out.println(b);
outputStream.write(b);
}
inputStream.close();//关闭管道
outputStream.close();
}
}②读入写入一系列字节并存储在一个数组中：
public class StreamDemo2 {
public static void main(String[] args) throws IOException {
FileInputStream inputStream = new FileInputStream("D:/demo.txt");
FileOutputStream outputStream = new FileOutputStream("C:/demo.txt");
byte[] bytes = new byte[10];//相当于将10个字节装进一个小推车
// read(bytes); 一次读byte数组长度个字节，，文件读取完毕后返回返回-1
// size 每次实际往数组中加入的元素个数
int size = 0;
while ((size = inputStream.read(bytes))!=-1){
System.out.println(size);
//一次向外写出一个byte数组长度个字节内容，从指定的位置开始写，写size个
outputStream.write(bytes,0,size);
}
inputStream.close();
outputStream.close();
}
}六、节点流与处理流
● 根据封装类型不同流又分为
节点流
处理流
● 节点流：
如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等， 则称为节点流。
节点流中常用类
字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter
● 处理流:
如果流封装的是其它流对象，称为处理流。 处理流提供了缓冲功能， 提高读写效率,同时增加了一些新的方法
处理流中常用类
缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter
①字节流
比如下面写出缓冲字节流输入输出的具体操作：
public class StreamDemo3 {
public static void main(String[] args) throws IOException {
//FileInputStream 直接封装数据，称为节点流（最基础去读数据的流）
FileInputStream inputStream = new FileInputStream("D:/demo.txt");
//BufferedInoutStream 封装的是一个节点流对象，可以提供缓冲功能，称为处理流或包装流，缓冲字节输入流，默认缓冲区大小是8192个字节
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream,20);//可以自定义缓冲区大小
FileOutputStream outputStream = new FileOutputStream("C:/demo.txt");
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream,20);
byte[] bytes = new byte[10];
int size = 0;
while ((size = bufferedInputStream.read(bytes))!=-1){
bufferedOutputStream.write(bytes,0,size);
}
bufferedInputStream.close();
bufferedOutputStream.close();
bufferedOutputStream.flush();
}
}下面再举一个数据输入输出流的例子吧
！！！模拟控制台输入信息到D盘中的文本文件再输出回来
public class StreamDemo4 {
public static void main(String[] args) throws IOException {
//第一步：控制台输入信息
Scanner scanner = new Scanner(System.in);
String message = scanner.next();
//数据输入输出字节流（包装流/处理流）
FileOutputStream fileOutputStream = new FileOutputStream("D:/message.txt");
DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
dataOutputStream.writeUTF(message);//可以直接将字符串写出（内部进行转换）
dataOutputStream.flush();
dataOutputStream.close();
FileInputStream fileInputStream = new FileInputStream("D:/message.txt");
DataInputStream dataInputStream = new DataInputStream(fileInputStream);
String s = dataInputStream.readUTF();//可以直接将读取到的数据转为String
System.out.println(s);
}
}②字符流
比如下面写出缓冲字符流输入输出的具体操作：
public class CharDemo3 {
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("D:/demo.txt");
FileWriter writer = new FileWriter("D:/demo1.txt",true);//保留原来的内容，在原内容的基础上向后续写
BufferedReader bufferedReader = new BufferedReader(reader);
BufferedWriter bufferedWriter = new BufferedWriter(writer);
String line = null;
while((line = bufferedReader.readLine())!=null){
bufferedWriter.write(line);
bufferedWriter.newLine();//插入换行符
}
bufferedReader.close();
bufferedWriter.close();
}
}七、输入输出节点字符流
●Reader 的基本方法
读取一个字符并以整数的形式返回, 如果返回-1已到输入流的末尾。
int read() throws IOException
读取一系列字符并存储到一个数组buffer， 返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
int read( char[] cbuf) throws IOException
关闭void close() throws IOException
• Writer 的基本方法
向输出流中写入一个字符数据,该字节数据为参数b的16位
void write(int c) throws IOException
一个字符类型的数组中的数据写入输出流
void write( char[] cbuf) throws IOException
将一个字符类型的数组中的从指定位置（off set）开始的 length个字符写入到 输出流
void write( char[] cbuf, int off set, int length) throws IOException
关闭void close() throws IOException
①读入写入一个字符数据：
public class CharDemo1 {
public static void main(String[] args) throws IOException {
/*
字符流只能读文本文件，会将读到的字节结合编码表转换为一个字符编码
*/
FileReader reader = new FileReader("D:/demo.txt");
FileWriter writer = new FileWriter("D:/demo1.txt");
int c = 0;
while ((c= reader.read())!=-1){
writer.write(c);
}
reader.close();
writer.close();
}
}②读入写入一系列字符并存储在一个数组中：
public class CharDemo2 {
public static void main(String[] args) throws IOException {
/*
字符流只能读文本文件，会将读到的字节结合编码表转换为一个字符编码
*/
FileReader reader = new FileReader("D:/demo.txt");
FileWriter writer = new FileWriter("D:/demo1.txt");
char[] chars = new char[2];
int size = 0;
while ((size= reader.read(chars))!=-1){
System.out.println(size);
writer.write(chars,0,size);
}
reader.close();
writer.close();
}
}八、对象输入输出流——对象序列化
● 对象的寿命通常随着生成该对象的程序的终止而终止。 有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。
（比如说，系统升级，关闭服务器时将对象保存起来，升级完毕，重新再把数据还原回来）
● 对象的输入输出流 :
主要的作用是用于写入对象信息与读取对象信息。 对象信息 一旦写到文件上那么对象的信息就可以做到持久化了
（简单来说就是把java中的对象输出到文件中，从文件把对象输入到程序）
①把对象输出到文件的过程也称为对象的序列化
②再把对象从文件输入到程序得过程称为对象的反序列化，反序列化时会生成一个新的对象，所以反序列化也是创建对象的一种形式
对象的输出流:ObjectOutputStream
对象的输入流:ObjectInputStream
● 在ObjectInputStream 中用readObject()方法可以直接读取一个对象
ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中
public class ObjectStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
String s = new String("abc");
Date date = new Date();
//对象输出：对象的序列化
FileOutputStream fileOutputStream = new FileOutputStream("D:/obj.txt");
ObjectOutput output = new ObjectOutputStream(fileOutputStream);
output.writeObject(s);
output.writeObject(date);
output.close();
output.flush();
//对象输入：对象的反序列化
FileInputStream fileInputStream = new FileInputStream("D:/obj.txt");
ObjectInput input = new ObjectInputStream(fileInputStream);
String s =(String)input.readObject();
Date date = (Date) input.readObject();
System.out.println(s);
System.out.println(date);
input.close();
}
}
新建一个自定义的Student类， 如果一个类需要被序列化到文件中，那么这个类需要实现Serializable接口，实现后，会自动为该类生成一个序列化编号， 编号是类的唯一标识
public class Student implements Serializable {
/* 如果一个类需要被序列化到文件中，那么这个类需要实现Serializable接口，实现后，会自动为该类生成一个序列化编号
编号是类的唯一标识
但是自动生成的编号在类信息改变后，会重新为类生成一个编号
可以在类中显示的生成一个编号，这样类信息修改后，也不会改变
*/
private int num;
private String name;
public Student(int num, String name) {
this.num = num;
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}public class ObjectStream1 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//当一个类的对象需要被序列化到文件时，这个类必须要生成一个序列化编号
Student student = new Student(13,"黎明");
//对象输出：对象的序列化
FileOutputStream fileOutputStream = new FileOutputStream("D:/obj.txt");
ObjectOutput output = new ObjectOutputStream(fileOutputStream);
output.writeObject(student);
output.close();
output.flush();
//对象输入：对象的反序列化
FileInputStream fileInputStream = new FileInputStream("D:/obj.txt");
ObjectInput input = new ObjectInputStream(fileInputStream);
Student student =(Student)input.readObject();
System.out.println(student);
input.close();
}
}