输入和输出处理（二）

 

1、File类是在java.io 包下,在程序中操作⽂件和⽬录

  1. 递归 
    package com.file;

import java.io.File;

//递归操作
public class FileTest {
    public static void main(String[] args) {
        File file = new File("C:\\Users\\hsk\\Desktop");
        listSubFiles(file);
    }
//    地柜遍历所有目录
    public static void listSubFiles(File dir){
        //判断目录不是空的，且还是一个文件夹
        if (dir!=null && dir.isDirectory()){
            //遍历files
            File[] files = dir.listFiles();
            if (files!=null){
                for (File file : files) {
                    listSubFiles(file);
                }
            }

        }
        System.out.println(dir);
    }
}

     

2、IO包

  1. 什么是IO:(in/out) 针对⽂件内容操作的,java中的I/O操作主要是使⽤java.io包下的内容进⾏输出和输出操作。
  2.  输⼊(也叫读取数据),输出也叫写出数据。

3、IO流分类

  1. 根据数据的流向,分为输⼊流和输出流
    1. 输⼊流:把数据从其他设备上读取到内存中的流以InputStream Reader结尾。
    2. 输出流: 把数据从内存中写出到其他设备上的流以OutputStream Writer结尾。
  2. 根据数据的类型分为: 字节流和字符流
    1. 字节流: 以字节为单位,读写数据的流,⽐如读取图⽚或视频以InputStream OutputStream结尾。
    2.  字符流: 以字符为单位,读写数据的流,⽐如读取⽂本⽂件以Reader Writer结尾。
  3. package com.iotest;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
//使用输出流写文件
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //创建操作文件输出流对象
        File file =new File("D:\\Java\\大数据123\\day0928\\file\\test1.txt");
        OutputStream outputStream =new FileOutputStream(file);
        //向文件写内容
        outputStream.write(99);
        outputStream.write(98);
        //关闭输出流
        outputStream.close();
    }
}

4、字节流

  1. 字节输⼊流InputStream 读⽂件,常⽤⽅法read(),close()。
  2. ⽤它的⼦类FileInputStream 专门进⾏⽂件的读取操作。
  3. package com.iotest;

import java.io.*;

public class Demo03InputStreamTest {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        File file =new File("day1005/src/data/aaa.txt");
        InputStream inputStream =new FileInputStream(file);
        //读取文件内容
        int read = inputStream.read();
        System.out.println(read);
        System.out.println((char)read);
        read = inputStream.read();
        System.out.println(read);
        System.out.println((char)read);
        //关闭
        inputStream.close();
    }
}
  4. 循环读取⽂件内容 
    package com.iotest;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Demo04InputStreamTest {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        File file =new File("day1005/src/data/aaa.txt");
        InputStream inputStream =new FileInputStream(file);
        //循环读取文件内容
       int b;
       while ((b=inputStream.read())!=-1){
            System.out.print((char)b);
        }
        //关闭
        inputStream.close();
    }
}
  5. 字节输⼊流和输出流综合例⼦ 
    package com.iotest;

import java.io.*;

public class Demo05InputStreamOutputStreamTest {
    public static void main(String[] args) throws IOException {
        //创建一个输入流对象
        File file =new File("day1005/src/data/aaa.txt");
        InputStream inputStream =new FileInputStream(file);
        //创建一个输出对象
        OutputStream outputStream =new FileOutputStream("day1005/src/data/ccc.txt");
        //流对象，把输入流的内容放到输出流里
        int len;//定义一个int类型长度
        byte[] b = new byte[1024];
        while ((len=inputStream.read(b))!=-1){
            outputStream.write(b,0,len);
        }
        //关闭流
        inputStream.close();
        outputStream.close();
    }
}

     

5、字符流

  1. 当使⽤字节流读取⽂本⽂件时,如果遇到中⽂字符,就会出问题,因为⼀个中⽂占⽤多个字节,需要⽤字符流,以字符为单位,读取数据。
  2. 字符输⼊流 Reader⼦类 FileReader。
  3. 字符输出流 Writer ⼦类 FileWriter。
  4. package com.iotest;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
//使用字符数组读取文件
public class Demo06ReaderTest {
    public static void main(String[] args) throws IOException {
        //创建一个字符输入流
        Reader reader =new FileReader("day1005/src/data/bbb.txt");
        //字符数组读取
        char[] c =new char[1024];
        int len;
        while ((len=reader.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        //关闭输入流
        reader.close();
    }
}

     

  5. package com.iotest;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
//使用字符数组读取文件
public class Demo06ReaderTest {
    public static void main(String[] args) throws IOException {
        //创建一个字符输入流
        Reader reader =new FileReader("day1005/src/data/bbb.txt");
        //字符数组读取
        char[] c =new char[1024];
        int len;
        while ((len=reader.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        //关闭输入流
        reader.close();
    }
}

     

  6. 字符输⼊流和输出流综合案例
  7. package com.iotest;

import java.io.*;

public class Demo08ReaderWriterTest {
    public static void main(String[] args) throws IOException {
        Reader reader =new FileReader("day1005/src/data/bbb.txt");
        Writer writer =new FileWriter("day1005/src/data/eee.txt");
        char[] c =new char[1024];
        int len;
        while ((len=reader.read(c))!=-1){
            new String(c,0,len);
            writer.write(c);
        }

        reader.close();
        writer.close();

    }
}

     

  8. 复制⼀个视频⽂件(使⽤字节流) 
    package com.iotest;


import java.io.*;

public class Demo09CopyVideo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long start =System.currentTimeMillis();
        InputStream inputStream =new FileInputStream("C:\\Users\\hsk\\Desktop\\图1.jpg");
        //创建一个输出流对象
        OutputStream outputStream = new FileOutputStream("F:\\图1.jpg");
        int b;
        while ((b=inputStream.read())!=-1){
            outputStream.write(b);
        }
        inputStream.close();
        outputStream.close();
        //记录结束时间
        long end =System.currentTimeMillis();
        System.out.println("复制视频的时间为："+(end-start)+"毫秒");
    }
}

     

6、缓冲流

  1. 提⾼读和写的速度
  2. 字节输⼊流InputStream --->字节输⼊缓冲流BufferedInputStream
  3. 字节输出流OutputStream-->字节输出缓冲流BufferedOutputStream
  4. 字符输⼊流Reader --->字符输⼊缓冲流 BufferedReader
  5. 字符输出流Writer---->字符输出缓冲流 BufferedWriter
  6. package com.iotest;


import java.io.*;

public class Demo09CopyVideoBuffered {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long start =System.currentTimeMillis();
        BufferedInputStream inputStream =new BufferedInputStream(new FileInputStream("C:\\Users\\hsk\\Desktop\\图1.jpg"));
        //创建一个输出流对象
        BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream("F:\\图1.jpg"));
        int b;
        while ((b=inputStream.read())!=-1){
            outputStream.write(b);
        }
        inputStream.close();
        outputStream.close();
        //记录结束时间
        long end =System.currentTimeMillis();
        System.out.println("复制视频的时间为："+(end-start)+"毫秒");
    }
}

7、转换流

  1. 指定读写⽂件时使⽤的编码格式。
  2. package com.iotest;

import java.io.FileInputStream;
import java.io.IOException;

import java.io.InputStreamReader;

public class Demo10ReadGBK {
    public static void main(String[] args) throws IOException {
        //创建一个输入流对象
        InputStreamReader reader =new InputStreamReader(new FileInputStream("day1005/src/data/fff.txt"),"GBK");
        //读取文件
        int read;
        while ((read=reader.read())!=-1){
            System.out.print((char)read);
        }
        //关闭流
        reader.close();
    }
}

8、序列化和反序列化

  1. 把对象转化为字节序列 >>> 把内存中的对象--通过序列化-->流对象。
  2.  字节序列再还原成java对象 >>> 把流--通过反序列化-->内存中的对象。
  3. 序列化的步骤
    1. 实现 Serializable 接⼝
    2. 创建对象输出流
    3. 调⽤writerObject()⽅法将对象写⼊⽂件
    4. 关闭流
    5. package com.studenttext;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
      package com.studenttext;

import java.io.*;

public class StudentTest {
    public static void main(String[] args) throws IOException {
        Student student =new Student("未文选",56);
        //创建对象的输出流
        OutputStream outputStream =new FileOutputStream("day1005/src/data/ggg.txt");
        ObjectOutputStream oos =new ObjectOutputStream(outputStream);
        //实现对象的序列化
        oos.writeObject(student);
        //关闭流
        outputStream.close();
    }
}
  4. 反序列化
    1. 实现 Serializable 接⼝
    2. 创建对象输⼊流
    3. 调⽤readObject()⽅法读取对象
    4. 关闭流
    5. package com.studenttext;

import java.io.*;

public class StudentTest2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建对象的输入流
        InputStream inputStream =new FileInputStream("day1005/src/data/ggg.txt");
        ObjectInputStream ois =new ObjectInputStream(inputStream);
        //实现对象的序列化
        Student student =(Student)ois.readObject();
        System.out.println(student.getName()+","+student.getAge());
        //关闭流
        ois.close();
        inputStream.close();
    }
}

       

posted @ 2023-10-07 01:37  韩世康  阅读(8)  评论(0)  编辑  收藏  举报