Java的学习记录：charpter11.流

1.1流的概念及使用

什么是流？
简单来说，流就是一组有序的数据序列(字节数组)。
流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。

流的方向？
流具有方向性，至于是输入流还是输出流则是一个相对的概念，一般以程序为参考，如果数据的流向是程序至设备，我们成为输出流，反之我们称为输入流。

流的分类？
1.根据流的方向分为输入流和输出流：

​ 1）输入（读）：从外 ->内 XxxinputStream(字节输入流) /XxxReader(字符输入流)

​ 2）输出（写）：从内 ->外 XxxoutputStream(字节输出流) /XxxWriter(字符输出流)

2.根据流所传输的内容分为字节流和字符流：
1）字节流：byte[] XxxinputStream(字节输入流)/ XxxoutputStream(字节输出流)

​ 2）字符流：char[] XxxReader(字符输入流)/XxxWriter(字符输出流)

3.根据流所用有的功能分为节点流和处理流：
1)节点流：直接面向数据源的流 (基础流)，只能进行基本操作
节点流：节点流从一个特定的数据源读写数据。即节点流是直接操作文件，网络等的流，例如FileInputStream和FileOutputStream，他们直接从文件中读取或往文件中写入字节流。

​ 2)处理流：扩展了节点流在某些特定领域的操作，依赖节点流
处理流：“连接”在已存在的流（节点流或处理流）之上通过对数据的处理为程序提供更为强大的读写功能。过滤流是使用一个已经存在的输入流或输出流连接创建的，过滤流就是对节点流进行一系列的包装。例如BufferedInputStream和BufferedOutputStream，使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率，以及DataInputStream和DataOutputStream，使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。

代码示例：

public static void main(String[] args) throws IOException {
        // 节点流FileOutputStream直接以test.txt作为数据源操作
        FileOutputStream fos= new FileOutputStream("test.txt");
        // 过滤流BufferedOutputStream进一步装饰节点流，提供缓冲写
        BufferedOutputStream bos= new BufferedOutputStream(
                fileOutputStream);
        // 过滤流DataOutputStream进一步装饰过滤流，使其提供基本数据类型的写
        DataOutputStream out = new DataOutputStream(bufferedOutputStream);
        out.writeInt(3);
        out.writeBoolean(true);
        out.flush();
        out.close();
        // 此处输入节点流，过滤流正好跟上边输出对应，读者可举一反三
        DataInputStream ds= new DataInputStream(new BufferedInputStream(
                new FileInputStream("test.txt")));
        System.out.println(in.readInt());
        System.out.println(in.readBoolean());
        ds.close();

4.根据流是否依赖网络又可以分为本地流和网络流

1.继承自InputStream/OutputStream的流都是用于向程序中输入/输出数据，且数据的单位都是字节(byte=8bit)
2.继承自Reader/Writer的流都是用于向程序中输入/输出数据，且数据的单位都是字符(2byte=16bit)

补充：
如何创建目录/文件：
代码示例：

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

        File dir = new File("copy/upload/upload1");
        boolean mkdir = dir.mkdirs();// mkdirs：是否创建了多级子目录
        System.out.println(mkdir);
        File file = new File("text1.txt");
        if(!file.exists()){
            if(file.createNewFile()){
                System.out.println(file.getName()+"创建成功");
                System.out.println(file.getPath());//相对路径：结果：text1.txt
                System.out.println(file.getAbsoluteFile());//绝对路径：从分区根目录到(包括)相对路径
            }else{
                System.out.println(file.getName()+"创建失败");
            }
        }else{
            System.out.println(file.getName()+"已存在");
        }

文件流：
代码示例：

            //文件输入流
        FileReader fr =new FileReader(file);
        char[] cs = new char[8];//cs表示一次读8个字符的字符数组
        int len = -1;

        while(-1 != (len=fr.read(cs))){ //len=-1：表示读到了文件的末尾； 否则len！=-1，表示实际读取的字符数
            System.out.print(new String(cs,0,len));//读字节的时候不能用println，要用print
        }
        fr.close(); //关闭流

        //文件输出流
        FileWriter fw = new FileWriter(file,true);//append表示在原来的文件内容后追加内容
        fw.write("\nHi!BoB!\nnice to meet you too!");
        fw.close();//关闭流

处理流：
代码示例：

 		//处理流 输入
        BufferedReader br = new BufferedReader(new FileReader(file)); //buffered 缓存的 :降低和数据源的操作频次

        String line = null;

        while(null!=(line=br.readLine())){//line: 表示实际读取行的内容，null表示文件结尾
            System.out.println(line);
        }

        br.close();

        //处理流 输出
        BufferedWriter bw = new BufferedWriter(new FileWriter(file,true));
        bw.newLine();
        bw.write("My name is Tom,I'm twenty-one years old!");
        bw.newLine();
        bw.write("Can I be your friend?");
        bw.newLine();
        bw.write("Of crouse, I'm glad to be your friend!");

        bw.close();

对字符串进行修改的方法：
代码示例：

        //当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
        StringBuilder sb =new StringBuilder("很高兴认识你");
        sb.append("Tom");
        System.out.println(sb);
        sb.delete(2,4);  //注意：删除是根据下标来删的，并且是左开右闭的情况，即右边的end下标的字符不删除
        System.out.println(sb);
        sb.replace(1,3,"我不"); //从str的起始位置star开始替换为
        System.out.println(sb);
        sb.reverse(); //字符串反转
        System.out.println(sb);

字节文件流：
代码示例：

public class Test {
    public static void main(String[] args) throws IOException, InterruptedException {
        File src = new File("C:\\KBO8study\\CentOS-7-x86_64-DVD-1908.iso");
//        //自动新建一个文件夹
//        File dir = new File("files/");
//        boolean mkdir = dir.mkdir();
//        System.out.println(mkdir);
        File dest = new File("files/" +src.getName());

        FileInputStream fis = new FileInputStream(src); //先把文件读成字节数组
        FileOutputStream fos = new FileOutputStream(dest);//再把字节数组写到目标文件夹内

        final int M8 =8*1024*1024;
        final int M64 =8*M8;
        //一次从src内读取8兆，放到缓存区，读取64兆满8次之后再写入到dest内
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src),M64);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest),M64);

        byte[] bs =new byte[M8];//字节数组
        int len =-1;

        while(-1 !=(len=fis.read(bs))){ //len=-1，表示读到了文件的末尾，len！=-1表示实际读取的字节数
            fos.write(bs,0,len);
            Thread.sleep(1000);
        }
        //先开的后关，后开的先关
//      fos.close();
//      fis.close();
        bos.close();
        bis.close();
        }
       }