java bio总结

、同步异步、阻塞非阻塞（目前不是很清楚，这篇博客写完后，后续进行处理）

　　1.同步和异步：关注的是消息的通讯机制，

　　　　同步：发起调用后，如果没有得到结果,该调用是不会返回的；该调用者会主动等待调用返回。

　　　　异步：发起调用后，调用立刻返回，但并不是返回的结果；也就是说调用者并不会立刻得到结果，而是被调用者通知调用者，或者通过回调函数处理这个调用。

　　2.阻塞和非阻塞：指的是程序等待调用结果时的状态。只有同步才会有阻塞和非阻塞的概念。

　　　　阻塞：发起调用后当前线程会被挂起，直到有返回

　　　　非阻塞：发起调用后，当前线程不会被挂起，而是继续执行。

二、io流的分类

　　1.输入流、输出流：根据流是否流向处理器来确定是输入流还是输出流。

　　2.字节流、字符流：字节流读到的数据不会进行任何处理；字符流读取到的二进制数据会根据相应的编码进行转换为字符，字符流=字节流+解码。

三、io流类结构图

四、常用功能

　　注意一点：使用完io后，一定要关闭流

　1.io流对文件进行读取

/**

 * 字符流读写文本文件

 * 在使用io读写文本文件的时候一定要记住关闭流

 */

public class Test2 {

    public static void main(String[] args) {

        ReadFile(new File("E:/b.txt"));

        WriteFile(new File("E:/c.txt"));

    }

    public static void ReadFile(File file){

        FileReader fr = null;

        BufferedReader br = null;

        InputStreamReader isr = null;

        try {

            System.out.println("\r\n========自己定义缓冲数组来读取文件================");

            fr = new FileReader(file);

            char[] buffer1 = new char[3];

            int len1 = 0;

            while((len1 = fr.read(buffer1)) != -1){

                System.out.print(new String(buffer1,0,len1));

            }

            System.out.println("\r\n========使用缓冲流来读取文件================");

            br = new BufferedReader(new FileReader(file));

            String temp = "";

            while((temp = br.readLine()) != null){

                System.out.println(temp);

            }

            System.out.println("\r\n========使用转换流来读取文件===========");

            isr = new InputStreamReader(new FileInputStream(file),"utf-8");

            char[] buffer2 = new char[1];

            int len2 = 0;

            while((len2 = isr.read(buffer2)) != -1 ){

                System.out.print(new String(buffer2,0,len2));

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (UnsupportedEncodingException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }finally{

            try {

                br.close();

                isr.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

    public static void WriteFile(File file){

        FileOutputStream fos = null;

        FileWriter fw = null;

        BufferedWriter bw = null;

        try {

            //========使用字节流写入文件===========

            fos = new FileOutputStream(file);

            fos.write("测试写入文件abc123。。".getBytes());

            fos.write("测试是否叠加".getBytes());

            fos.flush();

            //========使用字符流写入文件===========

            fw = new FileWriter(file,true);

            fw.write("\r\n========使用字符流写入文件===========");

            fw.write("这是用FileWriter写入的数据 ");

            fw.flush();

            //========使用缓冲流写入文件===========

            //FileWriter默认是会覆盖上一次的数据，所以在新建的时候要将是否追加参数设置为true

            bw = new BufferedWriter(new FileWriter(file,true));

            bw.newLine();

            bw.write("使用缓冲流写入");

            bw.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (NumberFormatException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }finally{

            try {

                bw.close();

                fw.close();

                fos.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

2.字节流对文件进行复制

/**

 * 字节流对文件进行复制

*

 */

public class Test1 {

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

        copy();

    }

    public static void copy(){

        FileInputStream fis = null;

        FileOutputStream fos = null;

        try{

            fis = new FileInputStream("E:/a.txt");

            fos = new FileOutputStream("E:/b.txt");

            byte[] buffer = new byte[1024];//使用数组进行缓冲，提高io速度

            int len = 0;

            while((len = fis.read(buffer)) != -1){

                fos.write(buffer, 0, len);

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }finally{

            try {

                fos.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

            try {

                fis.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

五、IO流使用的一些细节

　　1.IO流中，缓冲类都是Buffered*类，其并不具备读写能力，只是内部维护了一个8kb的数组，只有在调用了close（）和flush（）或者字节数组已经满了才会将数据写入到硬盘。提高了文件的读写效率。

　　2.文件输出流，目标文件如果不存在，则会创建文件。其write方法默认清空文件内容，再写入内容，需要在构造方法中设置才能成功。

　　3.FileOutputStream 参数为int时，只会把低8位写出，剩余24位丢弃。

　　4.转换流的作用就是将字节流转换为字符流，并可以按照指定的编码对数据进行读写。

巴特西

java bio总结

最新文章

热门文章