Java---IO流(二)

本文主要是介绍Java---IO流(二)，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

缓冲字节流&缓冲字符流

​ Java的缓冲流本身并不具备对文件的读取写入功能，他的作用只是在文件流的基础上，再对文件流进行包装，即在文件流在包上一层缓冲流，这样会大大提高IO流对文件读取写入的效率。因此，缓冲流就是一种处理流。在读写数据时提供缓冲功能。应用程序、缓冲流和底层字节流之间的关系如图所示：

​ 当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因此，缓冲流还是很重要的，我们在IO操作时记得加上缓冲流来提升性能。

BufferedInputStream和BufferedOutputStream为缓冲字节流，它们的构造方法中分别接收InputStream和OutputStream类型的参数作为对象通过内部缓存数组来提高操作流的效率。

//将图片复制到另外一个位置：
		long start = System.currentTimeMillis();			//程序开始执行的计时
        BufferedInputStream bi = null;
        BufferedOutputStream bo = null;
        try {
            File file1 = new File("src\\IOstream\\img1.jpg");
            File file2 = new File("src\\IOstream\\img3.jpg");
            FileInputStream fi = new FileInputStream(file1);	
            FileOutputStream fo = new FileOutputStream(file2);	

            bi = new BufferedInputStream(fi);		//即把文件流包进缓冲流里去。
            bo = new BufferedOutputStream(fo);		//即把文件流包进缓冲流里去。

            byte[] bytes = new byte[10];
            int leng;
            while ((leng = bi.read(bytes)) != -1) {
                bo.write(bytes,0,leng);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bi != null){
                try {
                    bi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bo != null){
                try {
                    bo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();			//程序结束时结束的计时
        System.out.println(end - start);				//执行程序所需的时间

在缓冲流中，输出方式还有另外一种方法：

//readLine()的使用：
            //方式1：IO流输出写入的基本方法
//            char[] chars = new char[5];
//            int leng;
//            while ((leng = br.read(chars)) != -1) {
//                bw.write(chars,0,leng);
            //方式2：方法一：readLine()方法--->不换行，输出数据为一整行
//            String str;
//            while ((str = br.readLine()) != null){      //默认不换行
//                bw.write(str);
//            }
            //方式2：方法二：readLine()方法--->换行，输出数据行列分明
            String str;
            while ((str = br.readLine()) != null){
                bw.write(str);
                bw.newLine();                   //再后面追加一行
            }

缓冲字符流有BufferedReader和BufferedWriter，其增加了 缓存机制，大大提升了对与文件的读写操作的效率。同时，提供了更方便的按行读取的方法：readLine(); 处理文本时，我们一般可以使用缓冲字符流。

• readLine():输出一行数据，默认不换行。
• readLine()方法是BufferedReader特有的方法，可以对文本文件进行更加方便的读取操作。
• 写入一行后要记得使用newLine()方法换行。

//缓冲字符流加上readLine()的使用:
		BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            File file1 = new File("src\\IOstream\\text2.txt");
            File file2 = new File("src\\IOstream\\text3.txt");
            FileReader fr = new FileReader(file1);
            FileWriter fw = new FileWriter(file2);
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            //方式1：IO流输出写入的基本方法
//            char[] chars = new char[5];
//            int leng;
//            while ((leng = br.read(chars)) != -1) {
//                bw.write(chars,0,leng);
            //方式2：方法一：readLine()方法--->不换行，输出数据为一整行
//            String str;
//            while ((str = br.readLine()) != null){      //默认不换行
//                bw.write(str);
//            }
            //方式2：方法二：readLine()方法--->换行，输出数据行列分明
            String str;
            while ((str = br.readLine()) != null){
                bw.write(str);
                bw.newLine();                   //再后面追加一行
            }
        } 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();
                }
            }
        }
    }

转换流

​ 转换流有InputStreamReader和OutputStreamWriter这两个，都属于字符流；可以用来实现将字节流转换为字符流，转换流也属于处理流的一种。它的原理有点类似于: 解码-->程序-->编码 这个过程。

• 解码：InputStreamReader：将字节流输入的转换成字符流输入；

• 编码：OutputStreamWriter:将字符流输出的转换成字节流输出；

• 提供字节流与字符流之间的转换；

• 

        InputStreamReader isf = null; 	
        try {
            FileInputStream file = new FileInputStream("src\\IOstream\\text3.txt");
//        InputStreamReader isf = new InputStreamReader(参数1,参数2); 参数2可以自定义字符流的格式	
            isf = new InputStreamReader(file,"GBK");
            char[] chars = new char[10];
            int leng;
            while ((leng = isf.read(chars)) != -1){
                String str = new String(chars,0,leng);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (isf != null){
                try {
                    isf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

//对字节流文件转换为字符流，再对其转换为字节流进行写入。即 解码-->程序-->编码      
		InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            FileInputStream file1 = new FileInputStream("src\\IOstream\\text3.txt");
            FileOutputStream file2 = new FileOutputStream("src\\IOstream\\text2.txt");
            isr = new InputStreamReader(file1,"UTF-8");		
            osw = new OutputStreamWriter(file2,"GBK");

            char[] chars = new char[10];
            int leng;
            while ((leng = isr.read(chars)) != -1){
                osw.write(chars,0,leng);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (isr != null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (osw != null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

对象流

数据流只能实现对基本数据类型和字符串类型的读写，并不能读取对象(字符串除外)，如果要对某个对象进行读写操作，我们需要学习一对新的处理流---对象流：

对象流有ObjectInputStream和ObjectOutputStream；可用于存储和读取基本数据类型数据或者对象的处理流。可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

其中，包含着序列化与反序列化的机制操作：

• 序列化：用ObjectOutputStream保存基本数据类型或对象机制，将内存中的java对象保存到磁盘或者通过网络传输出去。

• 反序列化：用ObjectInputStream读取基本数据类型或者对象机制，还原序列化的数据。

• 注意一点，不能序列化static和transient修饰的成员变量。

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

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

• 重点：序列化思想

//序列化： 		
		ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(
                    new FileOutputStream("src\\IOstream\\ObjectIO\\data.dat"));

            oos.writeObject("这是一个序列化写入，反序列化读取的程序！");
            oos.flush();        //刷新操作
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

//反序列化：
	ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(
                new FileInputStream("src\\IOstream\\ObjectIO\\data.dat"));

        Object obj = ois.readObject();
        String str = (String)obj;
        System.out.println(str);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if (ois != null) {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

如果需要自定义类时，自定义类需要满足以下要求，才可以序列化：

1、需要实现接口：Serializable

2、当前类提供一个全局常量：serialVersionUID

ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;   //(后面的值随意填写)

3、当前的类需要实现Serializable 接口，还必须保证其内部所有属性都为可序列化的。

//序列化自定义类：
ObjectOutputStream oos = null;
try {
    oos = new ObjectOutputStream(new FileOutputStream(
            "src\\IOstream\\ObjectIO\\person.dat"));

    oos.writeObject(new Person("XXXX",11,new Account("xxxxx")));
    oos.flush();        //记得刷新数据
    oos.writeObject(new Person("LLLL",22,new Account("lllll")));
    oos.flush();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (oos != null) {
        try {
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//反序列化自定义对象：
ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(
        new FileInputStream("src\\IOstream\\ObjectIO\\person.dat"));

        //不能定义obj对象，然后再去给Person转换，只能直接Person接ois.readObject()
        Person p = (Person)ois.readObject();
        Person p1 = (Person)ois.readObject();

        System.out.println(p);
        System.out.println(p1);
        
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if (ois != null) {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

其中需要注意的有---自定义类需要满足一些要求：

如果时自定义B类属性给另一个A类使用，也需要满足这些要求：

RandomAccessFile随机存取数据

之前所使用的数据流，读取写出数据都是从头开始，不能自定义插入的位置，而RandomAccessFile他就可以解决这个问题,因为它可以指定位置读,指定位置写的一个类,通常开发过程中,多用于多线程下载一个大文件：

1、直接继承于java.lang.object类，实现DataInput和DataOutput接口。

2、既可作为输入流也可作为输出流。

3、作为输出流。文件存在，写出数据到文件中，将会从文件数据的开头开始覆盖，有多少覆盖多少，其他的无变化。

4、可以通过相关操作，实现RandomAccessFile的插入数据操作。

5、RandomAccessFile(File,”rw”);后面可以设置读取方式，如下表：

public void test2() throws IOException {
     RandomAccessFile raf1 = new RandomAccessFile(new File("src\\IOstream\\ObjectIO\\text.txt"),"rw");
//     raf1.writeBytes("xyz") ;
//        raf1.seek(3);               //字符串为3的索引开始进行替换
        raf1.seek((new File("src\\IOstream\\ObjectIO\\text.txt").length())); 
    	//每次在字符串末尾加上xyz
        raf1.write("xyz".getBytes());    //将字符中的数替换成xyz
    raf1.close();
    }

如果想要从指定位置插入数据也可以：

• 读取文件数据
• 定义字符串，可以用来存储数据
• 定义，写入字符串中保存
• 再次定位，插入数据
• 把保存好的数据插入文件中
• 结束

RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(new File("src\\IOstream\\ObjectIO\\text.txt"),"rw");
        raf.seek(3);    //将指针指向角标为3的位置
        byte[] bytes = new byte[5];
        int leng;
        //将角标为3的位置之后的所有数据保存到strbf中
        StringBuilder strbf = new StringBuilder((int)new File("src\\IOstream\\ObjectIO\\text.txt").length());
        while ((leng = raf.read(bytes)) != -1){
            strbf.append(new String(bytes,0,leng));
        }
        //调回指针，写入数据
        raf.seek(3);
        raf.write("xyz".getBytes());

        //将StringBuilder的数据再写入文件中：
        raf.write(strbf.toString().getBytes());
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (raf != null) {
            try {
                raf.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//最后将会在角标为3的位置插入xyz，而前面与后面的其他数据不会发生改变。

最后，到这里Java的IO流学习也已经到了尾声了，如果有其他需要扩展的欢迎补充！！！

这篇关于Java---IO流(二)的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！