Java-IO流(==＞通俗易懂）

最新推荐文章于 2023-02-26 20:37:06 发布

涉外~攀枝花

最新推荐文章于 2023-02-26 20:37:06 发布

阅读量351

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/m0_54798309/article/details/116031547

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1：文件操作(File类)

1.1构造方法

  File file1=new File("D:\\BBB");

注意：一个File对象代表硬盘中实际存在的一个文件或者目录；无论该路径下是否存在文件或者目录，都不影响File对象的创建。

1.2常用方法

 //常用方法
        File file=new File("D:\\AAA");
        File file1=new File("D:\\AAA");

        System.out.println("文件是否可读"+file.canRead());
        System.out.println("文件是否可写"+file.canWrite());
        System.out.println("文件的名字"+file.getName());
        System.out.println("文件的上级目录"+file.getParent());
        System.out.println("文件是否是一个目录"+file.isDirectory());
        System.out.println("文件是否是一个文件"+file.isFile());
        System.out.println("文件是否隐藏"+file.isHidden());
        System.out.println("文件的大小"+file.length());
        System.out.println(file==file1); //这里是比较对象的地址
        System.out.println(file.equals(file1)); //这里是比较两个对象对应文件的路径

运行结果：
在这里插入图片描述

1.3跟目录相关的方法

   //跟目录相关的方法
        File f1=new File("D:\\a");
        //创建目录
        f1.mkdir();
        //创建多级目录
        File f2=new File("D:\\a\\b\\c");
        f2.mkdirs();
        //删除目录
//        f2.delete();
        //查看目录
        String[] list=f1.list();  //查看list目录下的一级目录
        for (String s:list){
            System.out.println(s);
        }
        File[] files=f2.listFiles(); //查看f2下的文件
        for (File f:files){
            System.out.println(f);
        }

1.4文件搜索(应用）

 @Test
    public static void printFile(File file){
        File[] files = file.listFiles(); //获取指定目录下的文件或目录
        for (File file1:files){
            if(file1.isFile()){ //判断是否为文件
                if(file1.getName().endsWith(".txt")){
                    System.out.println("文件名"+file1.getAbsolutePath());
                }
            }else {
                printFile(file1); //是目录则递归搜索
            }
        }
    }

运行结果：
在这里插入图片描述

2:IO流

2.1IO流的概念

简单来说：IO流就是简单的输入和输出，比如把硬盘中的数据，读取到内存中使用，或者是从网络连接中读取数据到内存中使用，这就称为"输入流"，输出流就是把程序中的数据输出到硬盘或者网络节点。

2.2IO流的分类

2.2.1按照流的流向分，可以分为输入流和输出流。

输入流：只能从中读取数据，而不能向其写入数据。
输出流:只能向其写入数据，而不能向其读取数据。
以程序运行所在的内存来考虑示例图如下：
在这里插入图片描述

java的输入流主要是InputStream和Reader作为基类，而输出流则是主要由outputStream和Writer作为基类。它们都是一些抽象基类，无法直接创建实例。

2.2.2按照操作单元划分，可以划分为字节流和字符流。

字节流和字符流的用法几乎完成全一样，区别在于字节流和字符流所操作的数据单元不同，字节流操作的单元是数据单元是8位的字节，字符流操作的是数据单元为16位的字符。

字节流主要是由InputStream和outPutStream作为基类，而字符流则主要有Reader和Writer作为基类。

2.3字节流

2.3.1字节流的概述

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，在传输时也是使用字节进行传输,我们称之为字节流；字节流可以传输任意文件数据，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.3.2使用字节流进行文件的拷贝

package javaDailyProctice.IOproctice;

import org.junit.Test;

import java.io.*;

public class Test0528 {
    @Test
    public void TestDataStream() throws IOException {
        File file=new File("D:\\AAA\\a.txt");
        InputStream is=new FileInputStream(file);
        //拷贝到D:\AAA\dd\ll.txt的文本中
        OutputStream os=new FileOutputStream("D:\\AAA\\dd\\ll.txt");
        while (true){
            int ch= is.read();
            if(ch==-1){
                break;
            }
            os.write(ch);
        }
        os.flush();
        os.close();
        is.close();
        System.out.printf("拷贝完成！");
    }
}

图解：
在这里插入图片描述
注意事项：
每次程序运行，创建输出流对象，都会清空目标文件中的数据;要想继续追加数据，只需要在输出流的参数中设置一个True即可。FileOutputStream(“D:\AAA\dd\ll.txt”,true);

2.4字符流

2.4.1字符流的概念

就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

2.4.2使用字符流进行文件拷贝


import org.junit.Test;

import java.io.*;

public class Test0528 {
@Test
  public void TestStringStream() throws IOException {
      File file=new File("D:\\AAA\\a1.txt");
      Reader  reader=new FileReader(file);
      Writer writer=new FileWriter("D:\\AAA\\dd\\QQ.txt");
      while (true){
          int read = reader.read();
          if (read==-1){
              break;
          }
          writer.write(read);
      }
      System.out.println("拷贝成功！");
      writer.flush();
      writer.close();
      reader.close();
  }
}

2.5缓冲流

2.5.1缓冲流概念

缓冲流,也叫高效流，是对4个基本的 File* 流的增强；所以也是4个流，按照数据类型分类：
字节缓冲流： BufferedInputStream ， BufferedOutputStream
字符缓冲流： BufferedReader ， BufferedWriter。

2.5.2原理

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO 次数，从而提高读写的效率。

2.5.3使用缓冲流来拷贝文件


import org.junit.Test;

import java.io.*;

public class Test0528 {
@Test
    public void TestHuanChongStream() throws IOException {
        InputStream is=new FileInputStream("D:\\AAA\\a1.txt");
        BufferedInputStream bufin=new BufferedInputStream(is);
        OutputStream os=new FileOutputStream("D:\\AAA\\dd\\QQ.txt");
        BufferedOutputStream bufOut=new BufferedOutputStream(os);
        while (true){
            int read = bufin.read();
            if (read==-1){
                break;
            }
            bufOut.write(read);
        }
        System.out.println("拷贝成功！");
        bufOut.flush();
        bufOut.close();
        bufin.close();
        os.close();
        is.close();
    }
}

import org.junit.Test;

import java.io.*;

public class Test0528 {
@Test
    public void TestHuanChongStream() throws IOException {
   Reader reader=new FileReader("D:\\AAA\\a1.txt");
      BufferedReader bufRead=new BufferedReader(reader);
      Writer writer=new FileWriter("D:\\AAA\\dd\\QQ.txt");
      BufferedWriter BufWrite=new BufferedWriter(writer);
      while (true){
          int read = bufRead.read();
          if(read==-1){
              break;
          }
          BufWrite.write(read);
      }
        System.out.println("拷贝成功！");
      BufWrite.flush();
      BufWrite.close();
      bufRead.close();
      writer.close();
      reader.close();
    }
}

2.6序列化

2.6.1什么是序列化

用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息
字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。
注意事项：
序列化的满足条件：该类必须实现 java.io.Serializable 接口;该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用 transient 关键字修饰.

代码示例：


import org.junit.Test;

import java.io.*;

class Person implements Serializable{
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}


public class Test0528_2 {
    //序列化
    @Test
    public void TestObjiecSteam() throws IOException {
        Person p1=new Person("哈哈",15);
        OutputStream os=new FileOutputStream("D:\\AAA\\Person.txt");
        ObjectOutputStream objOUt=new ObjectOutputStream(os);
        objOUt.writeObject(p1);
        objOUt.flush();
        objOUt.close();
        os.close();

    }
    //反序列化
    @Test
    public  void TestUnobjectStream() throws IOException, ClassNotFoundException {
        InputStream is= new FileInputStream("D:\\AAA\\Person.txt");
        ObjectInputStream objIn=new ObjectInputStream(is);
        Person person =(Person) objIn.readObject();
        System.out.println(person.age);
        System.out.println(person.name);
    }

}