Java 基础-傻傻分不清楚的文件操作类

作者: print("") 分类: Java学习 发布时间: 2021-01-31 21:06

为了记住那个是写入那个是读取。有时候傻傻分不清这里为了这我这个的脑瓜子记住,特意写一篇文章,也是给自己强行记住

首先是字节的两个超类

java.io.OutputStream    --->输入【写】
java.io.InputStream      --->输出 【读】

写这个超类,写文件用他的一个子类进行一个操作【字节写入类】

一、写入类

1.1 字节写入类

java.io.FileOutputStream extends OutputStream

构造方法:
FileOutputStream(File file)  创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
FileOutputStream(File file, boolean append)  创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
FileOutputStream(FileDescriptor fdObj)  创建一个向指定文件描述符处写入数据的输出文件流,该文件描述符表示一个到文件系统中的某个实际文件的现有连接。 
FileOutputStream(String name)  创建一个向具有指定名称的文件中写入数据的输出文件流。 
FileOutputStream(String name, boolean append)   创建一个向具有指定 name 的文件中写入数据的输出文件流。 

最简单的写入文件 一个个插入

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01OutpuStream {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream 构造方法中传递写入数据的目的地
        FileOutputStream fos= new FileOutputStream("I:\\a.txt");
        fos.write(97);
        fos.write(97);
        fos.write(97);
        fos.write(97);
        fos.close();
    }
}

还可以这样插入

        byte[] bytes2="你好".getBytes(StandardCharsets.UTF_8);
        System.out.println(Arrays.toString(bytes2));
        ofs.write(bytes2);
        ofs.close();

1.2 字符写入类

然后是字符写入类

java.io.FileWriter extends OutputStreamWriter extends Writer

构造方法:
FileWriter(File file)  根据给定的 File 对象构造一个 FileWriter 对象。 
FileWriter(File file, boolean append)   根据给定的 File 对象构造一个 FileWriter 对象。 
FileWriter(FileDescriptor fd) 构造与某个文件描述符相关联的 FileWriter 对象。 
FileWriter(String fileName)  根据给定的文件名构造一个 FileWriter 对象。 
FileWriter(String fileName, boolean append)  根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。 

最简单的一个方式是这样的

public class Demo02Write {
    public static void main(String[] args) throws IOException {
        FileWriter fw =new FileWriter("day16_File\\2.txt",true);
        fw.write("你好".toCharArray());
        fw.close();
        
    }
}

二、读取类

2.1 字节读取类 FileInputStream

java.io.FileInputStream extends InputStream
构造方法:
FileInputStream(File file)  通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定。 
FileInputStream(FileDescriptor fdObj) 通过使用文件描述符 fdObj 创建一个 FileInputStream,该文件描述符表示到文件系统中某个实际文件的现有连接。 
FileInputStream(String name)  通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的路径名 name 指定。 

最简单的例子:

public class Demo04InputStream {

    public static void main(String[] args) throws IOException {
        FileInputStream file= new FileInputStream("I:\\1.txt");
        int len=0;
        while ((len= file.read()) != -1)
        {
            System.out.println((char)len);
        }
    }
}

还可以通过byte数组的形式获取

 byte[] bytes = new byte[1024];
        int len=0;
        while ((len=file.read(bytes)) !=-1){
            System.out.println(new String(bytes,0,len));
        }

2.2 字符读取类FileReader

java.io.FileReader extends InputStreamReader extends Reader
构造方法:
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader。 
FileReader(FileDescriptor fd) 在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。 
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader。 

简单的例子:

public class Demo01Reader {
    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("I:\\1.txt");

        int len=0;
//        while ((len=file.read())!=-1){
//            System.out.print((char)len);
//
//        }
        //也可以使用char 数组的方式获取。
        char[] str=new char[50];
        while ((len= file.read(str))!=-1){
            System.out.println(new String(str,0,len));
        }
        file.close();

    }
}

通过上面简单的了解了一下 写入文件和读取文件的操作了。那么下面可以来一个复制文件的小例子

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

public class Demo06Copy {
    public static void main(String[] args) throws IOException {
        FileOutputStream files=new FileOutputStream("I:\\demo2.zip");
        FileInputStream fout=new FileInputStream("I:\\demo.zip");
        int len=0;
        long e=System.currentTimeMillis();
        byte[] bytes=new byte[20000];

        while ((len=fout.read(bytes))!=-1){
            files.write(bytes);
        }

        files.close();
        fout.close();
        long s=System.currentTimeMillis();
        System.out.println("复制成功:花费时间为"+(s-e)+"毫秒");
    }
}

三、缓冲流加速

3.1 缓冲流  字节 写BufferedOutputStream

java.io.BufferedOutputStream extends  FilterOutputStream extends OutputStream
构造方法:
BufferedOutputStream(OutputStream out)  创建一个新的缓冲输出流,以将数据写入指定的底层输出流。 
BufferedOutputStream(OutputStream out, int size)   创建一个新的缓冲输出流,以将具有指定缓冲区大小的数据写入指定的底层输出流。 

public class Demo01BufferedOutputStream {
    public static void main(String[] args) throws IOException {

        FileOutputStream fos =new FileOutputStream("day16_File\\1.txt");
        BufferedOutputStream buf= new BufferedOutputStream(fos);
        buf.write("我把数据写入到缓冲区中".getBytes(StandardCharsets.UTF_8));
        buf.close();
        
    }
}

3.2 缓冲流 字节读

java.io.BufferedInputStream extends FilterInputStream extends InputStream

构造方法:
BufferedInputStream(InputStream in)  创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。 
BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。 

简单的案例

public class Demo02BufferedInputStream {
    public static void main(String[] args) throws IOException {

        FileInputStream fos=new FileInputStream("I:\\2.txt");
        BufferedInputStream buf=new BufferedInputStream(fos);

//        int b=0;
//        while ((b=buf.read())!=-1){
//            System.out.print((char)b);
//        }

        byte[] bytes=new byte[1024];
        int len=0;
        while ((len=buf.read(bytes))!=-1){
            System.out.println(new String(bytes));
        }

    }
}

3.3 缓冲流的字符 读和写

缓冲流 字符写类

java.io.BufferedOutputStream extends FilterOutputStream extends OutputStream

构造方法:
BufferedOutputStream(OutputStream out)  创建一个新的缓冲输出流,以将数据写入指定的底层输出流。 
BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流,以将具有指定缓冲区大小的数据写入指定的底层输出流。 

就是直接把OutputStream 对象丢进去

缓冲流 字符读类

java.io.BufferedInputStream extends FilterInputStream extends InputStream 

构造方法:
BufferedInputStream(InputStream in)  创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。 
BufferedInputStream(InputStream in, int size)  创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。 

也和上面是一样的,直接把对象丢进去就可以有一个缓冲的效果

读写放在一起案例

public class Demo04BufferedReader {
    public static void main(String[] args) throws IOException {
        FileReader read= new FileReader("day16_File\\2.txt");
        BufferedReader buf_read= new BufferedReader(read);
        
        FileWriter write=new FileWriter("day16_File\\2.txt");
        BufferedWriter buff_Write=new BufferedWriter(write);
        buff_Write.newLine();
        buff_Write.write("你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀");
        buff_Write.write("你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀");
        buff_Write.newLine();
        buff_Write.write("你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀你好呀");
        buff_Write.close();
        
        int len=0;
        char[] list=new char[1024];

        buf_read.readLine();
        System.out.println(buf_read.readLine());

//        while ((len=buf_read.read(list))!=-1){
//            System.out.println(new String(list));
//        }
        String line;
        while (( line=buf_read.readLine())!=null){
            System.out.println(line);
        }
        buf_read.close();

    }
}

他这里写有一个特殊方法newLine() 是分隔符

读取也有一个readLine() 是获取一行的数据

为了测试缓冲流的加速效果。可以使用如下的代码 这个方式是可以加速的效果有1-2倍

public class Demo03Copy {
    public static void main(String[] args) throws IOException {
        FileOutputStream files=new FileOutputStream("I:\\demo2.zip");
        FileInputStream fout=new FileInputStream("I:\\demo.zip");
        int len=0;
        BufferedInputStream buf_input=new BufferedInputStream(fout);
        BufferedOutputStream buf_out=new BufferedOutputStream(files);
        long e=System.currentTimeMillis();
        byte[] bytes=new byte[1024];
        while ((len=buf_input.read(bytes))!=-1){
            buf_out.write(bytes);
        }
        files.close();
        fout.close();
        long s=System.currentTimeMillis();
        System.out.println("复制成功:花费时间为"+(s-e)+"毫秒");

    }
}

4.编码转换

WIndwos 国内默认是GBK的编码

IED 是UTF-8 默认。那么他们之间的编码转换如下:

java.io.InputStreamReader   InputStreamReader 是字节流通向字符流的桥梁  ---> 按照编码读取文件
java.io.OutputStreamWriter  OutputStreamWriter 是字符流通向字节流的桥梁   -->按照编码写入文件

public class demo04Tran {
    public static void main(String[] args) throws IOException {
        //1.创建InputStreamReader对象、构造方法传递字节输出流指定编码名称为GBK
        InputStreamReader gbk=new InputStreamReader(new FileInputStream("day16_File\\111.txt"),"GBK");
        OutputStreamWriter utf_8 = new OutputStreamWriter(new FileOutputStream("day16_File\\utf-8"),"utf-8");

        int lin=0;
        while ((lin=gbk.read())!=-1){
            utf_8.write(lin);
        }
        gbk.close();
        utf_8.close();
        
    }
}

如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!

发表评论

电子邮件地址不会被公开。 必填项已用*标注