Java 输入输出流处理

Java 输入输出流处理

一、File类

方法名称	说明
boolean exists( )	判断文件或目录是否存在
boolean isFile( )	判断是否是文件
boolean isDirectory( )	判断是否是目录
String getPath( )	返回此对象表示的文件的相对路径名
String getAbsolutePath( )	返回此对象表示的文件的绝对路径名
String getName( )	返回此对象表示的文件或目录的名称
boolean delete( )	删除此对象指定的文件或目录
boolean createNewFile( )	创建名称的空文件，不创建文件夹
long length()	返回文件的长度，单位为字节, 如果文件不存在，则返回 0L

public static void main(String[] args) {
    // 创建File类对象
    File file1 = new File("src\\com\\spark\\demo\\demo.txt");
    File file2 = new File("src\\com\\spark\\demo\\test");

    // 通过file调用方法实现对文件属性的操作

    // exists():判断文件或目录是否存在
    boolean result1 = file1.exists();
    System.out.println("file1对象指向的文件存在：" + result1);
    boolean result2 = file2.exists();
    System.out.println("file2对象指向的目录存在：" + result2);

    // boolean isFile():判断是否是文件
    // isDirectory():判断是否是目录
    boolean result3 = file1.isFile();
    System.out.println("file1对象指向的是一个文件：" + result3);
    boolean result4 = file1.isDirectory();
    System.out.println("file1对象指向的是一个目录：" + result4);
    System.out.println("file2对象指向的是一个文件：" + file2.isFile());
    System.out.println("file2对象指向的是一个目录：" + file2.isDirectory());

    // String getPath():返回此对象表示的文件的相对路径名
    String path = file1.getPath();
    System.out.println("file1对象指向的文件路径：" + path);

    // String getAbsolutePath():返回此对象表示的文件的绝对路径名
    String absolutePath = file1.getAbsolutePath();
    System.out.println("file1对象指向的文件路径：" + absolutePath);

    // boolean createNewFile():创建名称的空文件，不创建文件夹
    File file3 = new File("test.txt");
    File file4 = new File("src\\com\\spark\\demo\\a");
    File file5 = new File("src\\com\\spark\\demo\\b");
    File file6 = new File("src\\com\\spark\\demo\\mm\\aa\\bb");
    try {
        boolean result5 = file3.createNewFile();
        System.out.println("创建成功：" + file4.createNewFile());
        System.out.println("file3对象指向的文件创建成功：" + result5);
        // mkdir()
        // mkdir()
        System.out.println("目录创建成功：" + file5.mkdir());
        System.out.println("文件夹创建成功：" + file6.mkdirs());
    } catch (IOException e) {
        e.printStackTrace();
    }

    System.out.println(file3.getPath());
    System.out.println(file3.getAbsolutePath());

    // getName():返回此对象表示的文件或目录的名称
    System.out.println(file1.getName());
    System.out.println(file2.getName());

    // delete():删除此对象指定的文件或目录
    System.out.println("file1对象指向的文件删除成功：" + file1.delete());
    System.out.println("file2对象指向的目录删除成功：" + file2.delete());

    // length():获取文件内容的长度
    File file7 = new File("src\\com\\spark\\demo\\aaaa.txt");
    System.out.println(file7.length());
}

二、FileInputStream

1. InputStream类常用方法

int read( )：从此输入流中读取一个数据字节。

int read(byte[] b)：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

int read(byte[] b,int off,int len)：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

void close( )：关闭字节输入流

int available()：可以从输入流中读取的字节数目

public static void main(String[] args) {
    // 创建File类对象
    File file = new File("src/com/spark/demo/aaaa.txt");
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(file);
        int len = 0;
        while ((len = fis.read()) != -1) {
            char ch = (char) len;
            System.out.println(ch);
        }
        System.out.println();
        System.out.println("程序读取文件完毕");
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 子类FileInputStream常用的构造方法

FileInputStream(File file)：
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(String name)：
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

public static void main(String[] args) {
    // 创建File类对象
    File file = new File("src/com/spark/demo/aaaa.txt");

    // 创建FileInputStream对象
    try(FileInputStream fis = new FileInputStream(file)) {
        // 通过fis对象调用方法将文件里的内容读取进来
        // read()方法需要一个byte类型的参数，准备一个byte类型的参数
        byte[] bytes = new byte[1024];
        /* int read(byte[] bytes):从指定文件中读取数据，将读取的数据存储在一个byte类型的数组中，
           返回值表示从文件中读取的内容长度 */
        int num = fis.read(bytes);
        System.out.println(num);
        for (int i = 0; i < num; i++) {
            System.out.print((char)bytes[i]);
        }
        System.out.println();
        System.out.println("程序读取文件完毕");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

三、FileOutputStream

1. OutputStream类常用方法

void write(int c)

void write(byte[] buf)

void write(byte[] b,int off,int len)

void close()

void flush()：强制把缓冲区的数据写到输出流中

public static void main(String[] args) {
	OutputStream os = null;

	try {
		// 创建一个OutputStream类对象指向FileOutputStream类对象
		// FileOutputStream(String
		// path):通过此构造方法创建的对象，使用write()方法写入数据的时候，会将文件中原来的数据进行覆盖
		// FileOutputStream(String path,boolean
		// bool):通过此构造方法创建的对象，并将构造方法第二个参数设置为true，使用write()方法写入数据的时候，数据写入在文件的末尾位置；第二个参数为false，写入内容会覆盖文件中原来的内容
		// OutputStream os = new FileOutputStream("F:/aaaa.txt");
		os = new FileOutputStream("F:/aaaa.txt", true);
		// 将数据写入到自定的文件中
		os.write(65);
		System.out.println("数据写入完毕");
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		if (os != null) {
			try {
				os.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

2.子类FileOutputStream常用的构造方法

FileOutputStream (File file)

FileOutputStream(String name)

FileOutputStream(String name,boolean append)

public static void main(String[] args) {
	//创建File类对象
	File file= new File("F:/aaaa.txt");
	
	//创建FileOutputStream类对象
	FileOutputStream fos = null;
	try {
		fos = new FileOutputStream(file, true);
		//我要将一串字符串写入到文件中去
		String str = "hello word";
		//getBytes():将字符串编程byte类型的数组
		byte[] bytes = str.getBytes();
		fos.write(bytes);
		System.out.println("数据写入完毕");
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	}finally{
		if(fos!=null){
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

四、BufferedReader类

BufferedReader类Reader类的子类。

BufferedReader类带有缓冲区。

按行读取内容readLine()方法。

1. BufferedReader常用的构造方法

BufferedReader(Reader in)

2. 子类BufferedReader特有的方法

readLine()

public static void main(String[] args) throws IOException {
    // 创建File类对象
    File file = new File("scr/demo.txt");

    // 创建InputStream类对象，但是InputStream是一个抽象类，不能直接创建对象，可以创建它的子类FileStream类对象
    InputStream is = null;
    InputStreamReader ir = null;
    is = new FileInputStream(file);
    ir = new InputStreamReader(is);

    // 读数据
    int num;
    while ((num = ir.read()) != -1) {
        System.out.println((char)num);
    }
    ir.close();
    is.close();
}

五、BufferedWriter类

1. BufferedWriter类常用方法

write(String str)

write(String str,int off,int len)

void close()

void flush()

2. 子类BufferedWriter常用的构造方法

BufferedWriter(OutputStream out)

BufferedWriter(OutputStream out,String charsetName)

public static void main(String[] args) {
    try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/demo.txt", true)))) {
        bw.newLine();
        bw.write("qwertyuiop");
        bw.newLine();
        bw.write("qqqqqqqqqqqq");
        bw.flush();
        System.out.println("数据写入完毕");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

六、读写二进制文件

1. DataInputStream类

FileInputStream的子类

与FileInputStream类结合使用读取二进制文件

2. DataOutputStream类

FileOutputStream的子类

与FileOutputStream类结合使用写二进制文件

public static void main(String[] args) {
    //创建FileInputStream类对象
    FileInputStream fis=null;
    //创建DataInputStream类对象
    DataInputStream dis  =null;
    //创建FileOutputStream类对象
    FileOutputStream fos =null;
    //创建DataOutputStream类对象
    DataOutputStream dos = null;
    try {
        fis = new FileInputStream("F:/beautiful.jpg");
        dis  = new DataInputStream(fis);
        fos = new FileOutputStream("F:/girl.jpg");
        dos=new DataOutputStream(fos);
        int num;
        while((num=dis.read())!=-1){
            dos.write(num);
        }

        System.out.println("图片复制完毕");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally{
        try {
            dos.close();
            fos.close();
            dis.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

七、序列化和反序列化

序列化是将对象的状态写入到特定的流中的过程。

反序列化则是从特定的流中获取数据重新构建对象的过程。

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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

1. 序列化的步骤

① 实现Serializable接口。

② 创建对象输出流。

③ 调用writeObject()方法将对象写入文件。

④ 关闭对象输出流。

注意：使用集合保存对象，可以将集合中的所有对象序列化。

public class ObjectOutPutStreamDemo02 {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;

        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 18));
        list.add(new Student("李四", 43));
        list.add(new Student("王五", 124));
        list.add(new Student("赵丽颖", 18));
        list.add(new Student("迪丽热巴", 18));
        try {
            oos = new ObjectOutputStream(new FileOutputStream("src/com/spark/demo04/test.txt"));
            oos.writeObject(list);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2. 反序列化的步骤

① 实现Serializable接口。

② 创建对象输入流。

③ 调用readObject()方法将对象写入文件。

④ 关闭对象输出流。

public class ObjectInPutStreamDemo01 {
    public static void main(String[] args) {
        try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/com/spark/demo04/test.txt"))) {
            ArrayList arrayList = (ArrayList) ois.readObject();
            for (Object o : arrayList) {
                System.out.println(o);
            }

        }catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

八、总结

（1）File类：操作文件或者目录的属性
File(“文件路径”)
（2）流：传输数据的通道
按照传输方向分类：
输入流：InputStream、Reader
输出流：OutputStream、Writer
按照数据处理单元分类
字节流：InputStream、OutputStream
字符流：Reader、Writer
（3）InputStream类（抽象类）
（4）FileInputStream类（InputStream类子类）
构造方法：
FileInputStream(File file)
FileInputStream(String path)
（5）OutputStream类（抽象类）
（6）FileOutputStream类（OutputStream类子类）
FileOutputStream(File file)
FileOutputStream(String path)
FileOutputStream(File file,boolean bool)
FileOutputStream(String path,boolean bool)
（7）Reader类（抽象类）
（8）InputStreamReader类（Reader类子类）
InputStreamReader(InputStream is)
InputStreamReader(InputStream is,String charset)
（9）FileReader类（InputStreamReader类）
FileReader(File file)
FileReader(String path)
（10）BufferedReader类（Reader类子类）
BufferedReader(Reader re)
（11）Writer类（抽象类）
（12）OutputStreamWriter类（Writer类子类）
OutputStreamWriter(OutputStream os)
OutputStreamWriter(OutputStream os,String charset)
（13）FileWriter类（OutputStreamWriter类的子类）
FileWriter(File file)
FileWriter(String path)
FileWriter(File file,boolean bool)
FileWriter(String path,boolean bool)
（14）BufferedWriter类（Writer类子类）
BufferedWriter(Writer wr)
（15）DataInputStream类
DataInputStream(InputStream in)
（16）DataOutputStream类
DataOutputStream(OutputStream os)
（17）序列化：将对象写入到特定的流中，将对象存储到文件中
反序列化：从特定的流中构造对象对象的过程，从文件中读取对象信息
（18）ObjectOutputStream类（OutputStream类子类）
ObjectOutputStream()
ObjectOutputStream(OutputStream os)
（19）ObjectInputStream类（InputStream类的子类）
ObjectInputStream()
ObjectInputStream(InputStream is)