Java IO流 学习笔记
Java IO流学习笔记
首先我们先看看整个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/