JAVA 字符流字节流区别以及文件操作代码

数据流分为 字符流和字节流
字符流 Reader Writer
Reader
BufferReader InputStreamReader FileReader
Writer
BufferWriter OutputStreamWriter FileWriter

字节流 InputStream OutputStream
InputStream
FileInputStram BufferInputStream
OutPutStram
FileOutputStream BufferOutputStream

字符流相关

因为文件编码的不同，而有了对字符进行高效操作的字符流对象
使用原理： 基于字节流读取字节时，查指定的码表

字符流和字节流的区别：

1。字节流读取时，读到一个字节就返回一个字节， 字符流读到一个或多个字节时，先去查指定的编码表，将查到的字符返回
2.字节流可以处理所以类型的数据，而自字符流只能处理字符数据
结论：对于纯文本文件，可以考虑使用字符流，其他的使用字节流

一些IO操作方法

以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件

/**  FileInputStream   buffer
         * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
         * @param fileName  文件的名
         */
        public static void readFileByBytes(String fileName){
            File file = new File(fileName);
            InputStream in = null;
            try {
                System.out.println("以字节为单位读取文件内容，一次读一个字节：");
                //  一次读一个字节
                in = new FileInputStream(file);
                int tempbyte;
                while((tempbyte=in.read()) != -1){
                    System.out.write(tempbyte);
                }
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }
            try {
                System.out.println("以字节为单位读取文件内容，一次读多个字节：");
                //一次读多个字节
                byte[] tempbytes = new byte[100];
                int byteread = 0;
                in = new FileInputStream(fileName);
                ReadFromFile.showAvailableBytes(in);
                //读入多个字节到字节数组中，byteread为一次读入的字节数
                while ((byteread = in.read(tempbytes)) != -1){
                    System.out.write(tempbytes, 0, byteread);
                }
            } catch (Exception e1) {
                e1.printStackTrace();
            } finally {
                if (in != null){
                    try {
                        in.close();
                    } catch (IOException e1) {
                    }
                }
            }
        }

以行为单位读取文件，常用于读面向行的格式化文件

/**   BufferReader   (new FileReader)  readLine();
         * 以行为单位读取文件，常用于读面向行的格式化文件
         * @param fileName  文件名
         */
        public static void readFileByLines(String fileName){
            File file = new File(fileName);
            BufferedReader reader = null;
            try {
                System.out.println("以行为单位读取文件内容，一次读一整行：");
                reader = new BufferedReader(new FileReader(file));
                String tempString = null;
                int line = 1;
                //一次读入一行，直到读入null为文件结束
                while ((tempString = reader.readLine()) != null){
                    //显示行号
                    System.out.println("line " + line + ": " + tempString);
                    line++;
                }
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null){
                    try {
                        reader.close();
                    } catch (IOException e1) {
                    }
                }
            }
        }

随机读取文件内容

/**
         * 随机读取文件内容
         * @param fileName  文件名
         */
        public static void readFileByRandomAccess(String fileName){
            RandomAccessFile randomFile = null;
            try {
                System.out.println("随机读取一段文件内容：");
                //  打开一个随机访问文件流，按只读方式
                randomFile = new RandomAccessFile(fileName, "r");
                //  文件长度，字节数
                long fileLength = randomFile.length();
                //  读文件的起始位置
                int beginIndex = (fileLength > 4) ? 4 : 0;
                //将读文件的开始位置移到beginIndex位置。
                randomFile.seek(beginIndex);
                byte[] bytes = new byte[10];
                int byteread = 0;
                //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
                //将一次读取的字节数赋给byteread
                while ((byteread = randomFile.read(bytes)) != -1){
                    System.out.write(bytes, 0, byteread);
                }
            } catch (IOException e){
                e.printStackTrace();
            } finally {
                if (randomFile != null){
                    try {
                        randomFile.close();
                    } catch (IOException e1) {
                    }
                }
            }
        }

显示输入流中还剩的字节数

/** 
* 显示输入流中还剩的字节数
         * @param in
         */
        private static void showAvailableBytes(InputStream in){
            try {
                System.out.println("当前字节输入流中的字节数为:" + in.available());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }