博客分类:
Java知识
Java
自学习Java IO以来,认为难倒是不难,就是比较繁杂,各种方式操作的IO类多如麻,每次使用,都不得不花费大把时间网上溜达一圈,才能完成手头任务。按说,像这些常用的IO操作,对于Java程序员来说,应该达到信手拈来,拿来就用的熟练程度。但我就是记也不住哇,究其原因,就是对Java IO的整体结构不甚了解。结构含糊,就不容易记忆。为了以后方便,于是有了整理一下Java IO的想法,打算简明易懂的记录Java IO的各种分门别类,争取理清思路,常回来看看,印记于脑海,再用时再也不必花费大量时间。不想从2010年2月3日创建该笔记始,一直拖到今天2011-07-13才算有了眉目,但是还不够完整,需要后期继续补充。
另, 总结代码形成的工具类请参见 文件操作工具类 一、基本概念 1. 概述
使用IO时,首先创建一个数据源IO,然后根据需要,创建装饰类IO。Java IO 相关的类总结如下表: 字节流 输入 数据源IO 1 FileInputStream 输出 字符流 输入 输出 FileOutputStream StringReader PipedReader FileRea2 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArr3 StringBufferInputStream 4 SequenceInputStream 5 PipedInputStream 6 System.in 装饰类IO 7 DataInputStream PipedOutputStream StringW SequenceOutputStream PipedWr DataOutputStream 8 BufferedInputStream 产生格式化输出PrintStream PushbackInputStream 一般用于编译器开发 BufferedOutputStream BufferedReader Buffere LineNumberReader 9 LineNumberInputStream 10 11 产生格式化输出PrintWriter PushBackReader 说明:
2. Java IO的使用原则
决定使用哪个类以及它的构造进程的一般准则如下(不考虑特殊需要) 第一,考虑最原始的数据格式是什么:是否为文本? 第二,是输入还是输出?
第三,是否需要转换流:InputStreamReader, OutputStreamWriter? 第四,数据来源(去向)是什么:文件?内存?网络?
第五,是否要缓冲:bufferedReader (特别注明:一定要注意的是readLine()是否有定义,有什么比read, write更特殊的输入或输出方法) 第六,是否要格式化输出:print?
(1) 按数据来源(去向)分类
- 是文件: FileInputStream, FileOutputStream, FileReader, FileWriter
- 是byte[]:ByteArrayInputStream, ByteArrayOutputStream - 是Char[]: CharArrayReader, CharArrayWriter
- 是String: StringBufferInputStream, StringReader, StringWriter
- 网络数据流:InputStream, OutputStream, Reader, Writer
(2) 按是否格式化输出分
- 要格式化输出:PrintStream, PrintWriter
(3) 按是否要缓冲分
- 要缓冲:BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter
(4) 按数据格式分
- 二进制格式(只要不能确定是纯文本的): InputStream, OutputStream及其所有带Stream结束的子类
- 纯文本格式(含纯英文与汉字或其他编码方式);Reader, Writer及其所有带Reader, Writer的子类
(5) 按输入输出分
- 输入:Reader, InputStream类型的子类 - 输出:Writer, OutputStream类型的子类
(6) 特殊需要
- 从Stream到Reader,Writer的转换类:InputStreamReader, OutputStreamWriter
- 对象输入输出:ObjectInputStream, ObjectOutputStream
- 进程间通信:PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
- 合并输入:SequenceInputStream
- 更特殊的需要:PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
二、 例子代码
1.文件操作
(1) 从文件读
- 字节流
FileInputStream 的read方法 : throws IOException int read()读取单个字节 int read(byte[] b)从输入流中将最多 b.length 个字节的数据读入到 byte 数组中
b - 存储读取数据的缓冲区。 返回:读入缓冲区的字节总数,如果到达文件末尾而没有更多的数据,返回 -1
int read(byte[] b, int off,int len)读取len个字节到字节数组b中的指定位置
b - 目标缓冲区。
off - 开始存储字节处的偏移量。 len - 要读取的最大字节数。 Java代码
1. //1. 以字节为单位读取文件内容,一次读一个字节
2. FileInputStream in = new FileInputStream(file); 3. int temp;
4. while ((temp = in.read()) != -1) {//将读取的字节赋值给temp
5. System.out.write(temp); 6. }
7. in.close(); 8.
9. //2. 以字节为单位读取文件内容,一次读多个字节 10. int byteread = 0;
11. FileInputStream in = new FileInputStream(fileName); 12. byte[] tempbytes = new byte[in.available()];// 一次读多个字节
13. // 读入多个字节到字节数组中,byteread为一次读入的字节数
14. while ((byteread = in.read(tempbytes)) != -1) { 15. // String s=new String(tempbytes,\"UTF-8\"); 16. System.out.write(tempbytes, 0, byteread); 17. }
//3. 带缓冲的读文件 BufferedInputStream 只有read方法,没有readLine方法
BufferedInputStream的read方法 :throws IOException int read()读取单个字节 int read(byte[] b)从输入流中将最多 b.length 个字节的数据读入到 byte 数组中
b - 存储读取数据的缓冲区。 返回:读入缓冲区的字节总数,如果到达文件末尾而没有更多的数
据,返回 -1
int read(byte[] b, int off,int len)读取len个字节到字节数组b中的指定位置
b - 目标缓冲区。
off - 开始存储字节处的偏移量。 len - 要读取的最大字节数。 Java代码
1. byte[] data = new byte[10];
2. BufferedInputStream bis = new BufferedInputStream( 3. new FileInputStream(\"C:\\\\readFile.txt\")); 4. BufferedOutputStream bos = new BufferedOutputStream( 5. new FileOutputStream(\"C:\\\\saveFile.txt\")); 6. while (bis .read(data) != -1) bos.write(data); 7. // 将缓冲区中的资料全部写出 8. bos.flush();
- 字符流
FileReader的read方法: int read()读取单个字节 int read(byte[] b)从输入流中将最多 b.length 个字节的数据读入到 byte 数组中
b - 存储读取数据的缓冲区。 返回:读入缓冲区的字节总数,如果到达文件末尾而没有更多的数据,返回 -1
int read(byte[] b, int off,int len)读取len个字节到字节数组b中的指定位置
b - 目标缓冲区。
off - 开始存储字节处的偏移量。 len - 要读取的最大字节数。 Java代码
1. //1.一次读多个字符 read(byte[] b)
2. char data[] = new char[10];//建立可容纳10个字符的数组
3. FileReader fr = new FileReader(\"algorithms.xml\"); 4. int num = fr.read(data);// 将数据读入字符列表data内 5. String str = new String(data, 0, num);// 将字符列表转换成字符串
6. fr.close();
7.
8. //2.一次读多个字符 read(byte[] b, int off,int len) 9. File fileName=new File(\"d:\\\emp\\\\save.txt\");
10. char data[] = new char[(int)fileName.length()];//根据文件长度建立数组
11. FileReader fr = new FileReader(fileName);
12. int num = fr.read(data,4,6);//从文件中读6个字符放到data数组中,起始位置为data[4] //返回值num为从文件中读取字符的长度,即6
13. String str = new String(data, 0, num);// 将字符列表转换成字符串
14. fr.close(); //3. 带缓冲的读文件
BufferedReader的read方法: 增加了一个readLine() 方法throws IOException
int read() 读取单个字符。
int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。
cbuf - 目标缓冲区
off - 开始存储字符处的偏移量 len - 要读取的最大字符数
String readLine() 读取一个文本行。 Java代码
1. //以行为单位从一个文件读取数据, BufferedReader 有read方法和readLine方法
2. BufferedReader in = new BufferedReader( new FileReader(\"F:\\\\TestIO.java\"));
3. String s=null;
4. while((s = in.readLine()) != null) { 5. s+=\"\\n\"; 6. System.out.print(s); 7. }
8. in.close();
(2) 写文件
- 字节流
FileOutputStream的write方法: throws IOException void write(int b)将指定字节b写入文件 b - 要写入的字节
void write(byte[] b)将b.length 个字节从指定 byte 数组写入此文件输出流中
void write(byte[] b,int off,int len)将byte数组中从偏移off开始的len个字节写入文件输出流 b - 数据
off - 数据中的起始偏移量 len - 要写入的字节数 Java代码
1. //1. 不带缓冲的写文件
2. byte b[]=new byte[512];
3. int count=System.in.read(b); //从键盘读取一行字符(写一个读一个,最大读取512个,回车读取结束),存储到缓冲区 4. boolean a = true;//true表示追加,false表示覆盖 5. FileOutputStream fos = new FileOutputStream(\"C:\\\\saveFile.txt\
6. fos.write(b);//把缓冲区b的内容写到指定的文件中 7. fos.close();
//2. 带缓冲的写文件 见文件操作(读)
BufferedOutputStream的方法: throws IOException void write(int b)将指定字节b写入文件 b - 要写入的字节
void write(byte[] b)将b.length 个字节从指定 byte 数组写入此文件输出流中
void write(byte[] b,int off,int len)将byte数组中从偏移off开始的len个字节写入文件输出流 b - 数据
off - 数据中的起始偏移量 len - 要写入的字节数 void flush()刷新此缓冲的输出流,迫使所有缓冲的输出字节被写出到底层输出流中
- 字符流
//1. 不带缓冲的写文件
FileWriter的write方法: throws IOException
void write(int b)将指定字节b写入文件 b - 要写入的字节
void write(byte[] b)将b.length 个字节从指定 byte 数组写入此文件输出流中
void write(byte[] b,int off,int len)将byte数组中从偏移off开始的len个字节写入文件输出流 b - 数据
off - 数据中的起始偏移量 len - 要写入的字节数 Java代码
1. FileReader fr = null; 2. FileWriter fw = null; 3. int bi;
4. fr = new FileReader(\"d:\\\emp\\\\read.txt\"); 5. fw = new FileWriter(\"d:\\\emp\\\\save1.txt\"); 6. while ((bi = fr.read()) != -1) {
7. fw.write(bi);//一次读一个字符(一个汉字字符占两个字节,一个英文字符占一个字节) 8. }
9. fr.close(); 10.fw.close();
//2. 带缓冲的写文件
BufferedWriter的方法: throws IOException
void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void write(int c) 写入单个字符。
void write(String s, int off, int len) 写入字符串的某一部分 s - 要写入的字符串
off - 开始读取字符处的偏移量 len - 要写入的字符数
void newLine() 写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义,并且不一定是单个新行 ('\\n') 符 void flush()刷新此缓冲的输出流,迫使所有缓冲的输出字节被写出到底层输出流中 Java代码
1. public class BufferedReaderWriterDemo {
2. public static void main(String[] args) { 3. try {
4. // 缓冲System.in输入流
5. // System.in是位流,可以通过InputStreamReader将其转换为字符流
6. BufferedReader bufReader = new BufferedReader( 7. new InputStreamReader(System.in)); 8. // 缓冲FileWriter
9. BufferedWriter bufWriter = new BufferedWriter(new FileWriter(
10. \"F:\\\\saveFile.txt\")); 11. String input = null;
12. // 每读一行进行一次写入动作
13. while (!(input = bufReader.readLine()).equals(\"quit\")) {
14. bufWriter.write(input);
15. // newLine()方法写入与操作系统相依的换行字符,依执行环境当时的OS来决定该输出那种换行字符
16. bufWriter.newLine(); 17. }
18. bufReader.close(); 19. bufWriter.close();
20. } catch (ArrayIndexOutOfBoundsException e) { 21. System.out.println(\"没有指定文件\"); 22. } catch (IOException e) { 23. e.printStackTrace(); 24. } 25. } 26.}
2. 内存读写
ByteArrayInputStream和ByteArrayOutputStream是将位数组当作流输入来源、输出目的地的类。
CharArrayReader和CharArrayWriter将字符数组当作字符数据输入输出的来源和目的
ByteArrayInputStream的方法: throws IOException 构造函数:ByteArrayInputStream(byte[] buf)
创建一个 ByteArrayInputStream,使用 buf 作为其缓冲区数组。 ByteArrayInputStream(byte[] buf, int offset, int length)
创建 ByteArrayInputStream,使用 buf 作为其缓冲区数组。 buf - 输入缓冲区。
offset - 缓冲区中要读取的第一个字节的偏移量。 length - 从缓冲区中读取的最大字节数。 int read()读取单个字节 int read(byte[] b)从输入流中将最多 b.length 个字节的数据读入到 byte 数组中
b - 存储读取数据的缓冲区。
返回:读入缓冲区的字节总数,如果到达文件末尾而没有更多的数据,返回 -1
int read(byte[] b, int off,int len)读取len个字节到字节数组b中的指定位置
b - 目标缓冲区。
off - 开始存储字节处的偏移量。 len - 要读取的最大字节数。
ByteArrayOutputStream的方法: byte[] toByteArray()
创建一个新的 byte 数组,大小是此输出流的当前大小,并且缓冲区的有效内容已复制到该数组中。 String toString() 使用平台默认的字符集,通过解码字节将缓冲区内容转换为字符串。
String toString(String charsetName) 使用指定的 charsetName,通过解码字节将缓冲区内容转换为字符串。
void write(byte[] b, int off, int len)
将byte数组中从偏移量off开始的len个字节写入此byte数组输出流。
b - 数据。
off - 数据的初始偏移量。 len - 要写入的字节数。
void write(int b) 将指定的字节写入此 byte 数组输出流。
void writeTo(OutputStream out) 将此 byte 数组输出流的全部内容写入到指定的输出流参数中。 Java代码
1. public class ByteArrayStreamDemo {
2. public static void main(String[] args) { 3. try {
4. BufferedInputStream bufInputStream = new BufferedInputStream(
5. new FileInputStream(\"F:\\\\read.txt\"));
6. ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
7. byte[] bytes = new byte[1]; 8. // 将文件内容写入位数组流
9. while (bufInputStream.read(bytes) != -1) { 10. arrayOutputStream.write(bytes); 11. }
12. arrayOutputStream.close(); 13. bufInputStream.close();
14. // toByteArray()方法,以字符方式显示位数组内容 15. bytes = arrayOutputStream.toByteArray(); 16. for (int i = 0; i < bytes.length; i++) { 17. System.out.print((char) bytes[i]); 18. }
19. //toString()方法
20. System.out.println(arrayOutputStream.toString()); 21.
22. // writeTo方法
23. //写到控制台输出流(能直接输出)
24. arrayOutputStream.writeTo(System.out);
25. FileOutputStream fo=new FileOutputStream(\"F:\\\\saveFile.txt\
26. //写到文件输出流,能直接输出 27. arrayOutputStream.writeTo(fo); 28.
29. // 让使用者输入位置与字符修改位数组内容 30. Scanner scanner = new Scanner(System.in); 31. System.out.print(\"请输入修改位置:\"); 32. int pos = scanner.nextInt();
33. System.out.println(\"输入修改字符\"); 34. // 修改数组中对应的字符
35. bytes[pos - 1] = (byte) scanner.next().charAt(0);
36. // 将位数组内容存回文件
37. ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(
38. bytes); // 参数是数组
39. BufferedOutputStream bufOutputStream = new BufferedOutputStream(
40. new FileOutputStream(\"F:\\\\read.txt\")); 41. byte[] tmp = new byte[1];
42. while (byteArrayInputStream.read(tmp) != -1)//从字节数组中读取数据
43. bufOutputStream.write(tmp); 44. byteArrayInputStream.close(); 45. bufOutputStream.flush(); 46. bufOutputStream.close();
47. } catch (ArrayIndexOutOfBoundsException e) { 48. System.out.println(\"请指定文件名称\"); 49. } catch (IOException e) { 50. e.printStackTrace(); 51. } 52. } 53.}
CharArrayReader的方法:
构造函数:CharArrayReader(char[] buf)创建一个 CharArrayReader,使用 buf 作为其缓冲区数组。
CharArrayReader (char[] buf, int offset, int length) 创建 CharArrayReader,使用 buf 作为其缓冲区数组。 buf - 输入缓冲区。
offset - 缓冲区中要读取的第一个char的偏移量。 length - 从缓冲区中读取的最字符数。
int read()读取单个字符
int read(char[] c)将最多 c.length 个字符读入到 char 数组中 c - 存储读取数据的缓冲区。
返回:读取的实际字符数;如果到达流末尾,则返回 -1
int read(char[] c, int off,int len)读取len个字节到字节数组b中的指定位置
c - 目标缓冲区。
off - 开始存储字符的偏移量。 len - 要读取的最大字符数。
CharArrayWriter的方法:
char[] toCharArray() 返回输入数据的副本。 String toString() 将输入的数据转换为字符串。 void write(char[] b, int off, int len)
将char数组中从偏移量off开始的len个字节写入此CharArrayWriter数组输出。 c - 数据。
off - 数据的初始偏移量。 len - 要写入的字符数。
void write(String str, int off, int len) 将字符串的某一部分写入缓冲区。
str -要写入的字符串。 off - 数据的初始偏移量。 len - 要写入的字符数。
void write(int b) 将一个字符写入缓冲区。
void writeTo(Writer out) 将缓冲区的内容写入另一个字符流。 Java代码
1. public class CharArrayReaderWriterDemo { 2. public static void main(String[] args) { 3. try {
4. BufferedReader bufInputReader = new BufferedReader(new FileReader(
5. \"F:\\\\read.txt\"));
6. CharArrayWriter charArrayWriter = new CharArrayWriter();
7. char[] array = new char[1]; 8. // 将文件读入字符数组
9. while (bufInputReader.read(array) != -1) { 10. charArrayWriter.write(array); 11. }
12. charArrayWriter.close(); 13. bufInputReader.close(); 14.
15. // toCharArray()方法 显示字符内容
16. array = charArrayWriter.toCharArray(); 17. for (int i = 0; i < array.length; i++) { 18. System.out.print(array[i] + \" \"); 19. }
20. //toString()方法
21. System.out.println(charArrayWriter.toString()); 22.
23. // writeTo方法 写到文件输出流,能直接输出
24. FileWriter fw=new FileWriter(\"F:\\\\saveFile.txt\");
25. charArrayWriter.writeTo(fw); 26. fw.close(); 27.
28. // 将字符数组内容存回文件
29. CharArrayReader charArrayReader = new CharArrayReader(array);
30. BufferedWriter bufWriter = new BufferedWriter(new FileWriter(\"F:\\\\read.txt\"));
31. char[] tmp = new char[1];
32. while (charArrayReader.read(tmp) != -1) { 33. bufWriter.write(tmp); 34. }
35. charArrayReader.close(); 36. bufWriter.flush(); 37. bufWriter.close();
38. } catch (ArrayIndexOutOfBoundsException e) { 39. System.out.println(\"请指定文件名!\"); 40. } catch (IOException e) { 41. e.printStackTrace(); 42. } 43. } 44.} 3. 其它
InputStreamReader 和 OutputStreamWriter,用于字节流与字符流之间的转换
InputStreamReader从一个数据源读取字节,并自动将其转换成Unicode字符,除非特别声明
OutputStreamWriter将字符的Unicode编码写到输出流,如果你的使用的不是Unicode字符,OutputStreamWriter会将你的字符编码转换成Unicode编码。
在InputStreamReader和OutputStreamWriter的结尾链接一个
BufferedReader和BufferedWriter是一个好主意。记住对BufferedWriter使用flush()方法。
// 读写文件的编码:
InputStreamReader r = new InputStreamReader(new FileInputStream(fileName), \"utf-8\");
OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(fileName),\"utf-8\");
因篇幅问题不能全部显示,请点此查看更多更全内容
Copyright © 2019- dfix.cn 版权所有 湘ICP备2024080961号-1
违法及侵权请联系:TEL:199 1889 7713 E-MAIL:2724546146@qq.com
本站由北京市万商天勤律师事务所王兴未律师提供法律服务