I/O操作

文章目录

I/O操作
- 一：文件操作
- - 1.判断文件是否存在
  - 2.判断是否为文件
  - 3.创建文件与删除文件
  - 4.创建目录
- 二：I\O流操作
- - 1.（1）用字节流进行文件写入（OutputStream）
  - 1.（2）用字符输出流（Writer）进行写操作
  - 2.用字节输入流来读取数据
  - 3.文件拷贝实例代码（内包含了读取和写入的详细操作）
  - 4.转换流
  - 5.字符编码
  - 6.内存流
  - 7.打印流（PrintWriter）
  - 8.系统输出
  - 9.系统输入
  - 10.两种输入流
  - - 1.BufferedReader类
    - 2.java.util.Scanner类（⭐）
    - - 2.1 Scanner的基本用法用法：
      - 2.2使用Scanner操作文件：（⭐）
  - 11.序列化

一：文件操作

File类并不会操作文件内容

1.判断文件是否存在

        File file = new File("E:\\文件测试\\测试2");
        System.out.println(file.exists());  //true

文中的是一个路径，所以exists方法是判断路径是否存在，而不是该路径是不是文件

2.判断是否为文件

        File file = new File("E:\\文件测试\\测试2");
        System.out.println(file.isFile());   //false

这里的E:\文件测试\测试2是一个文件夹，所以为false

3.创建文件与删除文件

        File file = new File("E:\\文件测试\\测试2\\lala");
        if(file.createNewFile()) {<!-- -->
            System.out.println("create file success!");
        }else {<!-- -->
            System.out.println("create file fail");
        }
        System.out.println(file.isFile());  //true

该段代码中，E:\文件测试\测试2 是我们windows下已经有的路径，执行上操作就会自动在测试2这个文件夹下新建一个lala.txt文本文档，当不指定新建文件格式时，默认为文本文档； 若文件已存在，则会创建失败；
所以File类提供的createNewFile是创建一个文件，而不是文件夹或路径；
删除文件就不说了，为File类的：delete（）方法，返回值与创建文件一样，为boolean；

4.创建目录

File提供的：public boolean mkdirs()

        File file = new File("E:\\文件测试\\测试3\\测试3-1");
        if(file.mkdirs()) {<!-- -->
            System.out.println("创建目录成功");
        }else {<!-- -->
            System.out.println("创建目录失败");
        }

原本我们文件测试下没有测试3，更没有测试3-1，执行上面后，文件测试这个目录中新建了一个名为测试3的文件夹，测试3文件夹中又新建了测试3-1的文件夹，注意这里新生成的都是文件夹；
File类还提供了：public boolean mkdir() ，这个方法与上面不同的是，当file对象的父目录不存在时，就会创建路径失败，而mkdirs方法是无论父路径是否存在，如若不存在，就创建对应的所有父路径；

二：I\O流操作

File类不支持文件内容处理，如果要处理文件内容，必须要通过流的操作模式来完成。流分为输入流和输出流。

在java.io包中，流分为两种：字节流与字符流

字节流：InputStream、OutputStream
字符流：Reader、Writer

OutPutStream、InputStream 都是抽象类，所以不能直接创建对象使用，需要用它的子类，看它们的定义：

public abstract class InputStream implements Closeable
public abstract class OutputStream implements Closeable, Flushable

Closeable这个接口主要是关于close的方法，Flushable是关于flush（写入时刷新，读取不需要）的方法

1.（1）用字节流进行文件写入（OutputStream）

OutPutStream、InputStream 都是抽象类，所以不能直接创建对象使用，需要用它的子类，看它的定义：

//如果是  E:\\文件测试\\测试   就会编译报错，路径必须为一个具体文件，而不能为文件夹
		File file = new File("E:\\文件测试\\测试\\hello.txt");
//第一种写法：
        //写入数据时一定要判断父路径是否存在，若果不存在则给他创建
//        if(!file.getParentFile().exists()) {<!-- -->
//            file.getParentFile().mkdirs();
//        }
//        OutputStream out = new FileOutputStream(file);
//        String str = "i love you";
//        byte[] buff = str.getBytes();
//        out.write(buff);
//        out.flush();
//        out.close();

//第二种写法：
        if(!file.getParentFile().exists()) {<!-- -->
            file.getParentFile().mkdirs();
        }
        try(OutputStream out = new FileOutputStream(file)){<!-- -->
            String str = "i love you";
            byte[] buff = str.getBytes();
            out.write(buff);
            //刷新缓存，最好写上
            out.flush();
        }catch(IOException e) {<!-- -->
            e.printStackTrace();
        }

对于IO操作属于资源处理，所有的资源处理操作(IO操作、数据库操作、网络)最后必须要进行关闭； 第一种写法和第二种写法的区别就是：第一种要手动close，第二种是从JDk1.7开始追加了一个AutoCloseable接口，这个接口的主要目的是自动进行关闭处理，使用它必须结合try…catch；
在操作字节输出流时，给定的file对象必须应该为文件类型（⭐），即不能是一个文件夹，如果这个文件不存在，（前提是这个文件的父目录必须存在），则会自动创建这个文件，即不用使用createNewFile方法来新建； ⭐
进行写入时，每执行的时候，会将目标写入文件中清空，然后写入，若果想保留目标写入文件中的内容，继续添加内容的话，需要在创建OutputStream类对象时调用另一个有参构造，即：（上面代码只用改这一处就行）
```
 OutputStream out = new FileOutputStream(file，true)
```

1.（2）用字符输出流（Writer）进行写操作

public abstract class Writer implements Appendable, Closeable, Flushable

该类实现了三个接口，相对于字节输出流多了Appendable接口
该类也有write方法，如下所示，

    public void write(String str) throws IOException

字符输出流与字节输出流的使用方法几乎一模一样，**最大的区别就是该类提供方的write方法可以直接以字符串作为参数进行写入，无须转为字节，**除了这其他使用基本不变，同样的，Writer作为一个抽象方法，我们需要用FileWriter这个子类来为它实例化对象。

        File file = new File("E:\\文件测试\\测试2\\test.txt");
        try(Writer writer = new FileWriter(file,true)) {<!-- -->
            writer.write("i like you dream!!!"); 
        }catch (IOException e) {<!-- -->
            e.printStackTrace(); 
        }

2.用字节输入流来读取数据

输入输出其实都差不多，这里直接呈上代码：

        File file = new File("E:\\文件测试\\测试2\\test.txt");
        try(InputStream in = new FileInputStream(file)) {<!-- -->
            byte[] arr = new byte[10];
            //如果这里就先定义了 int len = in.read(arr) 的话，下面while条件里就会从第二次开始读取了               //⭐
            int len = -1;
            while((len = in.read(arr)) != -1) {<!-- -->
                String str = new String(arr,0,len);
                System.out.println(str);
            }
        }

在上面的例子中，我们定义的byte数组用来接受每次读取的字节数据，你可以随意设置这个数组的大小，但一般为1024*1024，这里我们为了凸显特性选取了10，假如我们没有这个while循环来一直读取的话，读一次是读不完的，

当读取完时，read函数将返回-1 ，
每次读取结束，下一次读取时是接着上一次结束的地方继续读取的！

3.文件拷贝实例代码（内包含了读取和写入的详细操作）

package com.bitten.file;
import java.io.*;
/**
 * @Author : YangY
 * @Description : 文件拷贝
 * @Time : Created in 16:33 2019/3/31
 */
public class FileCopyUtil {<!-- -->
    public static void main(String[] args) {<!-- -->
        //destFilePath必须是一个具体文件的路径，不能为文件夹；⭐⭐
        cp("E:\\文件测试\\测试\\hello.txt","E:\\文件测试\\测试2\\test.txt");
    }

    /**
     *
     * @param sourceFilePath:源文件
     * @param destFilePath：目的文件
     */
    public static void cp(String sourceFilePath,String destFilePath) {<!-- -->
        checkArgumentNotNull(sourceFilePath,"souce file path must not be NULL!!");
        checkArgumentNotNull(destFilePath,"dest file path must not be NULL!!");
        File souceFile = new File(sourceFilePath);
        checkFile(souceFile,"SouceFile must not be null!!");
        File destFile = new File(destFilePath);
        checkDestFile(destFile);
        dataCopy(souceFile,destFile);

    }
    public static void checkArgumentNotNull(Object args, String msg) {<!-- -->
        if(args == null ) {<!-- -->
            throw new IllegalArgumentException(msg);
        }
    }

    private static void checkDestFile(File file) {<!-- -->
        //如果父目录不存在，则会copy失败，为了避免这，如果不存在，我们给它创建对应的父目录；
        if(!file.getParentFile().exists()) {<!-- -->
            file.getParentFile().mkdirs();
        }
    }

    private static void checkFile(File file,String msg) {<!-- -->
        //源文件不能为空，而且必须为文件，是目录的话就不行，得抛出异常；
        if(file == null || !file.exists() ) {<!-- -->
            throw new IllegalArgumentException(msg);
        }
    }

    /**
     * 真正实现拷贝得方法
     * @param souce
     * @param dest
     */
    private static void dataCopy(File souce, File dest) {<!-- -->
        long start = System.currentTimeMillis();
        try(InputStream in = new FileInputStream(souce);
            OutputStream out = new FileOutputStream(dest);
        ){<!-- -->
            byte[] buff = new byte[1024*1024];  //每次传输1024*1024个字节，即1M
            int length = -1;
            //当read方法返回值为-1时，代表已经将数据读取完；
            while((length=in.read(buff)) != -1) {<!-- -->
                out.write(buff,0,length);
            }
            out.flush();
            long end = System.currentTimeMillis();
            System.out.println("COPY SUCCESS!!!"+"耗时："+(end-start));
        }catch(IOException e) {<!-- -->
            e.printStackTrace();
        }
    }
}

4.转换流

在Java中，还提供了字节流转换为字符流的类：

OutputStreamWriter :将字节输出流变为字符输出流（Writer对于文字的输出要比OutputStream方便）InputStreamReader :将字节输入流变为字符输入流（InputStream读取的是字节，不方便中文的处理）

看看这两个类的定义：

public class OutputStreamWriter extends Writer
public class InputStreamReader extends Reader

我们可以看到他们的继承关系，可以作为了解

5.字符编码

了解：在开发之中使用的编码只有一个：UTF-8

6.内存流

对于内存流也分为两类：

字节内存流:ByteArrayInputStream、ByteArrayOutputStream
字符内存流:CharArrayReader、CharArrayWriter

下面看一个对两个文件进行合并的例子：

package com.bitten.file;

import java.io.*;

/**
 * @Author : YangY
 * @Description :  进行两个文件的合并
 * @Time : Created in 19:06 2019/4/5
 */
public class TestFileMerge {<!-- -->

    /*
第一种思路
1. data-a.txt  =>  data.txt
2. data-b.txt append => data.txt

第二种思路 : 适合小量的合并，一般不会采取这种措施
1. data-a.txt  => ByteArrayOutputStream
2. data-b.txt  => ByteArrayOutputStream
3. ByteArrayOutputStream byte[] => FileOutputStream

  */

    public static void main(String[] args) {<!-- -->
        String fileA = "E:" + File.separator + "文件测试" + File.separator + "测试" + File.separator + "data-a.txt";
        String fileB = "E:" + File.separator + "文件测试" + File.separator + "测试" + File.separator + "data-b.txt";
        String file = "E:" + File.separator + "文件测试" + File.separator + "测试" + File.separator + "data.txt";

        try (FileInputStream ain = new FileInputStream(fileA);
             FileInputStream bin = new FileInputStream(fileB);
             ByteArrayOutputStream bout = new ByteArrayOutputStream();
             FileOutputStream fout = new FileOutputStream(file);
        ) {<!-- -->
            byte[] buff = new byte[4];
            int len = -1;
            //ain  -> bout
            while ((len = ain.read(buff)) != -1) {<!-- -->
                bout.write(buff, 0, len);
            }

            //bin  -> bout
            while ((len = bin.read(buff)) != -1) {<!-- -->
                bout.write(buff, 0, len);
            }

            //bout -> fout
            byte[] joinData = bout.toByteArray();
            fout.write(joinData);
            fout.flush();
        } catch (IOException e) {<!-- -->

        }
    }
}

7.打印流（PrintWriter）

打印流分为字节打印流：PrintStream、字符打印流:PrintWriter，以后使用PrintWriter几率较高。
来看他们的定义：

public class PrintStream extends FilterOutputStream
    implements Appendable, Closeable

public class PrintWriter extends Writer

打印流的设计属于装饰设计模式：核心依然是某个类的功能，但是为了得到更好的操作效果，让其支持的功能更多一些

        PrintWriter printWriter = new PrintWriter(new FileOutputStream(new File("E:"+
                File.separator+"文件测试" + File.separator
                +"测试"+File.separator+ "hello.txt")));
        printWriter.print(3);
        printWriter.print("lalallala");
        printWriter.print(3.16);
        //要习惯加上flush，不然有时候会看不到输出
        printWriter.flush();

8.系统输出

面试考点：System.out.println()分别代表啥

System表示类名

out表示对象，printStream

print属于方法，属于out对象的方法

我们可以看到System类中out的定义如下：（可见out为一个PrintStream类的对象常量）

    public final static PrintStream out = null;

系统输出一共有两个常量:out、err,并且这两个常量表示的都是PrintStream类的对象。

out输出的是希望用户能看到的内容
err输出的是不希望用户看到的内容

out和err其实在开发中用处很少，会被日志所代替
下面看一段简单代码：

        PrintStream outputStream = System.out;
        outputStream.println("lalalla");

9.系统输入

System.in对应的类型是InputStream ，而这种输入流指的是由用户通过键盘进行输入(用户输入)。java本身并没有
直接的用户输入处理，如果要想实现这种操作，必须使用java.io的模式来完成；

在实际操作中，很少用System.in，因为这个用起来还要结合内存流，很麻烦；

10.两种输入流

1.BufferedReader类

这个是十多年前Java用的输入类，所以不多讲解；

2.java.util.Scanner类（⭐）

打印流解决的是OutputStream类的缺陷，BufferedReader解决的是InputStream类的缺陷。而Scanner解决的是
BufferedReader类的缺陷(替换了BufferedReader类)
Scanner是一个专门进行输入流处理的程序类，利用这个类可以方便处理各种数据类型，同时也可以直接结合正
则表达式进行各项处理，在这个类中主要关注以下方法：

先来看它的构造方法：

    public Scanner(InputStream source) {<!-- -->
        this(new InputStreamReader(source), WHITESPACE_PATTERN);
    }
//可见它需要一个InputStream作为参数，而我们又知道，System.in正是InputStream类型；

判断是否有指定类型数据: public boolean hasNextXxx()

        Scanner scanner = new Scanner(System.in);
        System.out.println( scanner.hasNextInt());

取得指定类型的数据: public 数据类型 nextXxx()
定义分隔符:public Scanner useDelimiter(Pattern pattern)

2.1 Scanner的基本用法用法：

        Scanner scanner = new Scanner(System.in) ;
        System.out.println("请输入数据：") ;
        if (scanner.hasNext()) {<!-- --> // 有输入内容,不判断空字符串
            System.out.println("输入内容为: "+scanner.next());
        }
        scanner.close() ;

输出：
请输入数据：
ijbhu
输入内容为: ijbhu

Process finished with exit code 0

2.2使用Scanner操作文件：（⭐）

public class Test {<!-- -->
    public static void main(String[] args) throws Exception{<!-- -->
        Scanner scanner = new Scanner(new FileInputStream("E://文件测试测试print.txt"));
        //以c为分隔符；
        scanner.useDelimiter("c");
        if(scanner.hasNext()) {<!-- -->
            System.out.println(scanner.next());
        }
        scanner.close();
    }
}

输出：
aaa
bbbbb

已知在文件测试测试print.txt中的数据为：
aaa
bbbbb
ccccc

11.序列化

对象序列化指的是：将内存中保存的对象变为二进制数据流的形式进行传输，或者是将其保存在文本中。但是并不
意味着所有类的对象都可以被序列化，严格来讲，需要被序列化的类对象往往需要传输使用，同时这个类必须实现
java.io.Serializable接口。但是这个接口并没有任何的方法定义，只是一个标识而已。

如果要想实现序列化与反序列化的对象操作，在java.io包中提供有两个处理类:ObjectOutputStream、
ObjectInputStream

I / O操作详细解析