Go语言视频零基础入门到精通

admin

java中常用的IO操作基本上可以分为四大部分，分别是：File类操作、RandomAccessFile类操作、字节流操作、字符流操作。只要熟练掌握了本文中所列举的所有例子，基本上对于Java的IO流操作就可以说是掌握了。下面将以JUnit测试用例的方式，用一个个例子的方式列出这四大部分中常用的操作例子。一、File类操作File类操作定义了最基本的、与操作系统的稳健系统相关的操作，可以对文件夹、文件进行一系列的操作。 1、常用的一些用法

1.        //1.两个常量
2. @Test public void twoConstant(){
3. //输出： "/"  ":"
4. System.out.println(File.separator);
5. System.out.println(File.pathSeparator);
6. }
8. //2.创建新文件
9. @Test public void createFile(){
10. File f = new File("hello");
11. try{
12. f.createNewFile();
13. System.out.println("创建了文件：" + f.getAbsolutePath());
14. }catch(Exception e){
15. e.printStackTrace();
16. }
17. }
19. //3.创建一个文件夹
20. @Test public void createFolder(){
21. try{
22. File file = new File("HelloFolder");
23. //当一个目录下既没有该名字对应的目录和文件时，才能建立该文件夹
24. if(!file.isDirectory() && !file.isFile()){
25. file.mkdir();
26. //file.mkdirs(); //如果上级目录不存在，那么一并创建上级目录
27. }else{
28. System.out.println("已存在该名称的文件或文件夹");
29. }
30. }catch(Exception e){
31. e.printStackTrace();
32. }
33. }
35. //4.删除一个文件
36. @Test public void deleteFile(){
37. try{
38. File file = new File("hello");
39. if(file.exists()){
40. file.delete();
41. }else{
42. System.out.println("文件不存在");
43. }
44. }catch(Exception e){
45. e.printStackTrace();
46. }
47. }
49. //5.删除一个文件夹（与删除文件一样）
50. @Test public void deleteFolder(){
51. try{
52. File file = new File("HelloFolder");
53. if(file.exists()){
54. file.delete();
55. }else{
56. System.out.println("该文件夹不存在");
57. }
58. }catch(Exception e){
59. e.printStackTrace();
60. }
61. }
63. //6.获取指定目录下所有文件的文件名（包括隐藏文件和文件夹）
64. @Test public void getAllFileName(){
65. try{
66. File folder = new File(".");  //当前目录
67. String[] fileStrs = folder.list();
68. for(String str : fileStrs){
69. System.out.print(str + " ");
70. }
71. }catch(Exception e){
72. e.printStackTrace();
73. }
74. }
76. //7.获取指定目录下所有文件的路径
77. @Test public void getAllFilePath(){
78. try{
79. File folder = new File(".");  //当前目录
80. File[] files = folder.listFiles();
81. for(File file : files){
82. System.out.println(file.getCanonicalPath());
83. }
84. }catch(Exception e){
85. e.printStackTrace();
86. }
87. }   

复制代码

2、打印指定目录下的所有文件（递归调用）

1. package com.chanshuyi.io;
3. /**
4. * 列出指定目录的全部内容
5. * */
7. import java.io.*;
9. class ListAllFile{
10.     public static void main(String[] args) {
11.         File f = new File(".");
12.         print(f);
13.     }
14.    
15.     //递归打印
16.     public static void print(File f){
17.     if(f != null){
18.     if(f.isDirectory()){
19.     File[] fileArray = f.listFiles();
20.     if(fileArray != null){
21.     for(int i = 0; i < fileArray.length; i++){
22.     print(fileArray[i]);
23.     }
24.     }
25.     }else{
26.     System.out.println(f);
27.     }
28.     }
29.     }
30. }

复制代码

二、RandomAccessFile类操作RandomAccessFile类可以对文件进行随机访问，比如可以指定读写指针到某一个字节处，也可以读写指针指定跳过指定字节数。简单地说，RandomAccessFile类提供了许多方法，使得我们可以对文件进行更加细致的读写操作。

1. //8.随机读写文件类
2. @Test public void operateRandom(){
3. try{
4. //1.跳过两个字节读取文件内容
5. //文件内容是：Hello, this is demo File.
6. RandomAccessFile randomRW = new RandomAccessFile(new File("demo.txt"), "rw");
7. randomRW.skipBytes(2);  //跳过两个字节，即跳过了"he"两个英文字符（一个英文字符占用1个字节）
8. byte b[] = new byte[100];
9. int length = randomRW.read(b);
10. System.out.println("总共读取了" + length + "个字节，读取的内容是：" + new String(b));
11. //总共读取了23个字节，读取的内容是：llo, this is demo File.
13. //2.将读写指针跳回文件头重新读取
14. randomRW.seek(0);
15. length = randomRW.read(b);
16. System.out.println("总共读取了" + length + "个字节，读取的内容是：" + new String(b));
17. //总共读取了25个字节，读取的内容是：Hello, this is demo File.
19. //3.获取读写指针所在地址
20. long pointer = randomRW.getFilePointer();
21. System.out.println("文件指针地址：" + pointer);  //文件指针地址：25
22. randomRW.seek(2);
23. pointer = randomRW.getFilePointer();
24. System.out.println("文件指针地址：" + pointer);//文件指针地址：2
25. randomRW.seek(77);
26. pointer = randomRW.getFilePointer();
27. System.out.println("文件指针地址：" + pointer);//文件指针地址：77
29. randomRW.close();
30. }catch(Exception e){
31. e.printStackTrace();
32. }

复制代码

三、字节流读写FileInputStream / FileOutputStream - 实现了对文件的读写操作ObjectInpuStream / ObjectOutputStream - 实现了对序列化对象的读写操作ByteArrayInputStream / ByteArrayOutputStream - 实现了对字节数组的读写操作PipedInputStream / PipedOutputStream - 实现不同线程之间的通信SequenceInputStream - 实现不同输入流的合并（此对象没有对应的OutputStream类）BufferedInputStream / BufferedOutputStream - 实现读写缓存层1、字节流读取 - byte（表示读取的数据类型是byte或byte[]）

1. //15.字节流读取 - byte
2. @Test public void readByte(){
3. try{
4. File file = new File("hello.txt");
5. InputStream fos = new FileInputStream(file);
7. byte[] bytes = new byte[fos.available()];
8. fos.read(bytes);
9. String str = new String(bytes);
10. System.out.println("文件内容是:\n" + str);
11. fos.close();
13. }catch(Exception e){
14. e.printStackTrace();
15. }
16. }

复制代码

2、字节流读取（缓存） - byte

1. //字节流读取（缓存） - byte
2. @Test public void writeByteWithBuffere(){
3. try{
4. File file = new File("hello1.txt");
5. OutputStream fos = new FileOutputStream(file);
6. BufferedOutputStream out = new BufferedOutputStream(fos);
8. out.write("你好\n".getBytes());
9. out.write("吃饭了么!".getBytes());
10. out.flush();
12. fos.close();
13. }catch(Exception e){
14. e.printStackTrace();
15. }
16. }

复制代码

3、字节流写入 - byte

1. //17.字节流写入 - byte
2. @Test public void writeByte(){
3. try{
4. File file = new File("hello.txt");
5. OutputStream fos = new FileOutputStream(file);
6. fos.write("Hello Mac.\n你好，Mac.".getBytes());
7. fos.close();
8. }catch(Exception e){
9. e.printStackTrace();
10. }
11. }

复制代码

4、字节流写入（缓存） - byte

1. //18.字节流写入（缓存） - byte
2. @Test public void writeByteWithBuffer(){
3. try{
4. File file = new File("hello.txt");
5. OutputStream fos = new FileOutputStream(file);
6. BufferedOutputStream bos = new BufferedOutputStream(fos);
8. bos.write("Hello Mac.\n你好，Mac.".getBytes());
9. bos.close();
10. fos.close();
11. }catch(Exception e){
12. e.printStackTrace();
13. }
14. }

复制代码

如果你仔细敲过上面4个例子的代码你会发现，其实好像字节流的读取和写入，好像加了缓存和没加缓存，它们的代码好像都差不多啊，至少再写入数据的时候是一样的。而字符流的读取在加了缓存层之后，至少还能直接读取整行数据，字符流的写入加了缓存之后，可以写入换行符。那字节流的缓存究竟有什么必要性呢？确实，从代码以及其方法上看，其实他们并没有什么区别，但是从官方的API文档来看，缓存最重要的一个地方就是减少程序对于磁盘的IO次数。加了缓存的程序再读取的时候会一次性读取很多个字节，之后提供给程序使用，但如果你不加缓存，那么程序就只会读取代码中指定的字节数。这在你一个字节一个字节从文件中读取数据的时候，其差别就凸现出来了。如果你没有使用缓存进行数据读取，那么你每读一个字节的数据，程序就去磁盘读取一次文件，这样会造成磁盘的频繁IO读取，减少磁盘的寿命。5、ObjectInputStream / ObjectOutputStream - 序列化一个对象要被序列化的POJO对象：

1. package com.chanshuyi.io.po;
3. import java.io.Serializable;
5. public class Student implements Serializable{
7. /**
8. * 序列化ID
9. */
10. private static final long serialVersionUID = 7288449352920655248L;
12. private String name;
14. private int age;
16. private String phone;
18. public Student(){
20. }
22. public Student(String name, int age, String phone){
23. this.name = name;
24. this.age = age;
25. this.phone = phone;
26. }
28. public String getName() {
29. return name;
30. }
32. public void setName(String name) {
33. this.name = name;
34. }
36. public int getAge() {
37. return age;
38. }
40. public void setAge(int age) {
41. this.age = age;
42. }
44. public String getPhone() {
45. return phone;
46. }
48. public void setPhone(String phone) {
49. this.phone = phone;
50. }
52. public String toString(){
53. return name + "," + age + "," + phone;
54. }
56. }

复制代码

被序列化的POJO对象需要实现Serializable接口。序列化对象方法：

1. //20.ObjectOutputStream - 序列化对象 - 将对象属性序列化保存
2. @Test public void serialized(){
3. try{
4. Student std = new Student("Tommy", 13, "18923923876");
5. ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("StudentObject.obj"));
6. oos.writeObject(std);
7. oos.close();
8. }catch(Exception e){
9. e.printStackTrace();
10. }
11. }

复制代码

反序列化对象方法：

1. //21.ObjectInputStream - 反序列化对象 - 读取序列化后的对象
2. @Test public void deSerialized(){
3. try{
4. ObjectInputStream ois = new ObjectInputStream(new FileInputStream("StudentObject.obj"));
5. Student std = (Student)ois.readObject();
6. System.out.println(std);
7. ois.close();
8. }catch(Exception e){
9. e.printStackTrace();
10. }
11. }

复制代码

6、ByteArrayInputStream / ByteArrayOutputStream - 操作内存字节数据

1. //19.ByteArrayInputStream - 内存操作流 - 将内存数据转化为流
2. @Test public void random2Stream(){
3. try{
4. String str = "你好";
5. ByteArrayInputStream input = new ByteArrayInputStream(str.getBytes());
6. ByteArrayOutputStream output = new ByteArrayOutputStream();
7. int temp = 0;
8. while((temp = input.read()) != (-1)){
9. char ch = (char)temp;
10. output.write(Character.toLowerCase(ch));
11. }
12. String outputStr = output.toString();
13. input.close();
14. output.close();
15. System.out.println(outputStr);
17. }catch(Exception e){
18. e.printStackTrace();
19. }
20. }

复制代码

7、PipedInputStream / PipedOutputStream - 实现进程间的管道通信接收者：

1. package com.chanshuyi.io.pineStream;
3. import java.io.PipedInputStream;
5. /**
6. * 管道流 - 接收者
7. * @author yurongchan
8. *
9. */
10. public class Receiver implements Runnable{
12. private PipedInputStream in = null;
14. public Receiver(){
15. in = new PipedInputStream();
16. }
18. public PipedInputStream getIn(){
19. return this.in;
20. }
22. public void run(){
23. byte[] b = new byte[1000];
24. int length = 0;
25. try{
26. length = this.in.read(b);
27. }catch(Exception e){
28. e.printStackTrace();
29. }
30. System.out.println("接收到的消息：" + new String(b, 0, length));
31. }
32. }

复制代码

发送者：

1. package com.chanshuyi.io.pineStream;
3. import java.io.PipedOutputStream;
5. /**
6. * 管道流 - 发送者
7. * @author yurongchan
8. *
9. */
10. public class Send implements Runnable{
11. private PipedOutputStream out = null;
13. public Send(){
14. out = new PipedOutputStream();
15. }
17. public PipedOutputStream getOut(){
18. return this.out;
19. }
21. public void run(){
22. String msg = "Hello, I"m outputer.\n你好，我是发送者。";
23. try{
24. out.write(msg.getBytes());
25. out.close();
26. }catch(Exception e){
27. e.printStackTrace();
28. }
29. }
30. }

复制代码

测试方法：

1. //22.PipedInputStream - 在不同线程之间进行通信
2. @Test public void pipeContact(){
3. try{
4. Send send = new Send();
5. Receiver receiver = new Receiver();
6. try{
7. send.getOut().connect(receiver.getIn());
8. }catch(Exception e){
9. e.printStackTrace();
10. }
11. new Thread(send).start();
12. new Thread(receiver).start();
13. }catch(Exception e){
14. e.printStackTrace();
15. }
16. }

复制代码

8、SequenceInputStream - 合并输入流

1. //23.SequenceInputStream - 合并几个输入流
2. @Test public void sequenceInputStream(){
3. try{
4. InputStream is1 = new FileInputStream(new File("sequence1.txt"));
5. InputStream is2 = new FileInputStream(new File("sequence2.txt"));
6. OutputStream os = new FileOutputStream(new File("sequence3.txt"));
7. SequenceInputStream sis = new SequenceInputStream(is1, is2);
8. int temp = 0;
9. while((temp = sis.read()) != -1){
10. os.write(temp);
11. }
12. sis.close();
13. is1.close();
14. is2.close();
15. os.close();
16. }catch(Exception e){
17. e.printStackTrace();
18. }
19. }

复制代码

之后打开sequence3.txt会发现，1、2文本中的内容都到了sequence3.txt中了。四、字符流读写字符流的读写实际上还是基于字节流实现的，而且数组存储时更多是以字节为单位存储，因此更多时候还是使用字节流进行读写操作。因此对于字符流的读写，我们只需要掌握常用的几个操作即可。InputStreamReader / OutputStreamWriter - 实现字符流的读写BufferedReader / BufferedWriter - 实现字符流的缓存层FileReader / FileWriter - 字符流的工具类1、字符流读取 - char（表示读取的数据类型是char或char[]）

1. //9.字符流读取 - char
2. @Test public void writeChar(){
3. try{
4. 　　　　InputStreamReader reader = new InputStreamReader(new FileInputStream("OutputStreamWriter.txt"));
5. 　　　　char[] chars = new char[1000];
6. 　　　　int length = reader.read(chars);
7. 　　　　System.out.println("一共读取了" + length + "个字符，内容是：" + new String(chars));
8. 　　　　reader.close();
9. 　　}catch(Exception e){
10. 　　　　e.printStackTrace();
11. 　　}
12. }

复制代码

2、字符流读取（缓存） - char

1. //10.字符流读取（缓存）
2. @Test public void writeCharWithBuffer(){
3. try{
4. InputStreamReader isr = new InputStreamReader(new FileInputStream("BufferedWriter.txt"));
5. BufferedReader reader = new BufferedReader(isr);
6. String str = "";
7. while((str = reader.readLine()) != null && str.length() != 0){
8. System.out.println(str);
9. }
10. reader.close();
11. }catch(Exception e){
12. e.printStackTrace();
13. }
14. }

复制代码

3、字符流写入 - char / char[] / String

1. //11.字符流写入
2. @Test public void readChar(){
3. try{
4. 　　OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("OutputStreamWriter.txt"));
5. 　　writer.write("AllFileTest.fileReadUtil -> 字符流写入文件");
6. 　　writer.close();
7. }catch(Exception e){
8. 　　e.printStackTrace();
9. }
10. }

复制代码

4、字符流的写入（缓存）- char/ String

1. //12.字符流写入（缓存）
2. @Test public void readCharWithBuffer(){
3. try{
4. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("BufferedWriter.txt"));
5. BufferedWriter writer = new BufferedWriter(osw);
6. writer.write("AllFileTest.fileReadUtil -> 字符流写入文件");
7. writer.newLine();//换行
8. writer.write("第二行");
9. writer.close();
10. }catch(Exception e){
11. e.printStackTrace();
12.     }
13. }

复制代码

总结一下上面四种方式的字符流写入写出，我们会发现两个规律，一个是读写规律，一个是缓存层的规律：&middot; 读写规律。字符流的读取，其读取的数据都是char（字符型）的单个或者数组。而字符流的写入除了可以写入单个或多个char类型的字符歪，还可以直接写入String（字符串）类型。&middot; 缓存层规律。字符流的读写，增加了缓存层之后的一个明显区别就是：加了缓存层（Buffer）之后，字符流读取可以实现整行读取（readLine），而字符流写入可以实现写入换行符（writeLine）。5、文件读取工具类

1. //13.FileReader - 文件读取工具类（这是加了缓存的。但也可以不加缓存）
2. @Test public void fileReadUtil(){
3.     try{
4. FileReader fr = new FileReader(new File("demo.txt"));
5. BufferedReader reader = new BufferedReader(fr);
6. String str = "";
7. while((str = reader.readLine()) != null && str.length() != 0){
8. System.out.println(str);
9. }
10. reader.close();
11. }catch(Exception e){
12. e.printStackTrace();
13. }
14. }

复制代码

将这个例子与上面的第2个例子，即加了缓存的字符流读取例子相比，你会发现其实这两个例子的区别就只是声明FileReader、InputStreamReader的区别而已。声明FileReader只需要再加上File类型参数即可，而声明InputStreamReader则需要再加上一个FileInputStream类，之后才能跟上File类型的参数。因此，我们才说FileReader是一个文件读取工具类。6、文件写入工具类

1. //14.FileWriter - 文件写入工具类（这是加了缓存的。但也可以不加缓存）
2. @Test public void fileWriteUtil(){
3. try{
4. FileWriter fw = new FileWriter(new File("FileWriteUtil1.txt"));
5. BufferedWriter writer = new BufferedWriter(fw);
6. writer.write("HelloMan1");
7. writer.newLine();
8. writer.write("HelloMan2");
9. writer.close();
10. }catch(Exception e){
11. e.printStackTrace();
12. }
13. }

复制代码

同样的，其实FileWriter与OutputStreamWriter也只是声明上的区别而已。五、其他这里会收集一些不怎么常用，但是有时也会用到的例子，遇到的时候可以快速的查询到。1、追加新的内容

1. //9.字节流 - 追加新内容
2. //无论是字节流还是字符流，要追加新的内容都是再FileOutputStream中指定第二个参数为true
3. @Test public void appendFile(){
4. try{
5. File file = new File("hello.txt");
6. OutputStream fos = new FileOutputStream(file, true);
8. String str = "\n这是新增加的内容";
9. fos.write(str.getBytes());
10. fos.close();
12. }catch(Exception e){
13. e.printStackTrace();
14. }
15. }

复制代码

2、模拟打印流输出数据

1. //18.打印流 - 模拟打印的方式输出数据
2. @Test public void printStream(){
3. try{
4. PrintStream print = new PrintStream(new FileOutputStream(new File("PrintStream.txt")));
5. print.println(true);
6. print.println("您好，我是打印输出流");
7. print.printf("名字：%s.年龄：%d", "Tom", 32); //格式化输出
8. print.close();
9. //这里的数据要再PrintStream.txt文件中才能看到
10. }catch(Exception e){
11. e.printStackTrace();
12. }
13. }

复制代码

3、使用OutputStream向屏幕输出内容

1. //19.使用OutputStream向屏幕输出内容
2. @Test public void systemOutStream(){
3. try{
4. OutputStream out = System.out;
5. out.write("你好".getBytes());
6. out.close();
7. }catch(Exception e){
8. e.printStackTrace();
9. }
10. }

复制代码

4、标准输出重定向

1. //20.标准输出重定向
2. @Test public void redirectOutput(){
3. try{
4. System.out.println("Print in the Screen. 你好");
5. System.setOut(new PrintStream(new FileOutputStream(new File("RedirectOutput.txt"))));
6. //下面的输出都将重定向到文件中
7. System.out.println("=== 重定向后的输出 ===");
8. System.out.println("Hello, Eclipse in Mac.");
9. }catch(Exception e){
10. e.printStackTrace();
11. }
12. }

复制代码

5、标准输入重定向

1. //21.标准输入重定向
2. @Test public void redirectInput(){
3. try{
4. File file = new File("RedirectOutput.txt");
5. if(!file.exists()){
6. System.out.println("文件不存在!");
7. return;
8. }else{
9. System.setIn(new FileInputStream(file));
10. byte b[] = new byte[1000];
11. int length = System.in.read(b);
12. System.out.println("读入的内容为:" + new String(b, 0, length));
13. }
14. }catch(Exception e){
15. e.printStackTrace();
16. }
17. }

复制代码

6、错误输出重定向

1. //22.错误输出重定向
2. @Test public void redirectErrOutput(){
3. try{
4. System.err.println("Print in the Screen. 你好");
5. System.setErr(new PrintStream(new FileOutputStream(new File("RedirectErrOutput.txt"))));
6. //下面的输出都将重定向到文件中
7. System.err.println("=== 重定向后的错误输出 ===");
8. System.err.println("Hello, Eclipse in Mac.");
9. }catch(Exception e){
10. e.printStackTrace();
11. }
12. }

复制代码

感谢以下博文的参考：1、http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html2、http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html