javaSE (六):IO

目录

一、File类

● File类的构造方法

● File类的常用方法

二、输入及输出的概念

三、输入流与输出流

● 流按着数据的传输方向分为:

●从数据流编码格式上划分为:

● InputStream和OutputStream的子类都是字节流

● Reader和Writer的子类都是字符流

四、字节流与字符流

● 字节流中常用类

● 字符流中常用类

五、输入输出节点字节流

●InputStream的基本方法

● OutputStream的基本方法

六、节点流与处理流

● 根据封装类型不同流又分为

● 节点流:

 节点流中常用类

 ● 处理流:

处理流中常用类

 ①字节流

 ②字符流

七、输入输出节点字符流

●Reader 的基本方法

●Writer 的基本方法

八、对象输入输出流——对象序列化


一、File类

①File类是java.io包中很重要的一个类;

②File类的对象可以表示文件,还可以表示目录,在程序中一个File类对象可以代表一个文件或目录

③File对象可以对文件或目录的属性进行操作,如:文件名、最后修改日期、文件大小等;

④File对象无法操作文件的具体数据,即不能直接对文件进行读/写操作。

  File类的构造方法

javaSE (六):IO_第1张图片

● File类的常用方法

javaSE (六):IO_第2张图片

 !!!具体实现可以看下面这段代码:

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 操作

javaSE (六):IO_第3张图片

三、输入流与输出流

● 流按着数据的传输方向分为:

输入流:往程序中读叫输入流。

输出流:从程序中往外写叫输出流。

●从数据流编码格式上划分为:

  ● 字节流

  ● 字符流

● 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();
    }
}

你可能感兴趣的:(JavaSE,java,算法,开发语言)