CUMT--Java复习--文件及IO流
目录
2、ObjectInputStream和ObjectOutputStream
一、文件
1、文件系统和路径
????????一个文件系统包含三类对象：文件、目录和符号链接。
? ? ? ? 文件系统中的对象用路径来作为唯一的识别，路径有绝对路径（根目录为参照）和相对路径（当前目录为基础）两种。
2、File类
? ? ? ? java.io包提供了一系列用于文件处理的接口和类，如下图。
? ? ? ? 代码实例：
（1）File变量不一定初始化一个文件名，也可以是一个路径，“.”表示当前路径，在vscode环境下，代表当前项目的根目录，而不是当前包的路径。
（2）try...catch语句当File初始化的file变量路径不存在是生成一个该文件夹或文件，如果File初始化的是一个文件，那么如果该文件不存在，则在他应在的路径位置上生成一个该文件，若文件夹不存在，则生成一个该文件夹。
（3）对于vscode编译环境，使用file.list()生成“.”路径下的文件列表，输出是.vscode,bin,src这一类的项目根目录下的文件夹。file.listroots()生成的绝对路径文件列表，输出为C:/,D:/的系统根路径下目录。
import java.io.File;
import java.io.IOException;
public class Demo {
public static void main(String[] args)
{
File file=new File("."); //"."是指当前路径
System.out.println(file.getName()); //获取文件名
System.out.println(file.getParent()); //父路径
System.out.println(file.getAbsolutePath()); //绝对路径
System.out.println(file.exists()); //file是否存在
try
{
file.createNewFile(); //如果file不存在则在当前路径下创建
}
catch(IOException e)
{
e.printStackTrace();
}
String[] list=file.list(); //当前路径的文件列表
for(String name:list)
System.out.println(name);
File[] listroots=file.listRoots(); //电脑根目录下的文件列表
for(File name:listroots)
System.out.println(name);
}
}
3、FilenameFilter接口
? ? ? ? FilenameFilter接口是一个文件过滤器接口，可以将符合条件的文件筛选出来，FilenameFilter接口只有一个accept（File dir，String name）方法，用于筛选符合条件的文件返回true。
? ? ? ? 上面File类提到的list（）方法也可以接受FilenameFilter类型的参数。
? ? ? ? 下面实例返回后缀为.zip和.txt的符合条件的文件列表。
String[] filterFileNames=file.list(
new FilenameFilter() {
public boolean accept(File dir,String name)
{
return(name.endsWith(".zip")||name.endsWith(".txt")); //过滤特定后缀
}
}
);
for(String name:filterFileNames)
System.out.println(name);二、IO流
? ? ? ? IO流是实现数据输入和输出的基础，流的优势在于使用统一的方式对数据进行操作或传递，简化代码操作。
1、流的分类
按流的流向来分类：
? ? ? ? 输入流：只能从输入流中读取数据
? ? ? ? 输出流：只能从输出流中写入数据
按流所操作的基本数据单元来分类：
? ? ? ? 字节流：所操作的基本数据单元是8位的字节（byte）
? ? ? ? 字符流：所操作的基本数据单元是16位的字符（unicode）
按流的角色来分类：
? ? ? ? 节点流：用于从/向一个特定IO设备中读/写数据的流
? ? ? ? 处理流：对一个已经存在的流进行连接或封锁，通过封锁后的流来实现数据的读/写功能
2、流的体系结构
? ? ? ? 在使用IO流时，如果内容是文本内容，则使用字符流，若内容是二进制内容，如图像，则使用字节流。
? ? ? ? Java的IO流体系如下：
三、字节流?
? ? ? ? ?字节流的最基本的两个抽象类是InputStream和OutputStream，这两个都是抽象类，不能进行实例化，所以必须用子类（如FileInputStream和FileOutputStream）来进行实例化。
1、InputStream
? ? ? ? InputStream字节输入流的方法：
? ? ? ? InputStream子类：
????????读取文件的实例：（注意缓冲区的设置）?
public class stream {
public static void main(String[] args)
{
FileInputStream fin=null;
try{
fin = new FileInputStream("src/io/stream.java");
byte[] bbuf=new byte[1024]; //缓冲区
int hasRead = 0;
while((hasRead=fin.read(bbuf))>0) //循环读取文件数据，read输出当前字节数
System.out.println(new String(bbuf,0,hasRead)); //String构造函数，三个参数byte[],offset,length
}
catch(IOException e){
e.printStackTrace();
}
finally{
try{
fin.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}
}2、OutputStream
????????OutputStream字节输出流的方法：
? ? ? ? OutputStream的子类：
????????写入文件的实例：
import java.io.*;
import java.util.Scanner;
public class stream {
public static void main(String[] args)
{
File file=new File("src/io/1.txt");
try{
file.createNewFile(); //创建一个文件
}
catch(IOException e)
{
e.printStackTrace();
}
Scanner sc=new Scanner(System.in);
FileOutputStream fout=null;
try{
fout=new FileOutputStream("src/io/1.txt"); //输出字节流
System.out.println("请输入内容：");
String str=sc.nextLine(); //输入为String
fout.write(str.getBytes()); //转换为byte数组
}
catch(IOException e){
e.printStackTrace();
}
finally{
try{
fout.close();
sc.close(); //关闭扫描流（很新颖）
}
catch(IOException e)
{
e.printStackTrace();
}
}
}
}
四、字符流
? ? ? ? 字符流处理数据基本单元是字符，也就是char[]数组，而不是字节流的byte[]数组。
? ? ? ? 字符流的两个基本流是字符输入流Reader和字符输出流Writer，这两个都是抽象类，不能进行实例化，可以使用FileReader和FileWriter来创建实例。
1、Reader
? ? ? ? Reader的子类：
? ? ? ? Reader方法：
? ? ? ? Reader实例：
????????由于FileReader接口可以读文件，BufferedReader接口参数为Reader，FileReader只有read()方法，每次读一个字符，而BufferedReader存在新方法ReadLine（）可以逐行读，所以构成了下面的嵌套格式。
public class stream2 {
public static void main(String []args)
{
BufferedReader br=null;
try{
br=new BufferedReader(new FileReader("src/io/stream3.java")); //会引发FileNotFoundException，但该异常蕴含与IOException
String result=null;
while((result=br.readLine())!=null)
{
System.out.println(result);
}
}
catch(IOException e)
{
e.printStackTrace();
}
finally{
try{
br.close(); //关闭字符流
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
}2、Writer?
? ? ? ? Writer子类：
? ? ? ? ?Writer方法：
? ? ? ? Writer实例：
? ? ? ? 文件写入字符流，可以直接用write（）写入键盘输入的String变量，不需要嵌套。
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class stream2 {
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
FileWriter fw=null;
try{
fw=new FileWriter("src/io/1.txt");
System.out.println("请输入内容： ");
String str=sc.nextLine();
fw.write(str);
}
catch(IOException e){
e.printStackTrace();
}
finally{
try{
fw.close();
sc.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}
}
五、过滤流和转换流
1、过滤流
? ? ? ? 过滤流用于对已有流进行连接和封装处理，分为过滤输入流FilterInputStream和过滤输出流FilterOutputStream，分别继承于InputStream和OutputStream。?
? ? ? ? 过滤流可以参见字节流处理中的BufferedInputStream类。
2、转换流
? ? ? ? 转换流就是将字节流和字符流之间相互转换。
? ? ? ? InputStreamReader：将字节输入流转换成字符输入流
? ? ? ? OutputStreamWriter：将字符输出流转换成字节输出流
六、序列化
1、对象序列化与反序列化
? ? ? ? 对象序列化：将对象数据写入一个输出流的过程。（将代码转换成二进制格式）
? ? ? ? 反序列化：从一个输入流中读取一个对象。（从二进制格式中读代码）
? ? ? ? 对象序列化的两个特点：
（1）可以在分布式应用中使用，参数和返回值必须序列化
（2）可以循环保存每一个对象的数据。
? ? ? ? 序列化接口：java.lang.Serializable接口，接口中没有任何方法，当一个类implements该接口，则该类为可序列化类，可序列化类可以进行对象序列化。
2、ObjectInputStream和ObjectOutputStream
? ? ? ??ObjectInputStream和ObjectOutputStream分别是InputStream和OutputStream的子类，通过对象输出流通过writeObject来写入序列化对象，对象输入流通过readObject来读取序列化对象。
? ? ? ? 下面对象序列化实例：
? ? ? ? try括号内建立回收机制，当try...catch结束后，自动对其执行close。
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class filter {
public static void main(String [] args)
{
try(ObjectOutputStream obs=new ObjectOutputStream(new FileOutputStream("src/io/1.txt")))
{
Person person=new Person("张三",25);
obs.writeObject(person);
obs.flush();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
class Person implements Serializable{
private int age;
private String name;
public Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String toString()
{
return "姓名："+this.name+"，年龄："+this.age;
}
}
七、NIO?
? ? ? ? NIO类将文件或文件的一段区域映射到内存中，可以像访问内存一样访问文件。
? ? ? ? NIO中两个核心类：Buffer和Channel，Buffer本质上是一个数组，Channel类似于流传输，相比于输入输出流，提供了一个map（）方法，将一块数据直接映射到内存。
1、Buffer
? ? ? ? Buffer类没有构造方法，而是通过静态方法获得Buffer对象。
static xxxBuffer allocate(int capacity) : 创建一个指令容量的xxxBuffer对象。（xxx代表数据类型如char）
? ? ? ? ?Buffer的四个重要方法：capacity（容量），limit（界限），position（位置），mark（标记）。
????????capacity：最开始allocate设置的长度
? ? ? ? limit：初始化为capacity大小，当执行flip方法后，变为当前position大小，当执行clear方法后，再回到capacity大小
? ? ? ? position：初始化为0，当添加元素时，为添加元素所占总长度，不会因为后续获取靠前的数据而发生变化，因为Buffer类本质上是一个数组，当获取值后，不会影响数组变化
? ? ? ? mark：设置mark为当前position
? ? ? ? 其他常用方法：
| clear() | 将position设置为0，limit设置为capacity，丢弃标记 |
| flip() | 将limit设置为当前position，position设置为0 |
| rewind() | 将position设置为0，丢弃mark |
| reset() | 将position设置为以前的mark |
| get("2") | 将索引为2的元素获取，若为添加参数，则传入当前position的值 |
| put("a") | 添加元素a |
????????测试代码：
import java.nio.CharBuffer;
public class nioDemo {
public static void main(String[] args)
{
CharBuffer buff=CharBuffer.allocate(8);
System.out.println(buff.capacity()); //输出8
System.out.println(buff.limit()); //输出0
System.out.println(buff.position()); //输出0
buff.put("a");
buff.put("b");
buff.put("c");
System.out.println(buff.limit()); //输出8
System.out.println(buff.position()); //输出3
System.out.println(buff.get(0)); //输出a
buff.flip(); //此时limit=3，position=0
System.out.println(buff.get()); //输出a
buff.clear(); //position=0,limit=8
System.out.println(buff.limit()); //输出8
}
}2、Channel
? ? ? ? Channel与Buffer的区别：
（1）Channel可以直接将指定文件部分或全部映射成Buffer
（2）程序不能直接访问Channel数据，Channel只能与Buffer交互。
参考书籍：《Java 8 基础应用与开发》QST青软实训编?
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！