java io流 教程

io流

1、File类

1.1、File类概述

File类是专门对文件进行操作的类，他只能对文件本身进行操作，不能对文件内容进行操作。

File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

我们这里注意：File和流无关，File不能对文件进行读和写，即不能输入和输出。

1.2、File类的构造方法

1、 public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
2、 public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。
3、 public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

代码实现

            /*通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例*/
            String path="D:\\我的青春我做主.txt";
            File file = new File(path);

            /*从父路径名字符串和子路径名字符串创建新的 File实例。*/
            String parent="D:\\a";
            String child="b.txt";
            File file1 = new File(parent,child);   //相当于   D:\a\\b.txt

            /*从父抽象路径名和子路径名字符串创建新的 File实例。*/
            File file2 = new File("D:\\c");
            String child2="d.txt";
            File file3 = new File(file2, child2);      //相当于   D:\c\\d.txt 

注意：一个File对象，代表硬盘中实际存在的一个文件或者目录。

​ File类构造方法不会给你检验这个文件或文件夹是否真实存在，因此无论该路径下是否存在文件或者目录，都不影响File对象的创建。

1.3、File的常用方法

​ FIle类有许多方法，对于这些方法不需要死记硬背，编程时若用到相关的算法，查看API即可。

方法	说明
public String getAbsolutePath()	返回此File的绝对路径名字符串。
public String getPath()	将此File转换为路径名字符串。
public String getName()	返回由此File表示的文件或目录的名称
public long length(）	返回由此File表示的文件的长度。
public boolean exists()	此File表示的文件或目录是否实际存在
public boolean isDirectory()	此File表示的是否为目录。
public boolean isFile()	此File表示的是否为文件
public boolean delete()	删除由此File表示的文件或目录
public boolean mkdir()	创建由此File表示的目录。
public boolean mkdirs()	创建由此File表示的目录，包括任何必需但不存在的父目录。

**这里特别说明一点：**路径是不区分大小写的

代码实现：这里我们只举例几个方法，其他方法的调用方式一样，

import java.io.File;

public class FileTest2 {
    public static void main(String[] args) {

        File file = new File("D:\\我的青春我做主.txt");

        System.out.println("D:\\我的青春我做主.txt是否存在："+file.exists());

        System.out.println("文件名："+file.getName());

        System.out.println("是否是文件："+file.isFile());

        System.out.println("是否是目录"+file.isDirectory());


    }
}

2、io流

2.1、认识io流

​ 流是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道，

​ 按流动的方向，以内存为基准，分为输入流和输出流，即流向内存的是输入流，流出内存的是输出流。

​ Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据

2.2、io流的分类

根据数据的流向分为：输入流 和 输出流。

• 输入流 ：把数据从其他设备上读取到内存中的流。
• 输出流 ：把数据从内存 中写出到其他设备上的流。

根据数据的类型分为：字节流 和 字符流。

• 字节流 ：以字节为单位，读写数据的流。
• 字符流 ：以字符为单位，读写数据的流。

2.3、使用字节流FileOutputStream写文本文件

​ FileOutputStream称为文件输出流，他是字节输出流OutputStream的子类，他的作用是把内存中的数据输出到文件中。

2.3.1、字节输出流的基本共性功能方法：

• 1、 public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
• 2、 public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
• 3、 public void write(byte[] b)：将 b.length个字节从指定的字节数组写入此输出流。
• 4、 public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。 也就是说从off个字节数开始读取一直到len个字节结束
• 5、 public abstract void write(int b) ：将指定的字节输出流。

2.3.2、FileOutputStream构造方法：

1、 public FileOutputStream(File file)：根据File对象为参数创建对象。
2、 public FileOutputStream(String name)： 根据名称字符串为参数创建对象。

推荐第二种构造方法【开发常用】：

FileOutputStream outputStream = new FileOutputStream("abc.txt");

2.3.3、FileOutputStream写出字节数据

使用FileOutputStream写出字节数据主要通过Write方法，write方法分为三种：

public void write(int b)

public void write(byte[] b)

public void write(byte[] b,int off,int len) //从off 索引开始，len个字节

1、写出字节：write(int b) 每次可以写出一个字节

代码实现：这里小伙伴们注意，输出流，是将数据从内存写到文件中，下面的结果abc，在文件中查看

package day02;

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

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


        FileOutputStream fos = new FileOutputStream("D:\\我的青春我做主.txt");
        // 写出数据
        fos.write(97); // 写出第1个字节
        fos.write(98); // 写出第2个字节
        fos.write(99); // 写出第3个字节
        // 关闭资源
        fos.close();
    }
}

2、写出字节数组：write[byte b] ,每次可以写出数组中的数据

代码实现：

import java.io.IOException;

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


        FileOutputStream fos = new FileOutputStream("D:\\我的青春我做主.txt");

        byte[] bytes = "你好".getBytes();
        fos.write(bytes);
        // 关闭资源
        fos.close();
    }
}

3、写出指定长度字节数组（常用）：write[byte[] b,int off,int len] ，每次写出从off索引开始，len个字节

代码实现：

package day02;

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

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


        FileOutputStream fos = new FileOutputStream("D:\\我的青春我做主.txt");

        byte[] bytes = "abcd".getBytes();

        fos.write(bytes,0,2);
        // 关闭资源
        fos.close();
    }
}

2.4、字节流输入流 FileInputStream

FileInputStream类是文件输入流，从文件读取字节，输入到内存中

2.4.1、字节输入流的基本共性功能方法：

public void close() :关闭次输入流并释放与此流相关的任何系统资源

public abstract int read() : 从输入流读取数据的下一个字节

public int read(byte[] b): 该方法返回的int值代表的是读取了多少个字节，读到几个返回几个，读取不到返回-1

2.4.2、FileInputStream的构造方法

1、 FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
2、 FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名name命名。

这个构造方法，与FileOutputStream的构造方法相似，代码参考FileOutputStream

2.4.3、FileInputStream读取字节数组

1、**读取字节：**read方法，每次可以读取一个字节的数据，返回值为int 类型，读取到文件末尾返回-1

代码实现：(这里注意，D:\我的青春我做主.txt文件是我硬盘上的，内容为abcde，小伙伴你的需要自己创建一个)

package day02;


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

public class FileOutputStream {

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

        FileInputStream fileInputStream = new FileInputStream("D:\\我的青春我做主.txt");

        int read = fileInputStream.read();
        System.out.println((char) read);

        int read2 = fileInputStream.read();
        System.out.println((char)read2);

        fileInputStream.close();
    }

}

运行结果
a
b

改进：循环读取方式

代码实现：

package day02;


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

public class FileOutputStream {

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

        FileInputStream fileInputStream = new FileInputStream("D:\\我的青春我做主.txt");


        int b;
        while((b=fileInputStream.read())!=-1){
            System.out.println((char)b);
        }

        fileInputStream.close();
    }
}
运行结果
a
b
c
d
e

2、使用字节数组读取：read (byte[] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1，

代码实现：

package day02;


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

public class FileOutputStream {

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

        FileInputStream fileInputStream = new FileInputStream("D:\\我的青春我做主.txt");


        int len;
        byte[] bytes = new byte[2];
        while((len=fileInputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));   // len 每次读取的有效字节个数
        }

        fileInputStream.close();
    }
}

在开发中使用字节数组读取，非常常用，开发代码如下

package day02;

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

public class FileOutputStream {

    public static void main(String[] args)  {
        FileInputStream fileInputStream=null;
        try {
           fileInputStream = new FileInputStream("D:\\我的青春我做主.txt");
            byte[] bytes = new byte[1024];
            int len;
           while ((len=fileInputStream.read(bytes))!=-1){
               System.out.println(new String(bytes,0,len));
           }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.5、将一个数据，从一个文件写到另一个文件中

代码实现：

package day02;

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

public class FileTest03 {
    public static void main(String[] args) {
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;

      try {
            fileInputStream= new FileInputStream("D:\\我的青春我做主.txt");
            fileOutputStream = new FileOutputStream("E:\\我的青春我做主.txt");
            byte[] bytes = new byte[2];
            int len;
            while((len=fileInputStream.read(bytes))!=-1){
                fileOutputStream.write(bytes,0,len);
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

2.5、字符流Reader和Writer

2.5.1、Reader和Writer继承图：

2.5.2、字符流的由来：

​ 因为数据编码的不同，因而有了对字符进行高效操作的流对象，字符流本质就是基于字节流读取时，去查了指定的码表，而字节流直接读取中文数据有乱码问题，这是因为字节流读取中文字符时，可能不会显示完整的字符，那是因为一个字符占用多个字节存储。

​ 尽管字节流也能有办法解决乱码的问题，但是比较麻烦，于是就有了字符流，以字符为单位写数据，字符流专门用于处理文本文件，如果处理纯文本的数据，应优先考虑字符流。

2.5.3、字符输入流Reader

1、字符输入流的共性方法

1、public void close() ：关闭此流并释放与此流相关联的任何系统资源。
2、 public int read()： 从输入流读取一个字符。
3、 public int read(char[] d)： 从输入流中读取一些字符，并将它们存储到字符数组 d中

2、FileReader类

FileReader类是Reader抽象类的子类，构造时使用系统默认的字符编码和默认字节缓冲区。

FileReader类的构造方法

1、FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
2、 FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的字符串名称。

3、FileReader读取字符数据

1）读取字符：read 方法，每次可以读取一个字符的数据，返回为int类型，读取到文件末尾，返回-1

代码实现：

package day02;

import java.io.FileReader;
import java.io.IOException;

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

        FileReader fileReader = new FileReader("D:\\我的青春我做主.txt");

        int b;
        while((b=fileReader.read())!=-1){
            System.out.println((char)b);
        }


        fileReader.close();
    }
}

运行结果：
你
好
中
国

进程已结束，退出代码 0

2.5.4、字符输出流Writer

1、字符输出流的基本共性功能方法：

1、void write(int c) 写入单个字符。
2、void write(char[] cbuf)写入字符数组。
3、 abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
4、 void write(String str)写入字符串。
5、void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
6、void flush()刷新该流的缓冲。
7、void close() 关闭此流，但要先刷新它

2、FileWriter类

FileWriter类是Writer抽象类的子类，构造时使用系统默认的字符编码和默认字节缓冲区。

FileWriter类的构造方法

1、 FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
2、FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称

3、FileWriter写出数据

1）写出字符：write(int b) 方法，每次可以写出一个字符数据。

代码实现：

package day02;

import java.io.FileWriter;
import java.io.IOException;

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

        FileWriter fileWriter = new FileWriter("D:\\我的青春我做主.txt");

        fileWriter.write(99);
        fileWriter.write("p");
        fileWriter.write("c");

        fileWriter.close();

    }
}

2.6、缓冲流

缓冲流也叫高效流。

2.6.1、缓冲流的基本原理：

1、使用了底层流对象从具体设备上获取数据，并将数据存储到缓冲区的数组内。
2、通过缓冲区的read()方法从缓冲区获取具体的字符数据，这样就提高了效率。
3、如果用read方法读取字符数据，并存储到另一个容器中，直到读取到了换行符时，将另一个容器临时存储的数据转成字符串返回，就形成了readLine()功能。

也就是说在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

2.6.2、缓冲书写格式为BufferedXxx，按照数据类型分类：

字节缓冲流：BufferedInputStream，BufferedOutputStream
字符缓冲流：BufferedReader，BufferedWriter

1、字节缓冲流
1)构造方法

public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流，注意参数类型为InputStream。
public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流，注意参数类型为OutputStream。

代码实现：

//构造方式一： 创建字节缓冲输入流【但是开发中一般常用下面的格式申明】
FileInputStream fps = new FileInputStream(b.txt);
BufferedInputStream bis = new BufferedInputStream(fps)
 
//构造方式一： 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("b.txt"));
 
///构造方式二： 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));

2)缓冲流实现读写

代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建流对象
        try (
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("py.exe"));
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copyPy.exe"));
        ){
        // 读写数据
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
      
    }
}

2、 字符缓冲流
1)构造方法
相同的来看看其构造，其格式以及原理和字节缓冲流是一样一样的！

public BufferedReader(Reader in) ：创建一个新的缓冲输入流，注意参数类型为Reader。
public BufferedWriter(Writer out)： 创建一个新的缓冲输出流，注意参数类型为Writer。

构造举例，代码如下：

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader(“b.txt”));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter(“b.txt”));

2)字符缓冲流特有方法
字符缓冲流的基本方法与普通字符流调用方式一致，这里不再阐述，我们来看字符缓冲流具备的特有方法。

BufferedReader：public String readLine(): 读一行数据。 读取到最后返回null
BufferedWriter：public void newLine(): 换行,由系统属性定义符号。

readLine方法演示代码如下：

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
         // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        // 定义字符串,保存读取的一行文字
        String line  = null;
        // 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("------");
        }
        // 释放资源
        br.close();
    }
}

newLine方法演示代码如下：

public class BufferedWriterDemo throws IOException {
  public static void main(String[] args) throws IOException  {
      // 创建流对象
      BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
      // 写出数据
      bw.write("你");
      // 写出换行
      bw.newLine();
      bw.write("好");
      bw.newLine();
      bw.write("呀");
      bw.newLine();
      bw.write("中国");
      bw.newLine();
      // 释放资源
      bw.close();
  }
}