java小记5

本周的学习主要集中在io流的学习上面，关于io流的学习方面，目前我们课程的c++也学到了这个方面，自己的感觉是两种语言还是有差异的，另外两种语言都在完成图书馆管理系统，所以也能比较完全的感受到两种语言的优缺点。

下面是本周的学习进度：

Java中流的概念细分

    

一 按流的方向分类：

1. 输入流：数据流向是数据源到程序(以InputStream、Reader结尾的流)。

2. 输出流：数据流向是程序到目的地(以OutPutStream、Writer结尾的流)。

二 按处理的数据单元分类：

1. 字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如 FileInputStream、FileOutputStream。

2. 字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。

三 按处理对象不同分类：

1. 节点流：可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、DataInputStream等。

2. 处理流：不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如BufferedInputStream、BufferedReader等。处理流也叫包装流。

Java中IO流类的体系

io流也分为一些体系，下列是一些io流的体系区分

  1. InputStream/OutputStream

        字节流的抽象类。

     2. Reader/Writer

        字符流的抽象类。

     3. FileInputStream/FileOutputStream

        节点流：以字节为单位直接操作“文件”。

     4. ByteArrayInputStream/ByteArrayOutputStream

        节点流：以字节为单位直接操作“字节数组对象”。

     5. ObjectInputStream/ObjectOutputStream

        处理流：以字节为单位直接操作“对象”。

     6. DataInputStream/DataOutputStream

        处理流：以字节为单位直接操作“基本数据类型与字符串类型”。

     7. FileReader/FileWriter

        节点流：以字符为单位直接操作“文本文件”(注意：只能读写文本文件)。

     8. BufferedReader/BufferedWriter

        处理流：将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。

     9. BufferedInputStream/BufferedOutputStream

        处理流：将InputStream/OutputStream对象进行包装，增加缓存功能，提高 读写效率。

     10. InputStreamReader/OutputStreamWriter

        处理流：将字节流对象转化成字符流对象。

     11. PrintStream

        处理流：将OutputStream进行包装，可以方便地输出字符，更加灵活。

四大IO抽象类

 ·InputStream

· OutputStream

· Reader

· Writer

文件字节流和文件字符流

import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileOutputStream {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        String string = "vva";
        try {
            fos = new FileOutputStream("d:/a.txt", true);
            fos.write(string.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

上述代码的作用是将内容写到文件中，但文件字节流也有缺点，其不能很好的处理Unicode字符，所以此时就需要文件字符流的使用。

缓冲字节流

使用缓冲字节流的原因：

当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。

因此，缓冲流还是很重要的，我们在IO操作时记得加上缓冲流来提升性能。

缓冲字符流

public class TestBufferedFileCopy2 {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        String tempString = "";
        try {
            fr = new FileReader("d:/a.txt");
            fw = new FileWriter("d:/d.txt");
            //使用缓冲字符流进行包装
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            //BufferedReader提供了更方便的readLine()方法，直接按行读取文本
            //br.readLine()方法的返回值是一个字符串对象，即文本中的一行内容
            while ((tempString = br.readLine()) != null) {
                //将读取的一行字符串写入文件中
                bw.write(tempString);
                //下次写入之前先换行，否则会在上一行后边继续追加，而不是另起一行
                bw.newLine();
            }

 readLine()方法是BufferedReader特有的方法，可以对文本文件进行更加方便的读取操作

字节数组流

简单测试ByteArrayInputStream 的使用

import java.io.ByteArrayInputStream;
import java.io.IOException;
 
public class TestByteArray {
    public static void main(String[] args) {
        //将字符串转变成字节数组
        byte[] b = "abcdefg".getBytes();
        test(b);
    }
    public static void test(byte[] b) {
        ByteArrayInputStream bais = null;
        StringBuilder sb = new StringBuilder();
        int temp = 0;
        //用于保存读取的字节数
        int num = 0; 
        try {
            //该构造方法的参数是一个字节数组，这个字节数组就是数据源
            bais = new ByteArrayInputStream(b);
            while ((temp = bais.read()) != -1) {
                sb.append((char) temp);
                num++;
            }
            System.out.println(sb);
            System.out.println("读取的字节数：" + num);
        } finally {
            try {
                if (bais != null) {
                    bais.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

数据流 

 数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作Java基本数据类型与字符串类型。

对象流

  1. 对象流不仅可以读写对象，还可以读写基本数据类型。

  2. 使用对象流读写对象时，该对象必须序列化与反序列化。

  3. 系统提供的类(如Date等)已经实现了序列化接口，自定义类必须手动实现序列化接口。

 转换流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
 
public class TestConvertStream {
    public static void main(String[] args) {
        // 创建字符输入和输出流:使用转换流将字节流转换成字符流
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new OutputStreamWriter(System.out));
            // 使用字符输入和输出流
            String str = br.readLine();
            // 一直读取，直到用户输入了exit为止
            while (!"exit".equals(str)) {
                // 写到控制台
                bw.write(str);
                bw.newLine();// 写一行后换行
                bw.flush();// 手动刷新
                // 再读一行
                str = br.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭字符输入和输出流
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
 
public class TestConvertStream {
    public static void main(String[] args) {
        // 创建字符输入和输出流:使用转换流将字节流转换成字符流
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new OutputStreamWriter(System.out));
            // 使用字符输入和输出流
            String str = br.readLine();
            // 一直读取，直到用户输入了exit为止
            while (!"exit".equals(str)) {
                // 写到控制台
                bw.write(str);
                bw.newLine();// 写一行后换行
                bw.flush();// 手动刷新
                // 再读一行
                str = br.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭字符输入和输出流
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

以上为本周的学习内容，如有不足请指正。