全部频道

首页 热点资讯 义务教育 高等教育 出国留学 考研考公
您的当前位置：首页正文

Java I/O流使用记录

2024-12-18 来源：化拓教育网

参考书：《Java程序设计标准教程》

一、简介

java输入输出功能来自java.io.的抽象类：InputStream和OutputStream类、Reader和Writer类以及她们的子类，以流的形式处理数据。流是一组数据序列，JAVA中每个数据流都是一个对象，提供各种支持读入和写出操作流类

二、I/0的基本模式

输入流.png
输出流.png

三、以byte为数据单位的流类（InputStream、OutputStream）

3.1、InputStream类
基本方法：

  • Avilabel() 返回当前输入流的数据读取方法可以读取的有效字节数量，返回int
  • Read() 从当前数据流中读取一个字节，如果已经到达流结尾，则返回-1 返回 abstarct int
  • Read(byte[] byte) 从当前输入流读取一定的byte数据，并存放到数组中，然后返回读取byte数据的数量，如果已经到到流结尾，则返回-1
  • read（byte[] bytes, int off, int len）将当前输入流读取一定的byte数据，并存放在数组中指定位置。然后返回读取byte数据的数量，如果已经到到流结尾，则返回-1
  • Reset() 将当前输入流重新定位到最后一次调用mark()方法时的位置
  • Mark(int readlimit) 在当前输入流中做标记位置，当调用Reset（）方法时将返回到该位置，从标记位置开始，到再读入readlimit这个字符为止，这个标记都维持有效。
  • Marksupported （）测试当前输入流是否支持mark、Reset方法，只要其中一个不支持，则返回false
  • Skip(long n) 跳过和丢弃当前输入流中的n个字节数据
  • Close（）关闭当前输入流、并释放任何与之相关联的系统资源
InputStream is = System.inl // 获取控制台的输入流
// InputStream is = null ;
Try {
// is =  new InputStream();
Byte[] bs = new byte[1024];
Int i = is.read(bs); // 从输入流中读取数据到字节数组
Is.close(); // 关闭输入流
} catch (IOException e){
E.printStackTrace()
}

3.2、OutputStream类

  • Write（byte[] bw）将byte[]数组中的数据写入当前输出流
  • Write（byte[] b, int off, int len）将byte[]数组下标off开始的长度为len的数据写入当前的输出流
  • Write（int b）写入一个byte数据到当前的输入流
  • Flush（） void 刷新当前输出流，并强制写入所有缓冲的字节数据
  • Close（） void 关闭当前输出流 并释放所有与当前输出流有关的系统资源
实例：以控制台输出流
OutputStream out = null;
Try{
out = new OutputStream() ;
Byte[] bs = “实例是outputStream 输出流”。getBytes()；// 将字符串变成字节数组
Out.write(bs); // 将字节数组的内容写到输出流
Out.close(); // 关闭输出流
}catch(Exception e){
E.printStackTrace()
}

四、以char为数据单位的流类（Reader、writer类）

4.1、Reader类

  • Ready（）boolean 判断此数据流是否准备好
  • Read（）int 读取一个字符，如果已读到流结尾，返回-1
  • Read（char[] chards, int off, int len） abstract int 读取一些字符到char[]数组，下标off开始到len长度，并返回所读入的字符的数量，如果到流结尾，返回-1
  • Reset（） void 在当前输入流重新定位到最后一次调用mark（）方法时的位置
  • Mark（int readlimit）
  • Marksupported
  • Skip(long n) long 跳过参数n指定的字符数量，并返回所跳过的字符数量
  • Close（）abstract void 关闭该流并释放与之关联的所有资源，在关闭流后，再调用read、ready、mark、Reset、skip将抛出的异常，关闭已经关闭的流无效
实例：
InputStreamReader isr = null;
Try {
Isr = new InputStream(????????????????????????????);// 获取输入流
Char[] cs = new char[]; //??????????
Isr.read(cs)
String s = new String(cs);
Isr.close();
}catch(Exception e) {
}

4.2、Writer类

  • Write（char[] cb） 返回void 将字符数组写入字符输出流
  • Write（char[] cb, int off, int len）
  • Write(int c);向一个输出流写一个字符数据
  • Write（String str） 向一个输出流写入一个字符串数据
  • Write（String str, int off, int len）
  • Flush()刷新当前输出流，并强制写入所有缓冲区的字节数据
  • Close() 向输出流写入缓冲区的数据，然后关闭当前输出流，并释放所有与当前输出流有关的系统资源

五、常用I/0处理方式

5.1、文件类

  • File类 用于封装系统的文件和目录的相关信息，文件大小、修改时间、文件路径等
  • File(String path) --- 指定文件文件路径字符串创建一个新的File类的实例对象
  • File(String parent, String child)
    常用方法：
    getName 获取文件名称
    getParent 获取文件父路径字符串
    getPath 获取文件相对路径字符串
    getAbsolutePath 获取文件的绝对路径字符串
    Exists 判断是否存在
    isFile 判断是否为文件类型
    isDirectory 判断是否为文件夹类型
    isAbsolute boolean 判断是否是绝对路径
    Delete boolean 创建文件或文件夹，如果删除成功返回true
    Mkdir boolean 创建文件或文件夹，如果创建成功返回true
    setReadOnly 设置文件夹的只读属性
    Length long 获取文件长度
    lastModified long 获取文件的最后修改日期
    List() String[] 获取文件夹中的文件和子文件夹的名称，并存放到字符串数组中
    listFiles() 返回File[] 。。。。。，并存放到File类型的数组中；

5.3、文件的字节输入输出流
    程序运行期间，大部分数据是在内存中操作的，当程序关闭或结束，这些数据完全消失，但有些数据需要永久保存；使用文件输入输出流可以和指定的文件建立关联，然后把需要永久保存的数据输出到文件中，程序下次运行，可以从文件中取回这些数据；
    5.3.1创建文件字节输入流
    文件字节输入流可以从指定路径的文件中读取字节数据，文件字节输入流继承字InputStream类，并实现了读取输入流的各种方法，
创建文件字节输入流的常用构造方法：
1、FileInputStream(File file)-----new FileInputStream(file),使用File类型的文件对象创建FileInputStream类的实例对象（文件字节输入流）
2、FileInputStream(String s) ---s指文件的绝对路径、相对路径
3、创建文件字节输出流：关联指定路径的文件 ，数据通过文件字节输出流以字节为单位输出并保存到文件中。常用构造方法FileOutputStream(File file),FileOutputStram(String fileName)

// 写入文件
Private static String fileName = “xxxx”
Private static File file = new File(fileName);
// 将启动时间点存到文件 XXX中
Private static long date = System.currentTime();
// 文件开始写入
String dataStr;
Try{
If(!file.exist()) {
File.createNewFile(); // ?????????????????注意区分 mkdir（创建文件，只能用来创建文件夹，且只能创建一级目录，如果上级不存在，创建失败）\makdirs(只能用来创建文件夹，，能创建多级目录，如果上级不存在，自动创建，创建文件夹多用这个)\createNewFile（只能用来创建文件，且只能创建在存在的目录下创建文件，否则创建失败，）-----
}
dataStr = date + “”;
Byte[] data = dataStr.getBytes();
FileOutputStream os = new FileOutputStream(file);
Os.write(data); // 将数据流写入输出流
Os.flush(); // 刷新缓冲区
Os.close(); // 关闭输出流
}catch(Exception e) {
E.printStackTrace();
}
// 读取文件
Try{
If（!file.exist()）{
File.createNewFile();
}
Byte[] data = new Byte[1024];
FileInputStream fis = new FileInputStream(file); //创建文件输入流
Int rs = 0;
String result;
While((rs = fis.read(data)) > 0) { //在循环中读取输入流的数据
Result += new String(data, 0, rs)
}
Fis.close();
}catch(Exception e){
E.printStackTrace();
}

4、文件的字符输入输出流
字节流一字节为单位传送数据，可以是任何类型的数据，文本，音频，视频，图片等，字符流以字符为单位传送数据，只能传送文本类型数据
FileReader(File file)
FileReader(String fileName)
FileWriter(File file)
FileWriter(String fileName)

Public void readFile(){
Try{
String filePath  = “xxxx”;
File file = new File(filePath);
FileReader reader = new FileReader(file);
Char[] data = new Char[512];
StringBuider sb = new StringBuilder();
Int rs = 0;
While((rs = reader.read(data)) > 0) {
sb .append(data, 0 , rs);
}
Reader.close();
}catch(Exception e) {
E.printStackTrace();
}
}
// 写入文件
Public void writeFile() {
Try{
String filePath = “xxxx”;
File file = new File(filePath);
FileWriter fw = new FileWriter(file);
Fw.write(.......)//将数据写入
}catch(Exception e) {
E.printStackTrace();
}
}

六、对象序列化

程序运行时需要保存一些数据，对于基本数据类型，直接保存到文件中，但对于复杂对象类型，需要将对象中不同的属性分解为基本数据类型，然后分别存到文件中，当程序再次运行时，需要建立新的对象，然后从文件中读取与对象相关的所有数据，再使用这些数据分别为对象的每个属性初始化
ObjectInput\ObjectOutput接口继承了DataInput和DataOutput接口，提供对基本数据类型和对象序列化的方法，使用对象序列化可以方便将对象写入输出流或者从输入流读取对象数据。
1、readObject()反序列化方法，从输入流中获取序列化的对象数据，用这些数据生成新的JAVA对象，在ObjectInput接口中，由ObjectInputStream类实现
Object object = readObject();注意类型的转换，根据所需
2、writeObject序列化方法
将对象写入输出流，输出流可以是文件输出流、网络输出流、其他输出流
writeObject(object) 注意：被序列化的对象必须实现serializable接口，否则无法实现序列化

Public class Worker implement Serializable{
Private String name;
Private String getName() {
Return name;}
Private void setName(String name) {
This.name = name;
}
}


Public static main(String[] args) {
Worker w = new Worker();
W.setName(“AAAA”);
// 序列化
Try {
FileOutputStream fo = new FileOutputStream(“./worker.dat”); // 在实例所在文件夹下创建文件worker.dat
ObjectOutputStream obj = new ObjectOutputStream(fo);
Obj.writeObject(worker)
}catch(Exception e) {
E.printStackTrace();
}
// 反序列化
Try{
FileInputStream fis = new FileInputStream(“./worker.dat”);
ObjectInputStream ois = new ObjectInputStream(fis);
Worker wor = (Worker)ois.readObject();
String name  = wor.getName();
}catch(Exception e) {
E.printStackTrace();
}
}

七、对文件及文件夹操作

7.1 复制文件
指将文件内容复制到指定位置的新文件中，如果目标文件不存在，以目标文件名创建新的文件，并将原有文件内容复制到该文件中，否则覆盖目标文件

String sourceFilePath = “./A.txt”;
String dFilePath = “./B.txt”;
File sourceFile= new File(sourceFilePath); // 创建原文件对象
File dFile = new File(dFilePath); // 创建目标文件对象
Try{
FileInputStream fis  = new FileInputStream(sourceFile); // 创建原文件字节输入流
FIleOutputStream fosD = new FileOutputStream(dFile); // 创建目标文件字节输出流
Byte[] data = new Byte[1024];
Int rs = -1;
While((rs = fis.read(data)) > 0) { // 在循环中读取输入流的数据
fosD.write(data, 0, rs); // 在循环中把数据写入输出流中
}
Fis.close();
fosD.close();
}catch(FileNotFoundException e) {
E.printStackTrace();
}

7.2 复制文件夹
文件夹中可能含有多个文件，或文件夹，必须对他们分别执行复制操作

Public void copy(File[] s, File d) {
If(!d.exists) {
d.mkdir();
}
For(int i = 0; i < s.length; i++) {
If(s[i].isFile()) { // 如果是文件类型，直接进行复制操作
Try{
FileInputStream fis = new FileInputStream(s[i]);
FileOutputStream fos = new FileOutputStream(new File(d.getPath()            + File.separator + s[i].getName()));
Int num = fis.avaliable();
Byte[] data = new byte[num];
If((fis.read(data)) !=  -1){
Out.write(data); // 复制文件内容
}
Fos.close();
Fis.close();

} catch(Exception e) {
      E.printStackTrace();
    }
 }

        If(s[i].isDirectory) { // 如果是文件夹类型
               File des =(new File(d.getPath()+ File.separator + s[i].getName());
              Des.mkdir();
             Copy(s[i].listFiles(), des); // 递归调用方法本身
         }
   }
}

7.3 删除文件夹
File类的delete方法用来删除指定文件，必须使用目标文件路径创建一个File类的实例对象

File file = new File(“./aaaa.txt”);
deleteFile(file);

Public void deleteFile(File file) {
    If(!file.exists()) {
       // 文件不存在，直接返回
      Return；
    }
   Boolean rs = file.delete();
}

7.4 分行写入文件
FileWriter类 封装到BufferWriter类的缓冲字符流中，实现缓冲字符输出流，并可以newLine()方法实现数据的分行写入

String filePath = “./file.txt”;
File file = new File(filePath);
Try{
    FileWriter fw = new FileWriter(file); // 创建文件字符输出流
    BufferedWriter bw = new BufferedWriter(fw); // 使用缓冲数据流封装输出流
    Bw.write(“分行写入文件”);
    Bw.newLine();  // 写入换行符
    Bw.write(“mmmm”);
    Bw.flush(); // 刷新缓冲区
} catch(IOException e) {
    E.printStackTrace();
}
显示全文