JAVASE基础 Item -- IO流之字节流_java item 流

    fos.write("hello,IO".getBytes());
    fos.write("java".getBytes());

    //释放资源
    //关闭此文件输出流并释放与此流有关的所有系统资源。
    fos.close();
    /\*

* 为什么一定要close()呢?
* A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
* B:通知系统去释放跟该文件相关的资源
*/
//java.io.IOException: Stream Closed
//fos.write(“java”.getBytes());
}
}

package cn.itcast_01;

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

/*
* 字节输出流操作步骤：
* A:创建字节输出流对象
* B:调用write()方法
* C:释放资源
*
* public void write(int b):写一个字节
* public void write(byte[] b):写一个字节数组
* public void write(byte[] b,int off,int len):写一个字节数组的一部分
*/
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// OutputStream os = new FileOutputStream(“fos2.txt”); // 多态
FileOutputStream fos = new FileOutputStream(“fos2.txt”);

    // 调用write()方法
    //fos.write(97); //97 -- 底层二进制数据 -- 通过记事本打开 -- 找97对应的字符值 -- a
    // fos.write(57);
    // fos.write(55);

    //public void write(byte[] b):写一个字节数组
    byte[] bys={97,98,99,100,101};
    fos.write(bys);

    //public void write(byte[] b,int off,int len):写一个字节数组的一部分
    fos.write(bys,1,3);

    //释放资源
    fos.close();
}

}

package cn.itcast_01;

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

/*
* 如何实现数据的换行?
* 为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
* 如何实现呢?写入换行符号即可呗。
* 刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
* 因为不同的系统针对不同的换行符号识别是不一样的?
* windows:\r\n
* linux:\n
* Mac:\r
* 而一些常见的个高级记事本，是可以识别任意换行符号的。
*
* 如何实现数据的追加写入?
* 用构造方法带第二个参数是true的情况即可
*/
public class FileOutputStreamDemo3 {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// FileOutputStream fos = new FileOutputStream(“fos3.txt”);
// 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
FileOutputStream fos = new FileOutputStream(“fos3.txt”, true);

    // 写数据
    for (int x = 0; x < 10; x++) {
        fos.write(("hello" + x).getBytes());
        fos.write("\r\n".getBytes());
    }

    // 释放资源
    fos.close();
}

}

package cn.itcast_01;

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

/*
* 加入异常处理的字节输出流操作
*/
public class FileOutputStreamDemo4 {
public static void main(String[] args) {
// 分开做异常处理

    // 一起做异常处理
    // try {
    // FileOutputStream fos = new FileOutputStream("fos4.txt");
    // fos.write("java".getBytes());
    // fos.close();
    // } catch (FileNotFoundException e) {
    // e.printStackTrace();
    // } catch (IOException e) {
    // e.printStackTrace();
    // }

    // 改进版
    // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
    FileOutputStream fos = null;
    try {
        // fos = new FileOutputStream("z:\\fos4.txt");
        fos = new FileOutputStream("fos4.txt");
        fos.write("java".getBytes());
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 如果fos不是null，才需要close()
        if (fos != null) {
            // 为了保证close()一定会执行，就放到这里了
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

}

##### **3.2 字节流写数据常见问题**


1.创建字节输出流到底做了哪些事情?


2.数据写成功后，为什么要close()?


3.如何实现数据的换行?


4.如何实现数据的追加写入?


5.加入异常处理的IO流操作，该如何处理？


##### **3.3 字节流写数据InputStream**


* FileInputStream


1.FileInputStream的构造方法


* FileInputStream(File file)
* FileInputStream(String name)


2.FileInputStream的成员方法


* public int read()——一次读取一个字节
* public int read(byte[] b)——一次读取一个字节数组，每次可以读取多个数据，提高了操作效率。


这就像喝水一样：一次喝一滴水，一次喝一口水。

package cn.itcast_02;

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

/*
* 字节输入流操作步骤：
* A:创建字节输入流对象
* B:调用read()方法读取数据，并把数据显示在控制台
* C:释放资源
*
* 读取数据的方式：
* A:int read():一次读取一个字节
* B:int read(byte[] b):一次读取一个字节数组
*/
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
// FileInputStream(String name)
// FileInputStream fis = new FileInputStream(“fis.txt”);
FileInputStream fis = new FileInputStream(“FileOutputStreamDemo.java”);

    // 用循环改进
    // int by = fis.read();
    // while (by != -1) {
    // System.out.print((char) by);
    // by = fis.read();
    // }

    // 最终版代码
    int by = 0;
    // 读取，赋值，判断
    while ((by = fis.read()) != -1) {
        System.out.print((char) by);
    }

    // 释放资源
    fis.close();
}

}

package cn.itcast_02;

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

/*
* 一次读取一个字节数组：int read(byte[] b)
* 返回值其实是实际读取的字节个数。
*/
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
// FileInputStream fis = new FileInputStream(“fis2.txt”);
FileInputStream fis = new FileInputStream(“FileOutputStreamDemo.java”);

    // 最终版代码
    // 数组的长度一般是1024或者1024的整数倍
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = fis.read(bys)) != -1) {
        System.out.print(new String(bys, 0, len));
    }

    // 释放资源
    fis.close();
}

}

**示例：**字节流复制数据练习


复制数据的最基本思想：


* 数据源：读数据 ——InputStream
* 目的地：写数据——OutputStream


1.把c:\a.txt内容复制到d:\b.txt中

package cn.itcast_03;

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

/*
* 复制文本文件。
*
* 数据源：从哪里来
* a.txt – 读取数据 – FileInputStream
*
* 目的地：到哪里去
* b.txt – 写数据 – FileOutputStream
*
* java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
*
* 这一次复制中文没有出现任何问题，为什么呢?
* 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
* 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
* 它会自己做转换。
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream(“c:\a.txt”);
// 封装目的地
FileOutputStream fos = new FileOutputStream(“d:\b.txt”);

    int by = 0;
    while ((by = fis.read()) != -1) {
        fos.write(by);
    }

    // 释放资源(先关谁都行)
    fos.close();
    fis.close();
}

}

2.把e:\林青霞.jpg内容复制到当前项目目录下的mn.jpg中

package cn.itcast_03;

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

/*
* 需求：把e:\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
*
* 数据源：
* e:\林青霞.jpg --读取数据–FileInputStream
* 目的地：
* mn.jpg–写出数据–FileOutputStream
*/
public class CopyImageDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream(“e:\林青霞.jpg”);
// 封装目的地
FileOutputStream fos = new FileOutputStream(“mn.jpg”);

    // 复制数据
    int by = 0;
    while ((by = fis.read()) != -1) {
        fos.write(by);
    }

    // 释放资源
    fos.close();
    fis.close();
}

}

3.把e:\哥有老婆.mp4复制到当前项目目录下的copy.mp4中（一次读一个字节，效率低下。）

package cn.itcast_03;

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

/*
* 需求：把e:\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
*
* 数据源：
* e:\哥有老婆.mp4–读取数据–FileInputStream
* 目的地：
* copy.mp4–写出数据–FileOutputStream
*/
public class CopyMp4Demo {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream(“e:\哥有老婆.mp4”);
// 封装目的地
FileOutputStream fos = new FileOutputStream(“copy.mp4”);

    // 复制数据
    int by = 0;
    while ((by = fis.read()) != -1) {
        fos.write(by);
    }

    // 释放资源
    fos.close();
    fis.close();
}

}

##### **3.4 字节缓冲流**


字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想(**装饰设计模式**)，所以提供了字节缓冲区流


* 字节缓冲输出流   

	+ BufferedOutputStream

package cn.itcast_05;

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

/*
* 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
* 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
* 这种类被称为：缓冲区类(高效类)
* 写数据：BufferedOutputStream
* 读数据：BufferedInputStream
*
* 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
*
* 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
* 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
*/
public class BufferedOutputStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream(“bos.txt”);
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 简单写法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(“bos.txt”));

最后

小编的一位同事在校期间连续三年参加ACM-ICPC竞赛。从参赛开始，原计划每天刷一道算法题，实际上每天有时候不止一题，一年最终完成了 600+：

凭借三年刷题经验，他在校招中很快拿到了各大公司的offer。

入职前，他把他的刷题经验总结成1121页PDF书籍，作为礼物赠送给他的学弟学妹，希望同学们都能在最短时间内掌握校招常见的算法及解题思路。

整本书，我仔细看了一遍，作者非常细心地将常见核心算法题和汇总题拆分为4个章节。

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

而对于有时间的同学，作者还给出了他结合众多数据结构算法书籍，挑选出的一千多道题的解题思路和方法，以供有需要的同学慢慢研究。