字节流

缓冲流

缓冲流也称为处理流，对文件或者其他目标频繁的操作，效率低，性能差。缓冲流目的是提高程序读取和写出的性能。缓冲流也分为字节缓冲流和字符缓冲流。
使用缓冲流的好处是能够更高效的读写信息，原理是先将数据缓冲起来，然后一起写入或者读取出来。

字节输入流

• InputStream
• FileInputStream
• BufferedInputStream 【BufferedInputStream不是InputStream的直接实现子类，是FilterInputStream的子类】

InputStream是所有字节输入流的抽象类,它提供的两个方法为read()方法和close()方法

InputStream

1. read(byte[] b):该方法提供了将该流对象的b.length()长度的直接放到b对象中,当执行read(byte[] b)后返回值为-1表示该流已经全部读取完成;
2. read(byte[] b,int a,int c):该方法是将以索引为a的字节到长度为c的字节放到b对象中,返回结果为读取的字符长度,如果为-1则证明该对象的所有字节已经读取完成;
3. ** close():关闭流释放资源原因:如果不进行手动关闭,流会一直占用我们的资源,需要进行在finally{}代码块中关闭流;**

FileInputStream 文件输入流

一共有三种构造方式

有两种构造方式是用来读取文件的

第一种:通过文件路径来读取文件

public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("G:\\mm-wiki\\soft\\run.sh");
        fileInputStream.close();

    }

第二种:通过创建的文件对象来读取文件

public static void main(String[] args) throws IOException {
			File file = new File("G:\\mm-wiki\\soft\\run.sh");
        FileInputStream fileInputStream = new FileInputStream(file);
        fileInputStream.close();
    }

读取一整个文件的方式

public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("G:\\mm-wiki\\soft\\run.sh");
        byte[] bytes = new byte[2048];
        int count = 0;
        while ((count =  fileInputStream.read(bytes)) != -1){
            System.out.println(count);
            String s = new String(bytes);
            System.out.println(s);
        }
        fileInputStream.close();
    }

FileInputStream的其它方法

1:available():返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。

2: getChannel():返回与此文件输入流有关的唯一FileChannel 对象。

3:skip(long n) :从输入流中跳过并丢弃 n 个字节的数据。

BufferedInputStream 字节缓冲输入流

该流的作用是用来解决文件传输的效率问题,我们知道当数据存放在内存中时,操作的效率是很高的,但当我们从磁盘中再读取到内存中是非常浪费时间的,该流对象解决的是将磁盘中的文件读取到内存中然后操作内存中的数据来加快文件操作的效率,每当我们内存中的数据操作完成后,然后会在从磁盘中读取到内存中,我们就相当于直接操作的内存中的数据.
使用案例:

public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("D:\\Test\\ttt.txt");
        //字节缓冲流对象
        BufferedInputStream inputStream = new BufferedInputStream(fileInputStream);
        byte[] bytes = new byte[5];
        while (inputStream.read(bytes) != -1){
            inputStream.mark(5);
            inputStream.reset();
            String s = new String(bytes);
            System.out.println(s);
        }
        inputStream.close();
    }

字节输出流:

• OutputStream
• FileOutputStream
• BufferedOutputStream 【BufferedOutputStream不是OutputStream的直接实现子类，是FilterOutputStream的子类】

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
• public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
• public void write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。
• public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
• public abstract void write(int b) ：将指定的字节输出流

FileOutputStream

构造方法

• public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
• public FileOutputStream(String name) ： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

public class FileOutputStreamConstructor throws IOException { public static void main(String[] args) {
	// 使用File对象创建流对象 
	File file = new File("a.txt");
	FileOutputStream fos = new FileOutputStream(file);
	// 使用文件名称创建流对象
	FileOutputStream fos = new FileOutputStream("b.txt");
}
															}

写出字节数据

 write(int b) 方法

public class FOSWrite { public static void main(String[] args) throws IOException { 
	// 使用文件名称创建流对象
	FileOutputStream fos = new FileOutputStream("fos.txt");
	// 写出数据 fos.write(97); // 写出第1个字节 fos.write(98);
	// 写出第2个字节
	fos.write(99);
	// 写出第3个字节
	// 关闭资源
	fos.close();
}
					  }
输出结果： abc

写出字节数组

 public static void main(String[] args) throws IOException {
        File file = new File("D:\\Test2\\ttt.txt");
        String str = "a,b,c,d,e,f,g";
        String[] split = str.split(",");
        FileOutputStream outputStream = new FileOutputStream(file);
        for (String s : split) {
            outputStream.write(s.getBytes());
            outputStream.write("\t\n".getBytes());
        }
        outputStream.close();
    }

写出指定长度的字节数组

  public static void main(String[] args) throws IOException {
        File file = new File("D:\\Test2\\ttt.txt");
        String str = "a,b,c,d,e,f,g";
        String[] split = str.split(",");
        FileOutputStream outputStream = new FileOutputStream(file);
	  //从索引为2的到索引为6的字符
        outputStream.write(str.getBytes(),2,6);
        outputStream.close();
    }

数据追加续写

public static void main(String[] args) throws IOException {
        File file = new File("D:\\Test2\\ttt.txt");
        String str = "a,b,c,d,e,f,g";
        //构造方法后加true后为续写数据,如果为false为覆盖重写
        FileOutputStream outputStream = new FileOutputStream(file,true);
        outputStream.write("\t\n".getBytes());
        outputStream.write(str.getBytes(),2,6);
        outputStream.close();
    }

写出换行

• Windows系统里，每行结尾是 回车+换行 ，即 \r\n ；
• Unix系统里，每行结尾只有 换行 ，即 \n ；
• Mac系统里，每行结尾是 回车 ，即 \r 。从 Mac OS X开始与Linux统一。

BufferedOutputStream

字节缓冲输出流

public static void main(String[] args) throws IOException {
       //读取文件
        File fileIn = new File("D:\\Linux相关安装包\\CentOS-7-x86_64-DVD-1908.iso");
        //输出文件
        File fileOut = new File("H:\\CentOS-7-x86_64-DVD-1908.iso");
        FileOutputStream fileOutputStream = new FileOutputStream(fileOut);
        //字节输出缓冲流
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        //文件输入流
        FileInputStream fileInputStream = new FileInputStream(fileIn);
        byte[] bytes = new byte[2048000];
        while (fileInputStream.read(bytes) != -1){
            bufferedOutputStream.write(bytes);
        }
        bufferedOutputStream.close();
        fileInputStream.close();
        fileOutputStream.close();
        fileInputStream.close();
    }