Java IO流学习笔记

首先我们先看看整个IO流的体系图

Java IO流学习笔记

由图中我们可以看出，Java的IO主要分为字节流和字符流两部分。每一部分都有相应的读和写操作，再往下就是各种操作的细分，比如BufferReader,InputerStreamReader之类，就是缓存读取，和字节流通向字符流的读取方式。

一、文件

1. 先来看下简单的文件创建：

/**
 * Created by Administrator on 2016/2/28.
 */
public class CreateFile {
public static void main(String[] args){
        File file =  new File("E:"+ File.separator+"newFile.txt");
try {
            file.createNewFile();
        } catch (IOException e) {
           e.printStackTrace();
        }
    }
}

首先创建一个文件对象，填写路径（这里输入的是绝对路径，如果输入相对路径“newFile.txt”则会在项目目录下面生成文件
创建完对象之后可以使用File类中的createNewFile（）方法创建对象，该操作会可能会抛出IO异常（主要原因为路径填写出问题）
当该路径已经有文件的时候，再调用该方法，不会覆盖源文件
文件路径中使用了File对象中的常量，表示 “ \ ”，在windows系统下我们使用\进行分隔操作，但是在Linux系统下就不是如此，所以使用File类中的常量可以增强代码的强壮性。

2.创建目录：

/**
 * Created by Administrator on 2016/2/28.
 */
public class CreateFile {
public static void main(String[] args){
        File file =  new File("E:/newFile.txt");
        file.mkdir();   //创建一个文件夹
    }
}

目录创建的方法和创建文件的方法类似，不同的是使用了File类中的mkdir（）方法
mkdir（）这个方法和我们在windows,linux系统下创建目录的方法相同，这个比较容易理解

3.显示目录下面所有的文件：

/**
 * Created by Administrator on 2016/2/28.
 */
public class listFile {
@Test
public void showAllFiles(){
        String mkdirName = "E:"+ File.separator;
        File file = new File(mkdirName);
        String[] str = file.list();
// File[] fileArray=file.listFiles();
for(String names :str){
            System.out.println(names);
        }
    }
}

代码中直接调用了File类中的list方法，返回一个字符串数组，其中包含了所有的文件名（目录与文件）
当调用File类中的listFiles（）方法时，返回的则是一个文件数组，这个操作需要先判断文件是否为目录
判断文件是否为目录，可以使用isDirectory（）方法进行判断。

二、字符流

1.FileReader
首先我们来看下最简单的，从文件中读取出文本信息

package com.joker.FileReader;

import org.junit.Test;

import java.io.*;

/**
 * Created by jaycekon on 2016/3/10.
 */
public class ReadFile {
@Test
public void readFile(){
        File file = new File("E:"+ File.separator+"hello.txt");
char[] buffer=new char[512];
int num = 0;
        FileReader reader =null;
try {

             reader = new FileReader(file);
             reader.read(buffer);
             System.out.println(buffer);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

输出结果：

hello
world!

首先我们找到文件，然后创建FileReader对象，在构造函数里面提供了三种构造方法分别是String,File和FileDescriptor三种不同参数构成个构造函数。
然后我们需要用到一个字符数组来装载我们从文件中读取到的内容，reader.read(buffer);
在read方法里面，有个常用的无参方法和带字符数组的方法
在调用read方法的时候，文件读取是一个一个字符的读取，并且在读取完所有字符后，才会结束
这种方法适用于文件内容较少的情况

2.FileWriter

package com.Joker.Char;

import org.junit.Test;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * Created by Administrator on 2016/3/11.
 */
public class Write {
@Test
public void TestOutWriter(){
try {
            FileWriter writer =new FileWriter("hello.txt");
            writer.write("写入文件!\n");
char[] cs = {'a','b','c'};
            writer.write(cs);
            writer.write("覆盖原文！");
            writer.close();
            FileReader reader = new FileReader("hello.txt");
char[] ch = new char[100];
            reader.read(ch);
            System.out.println(ch);
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

写入文件!
覆盖原文！

这里需要注意的是，在输出流没有关闭时，不会调用写入操作，只有当输出流关闭，才会将缓存中的内容写入文件中。
这里调用的写入方法，会覆盖原文件中的内容
FileWriter提供了4种写入方式，包括char[]和String类型的方式，还有指定长度的写入方式

3.StringReader

package com.Joker.Char;

import org.junit.Test;

import java.io.IOException;
import java.io.StringReader;

/**
 * Created by Administrator on 2016/3/11.
 */
public class StringRead {
@Test
public void TestString(){
        StringReader reader = new StringReader("hello");
char[] ch = new char[100];
try {
            reader.read(ch);
            System.out.println(ch[1]);
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里的用法主要是用来读取字符串，看了一下他的构建方法，只有读取字符串这种方式，所以现在理解的用法是将字符串读取出来，再进行处理

4.PrintWriter

package com.Joker.Char;

import org.junit.Test;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;

/**
 * Created by Administrator on 2016/3/11.
 */
public class printWrite {
@Test
public void testPrint(){
try {
            Writer write= new PrintWriter(System.out);
            write.write("hello world!");
            write.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：


Process finished with exit code 0
hello world!

从输出结果来看，程序是先结束了再输出内容的。如果我们没有关闭输出流，则没有输出。
PrintWriter的用法可以用来输出内容到命令行，类似system.out.print的功能，不过要注意的是输出的时间不是即时的，而是程序结束阶段才会输出。

5.BufferedReader

package com.Joker.Char;

import org.junit.Test;

import java.io.*;

/**
 * Created by Administrator on 2016/3/11.
 */
public class BufferRead {
@Test
public void TestBufferRead(){
        File file = new File("hello.txt");
try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String str;
while((str=reader.readLine())!=null){
                System.out.println(str);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

hello world!==============>1
hello world!==============>2
hello world!==============>3
hello world!==============>4
hello world!==============>5
hello world!==============>6
hello world!==============>7

Process finished with exit code 0

首先我们看一下BufferedReader的构造函数，BufferedReader提供了一个带Reader参数的构造方法，我们需要填入一个Reader类型的对象才能创建BufferedReader对象。
常见的Reader对象有InputStreamReader和FileReader，我们这里用FileReader来演示
再创建出一个BufferedReader之后，我们可以逐行读取文本内容。这种方法对我们大区大文件的时候有很大的帮助，因为在读取的时候不用把所有的内容都放入内存，先放在缓存中，当读到该行的时候在放入内存中，这样可以提高效率并且节省资源。

6.BufferWriter

package com.Joker.Char;

import org.junit.Test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * Created by Administrator on 2016/3/11.
 */
public class BufferedWrite {
@Test
public void testBufferWrite(){
try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("hello.txt"));
for(int i=0;i<10;i++){
                writer.write("hello world! ++++++++"+i+"\n");
            }
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果:

hello world! ++++++++0
hello world! ++++++++1
hello world! ++++++++2
hello world! ++++++++3
hello world! ++++++++4
hello world! ++++++++5
hello world! ++++++++6
hello world! ++++++++7
hello world! ++++++++8
hello world! ++++++++9

BufferedWriter的构造方法和上面的类似，需要写入一个Writer对象，这里面主要起到的作用是做一个缓冲的作用，避免一下子写入大量的文件
最后需要注意的时候，不管使用哪种写入方法，都会覆盖原文件中的内容

三、字节流

package com.Joker.chars;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Created by Administrator on 2016/3/11.
 */
public class FileInputStreams {
@Test
public void testFileInputStreams(){
        File file = new File("hello.txt");
try {
            FileInputStream inputStream = new FileInputStream(file);
byte[] by = new byte[100];
            inputStream.read(by);
            String str = new String(by);
            System.out.println(str);
for(byte b:by){
                System.out.print(b+" ");
            }
            inputStream.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

hello world!

104 101 108 108 111 32 119 111 114 108 100 33

这里面读取到文件的内容是字节类型，如果我们想要获得字符内容的话需要自己手动进行转换

2.FileOutPutSream

package com.Joker.chars;

import org.junit.Test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * Created by Administrator on 2016/3/11.
 */
public class FileOutSreams {
@Test
public void testFileOutSreams(){
        File file = new File("hello.txt");
try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            String str ="Hello Wrold!";
byte[] bytes =str.getBytes();
            fileOutputStream.write(bytes);
            fileOutputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

Hello Wrold!

这里面输出的参数是字节数组，主要用来便于直接输出字节流
我们可以看到写入文件之后字节流变成的字符，所以最后存入文件中的是相应的字符

参考文章：

http://blog.csdn.net/yczz/article/details/38761237
http://www.importnew.com/

秒客网

Java IO流学习笔记

Java IO流学习笔记

一、文件

二、字符流

三、字节流

相关文章

Java IO流 学习笔记

Java IO流学习笔记

一、文件

二、字符流

三、字节流

相关文章

Java IO流学习笔记