Java IO流总结

一、IO流操作的基本步骤

1)创建源 2)选择流 3)操作 4)释放资源

二、创建源

1.以文件为源

创建File对象
(官方解释：File类：文件和目录路径名的抽象表示)

File对象的创建形式：

//1.直接路径构建(可为绝对路径或相对路径)
File src = new File("IO.txt");
//2.可以传入父子路径
File src = new File("D:/Java","/src/IO.txt");
//3.可以传入：父对象，子路径
File src = new File(new File("D:/Java/src"),"IO.txt");

File的常用方法及使用:

//返回文件的长度,文件夹为0，未创建的文件夹也为0
long len = src.length();
//返回当前文件或目录的名称
String name = src.getName();
//将此抽象路径名转换为路径名字符串,构建时使用相对路径就返回相对路径，绝对路径就返回绝对路径
String path = src.getPath();
//返回绝对路径名字符串
String absPath = src.getAbsolutePath();
//返回此抽象路径名的父目录的路径名字符串
String parPath = src.getParent();
//返回此抽象路径名的父目录的抽象路径名(父对象)
File parSrc = src.getParentFile();
//当抽象路径表示的文件不存在时，创建一个空文件
boolean flag = src.createNewFile();
//删除此抽象路径名表示的文件或目录
boolean flag = src.delete();
//补充
//显示当前用户目录
String str = System.getProperty("user.dir");
//类的内部域中：与系统相关的默认名称分隔符
//separator-->String  separatorChar-->char
System.out.println(File.separator);//输出 /

//判断此抽象路径名表示的文件是否是普通文件
boolean flag = src.isFile();
//判断此抽象路径名表示的文件是否为目录
boolean flag = src.isDirectory();
//判断此抽象路径名表示的文件或目录是否存在
boolean flag = src.exists();
//文件操作
File src = new File("IO.txt");
if(src == null || !src.exist()){
	System.out.println("文件不存在");
}else}{
	if(src.isFile()){
		System.out.println("文件操作");
	}else{
		System.out.println("文件夹操作");
	}
}

File dir = new File("IO.txt");
//文件夹操作
//创建有此抽象路径名命名的目录，若上级目录存在，则创建成功，否则失败
boolean flag = dir.mkdir();
//上级目录可以不存在，不存在一同创建
boolean flag = dir.mkdirs();
//列出下级文件和目录的名称
String[] subNames = dir.list();
//列出下级文件和目录的File对象
File[] subFiles = dir.listFiles();
//列出所有盘符对象
File[] subFiles = dir.listRoots();

//使用递归实现打印子孙级目录和文件的名称
public class DirName{
	public static void main(Stirng[] args){
		File src = new File("D:/Java");
		printName(src);
	}
	private static void printName(File src){
		System.out.println(src.getName());
		if(src == null || !src.exist()){
			return;
		}else if(src.isDirectory()){
			for(File s : src.listFiles()){
				printName(s);	
			}
		}
	}
}

//统计文件夹的大小
public class DirSize{
	public static void main(String[] args){
		File src = new File("D:/Java");
		count(src);
		System.out.println(length);
	}
	private static long length = 0;
	private static void count(File src){
		if(src!=null && src.exist()){
			if(src.isFile()){
				length+=src.length();
			}else{
				for(File s : src.listFiles())
					count(s);
			}
		}
	}
}

2.以字节数组为源

//编码：字符串-->字节数组
String str = "世界你好";
byte[] datas = str.getBytes();//默认使用工程的字符集
datas = str.getBytes("GBK");//以GBK形式进行编码
//解码：字节数组-->字符串
String msg = new String(datas,0,datas.length,"utf-8");

三、选择流

以文件为源的流

1.FileInputStream文件输入流

• 从文件系统中的文件获取输入字节
  流的创建：

//方式一
File src = new File("IO.txt");
InputStream is = new FileInputStream(src);
//方式二
InputStream is = new FileInputStream("IO.txt");

流的常用方法：

//从该输入流中读取一个字节的数据，返回该字节的编码
int tmp = is.read();  char ch = (char)tmp;
//从该输入流读取最多b.length个字节的数据到一个字节数组，返回读取的内容的长度
byte[] b = new byte[1024];
int len = is.read(b);
//最多读取k个字节数据到字节数组
int len1 = is.read(b,0,k);

//读取操作
byte[] flush = new byte[1024]; //缓冲容器
int len = -1;
while((len=is.read(flush))!=-1){
	String str = new String(flush,0,len);
	System.out.print(str);
}

2.FileOutputStream文件输出流

• 用于将数据写入File或FileDescriptor的输出流中
  流的创建：

//方式一
File dest = new File("IO.txt");
OutputStream os = new FileOutputStream(dest);
//方式二
OutputStream os = new FileOutputStream("IO.txt");
//方式三,在当前文件的内容之后写入文件数据
OutputStream os = new FileOutputStream("IO.txt",true);

流的常用方法：

//将b.length字节从指定的字节数组写入此文件输出流
byte[] b = "Hello world".getBytes();
os.write(b);
//或者从off开始的len个字节写入此文件输出流
os.write(b,0,b.length);

3.FileReader字符文件输入流

• 阅读字符文件
  流的创建：（参照FileInputStream对比）

//方法一
File src = new File("IO.txt");
Reader reader = new FileReader(src);
//方法二
Reader reader = new FileReader("IO.txt");

流的常用方法：

//读一个字符
int tmp = reader.read();
//分段读取
char[] flush = new char[1024];
int len = -1;
while((len=reader.read(flush))!=-1){
	String str = new String(flush,0,len);
	System.out.println(str);
}

此处与FileInputStream的区别在于传进read()的参数为char类型而非byte类型

4.FileWriter字符文件输出流

流的创建：

//方式一
File dest = new File("IO.txt");
Writer writer = new FileWriter(dest);
//方式二
Writer writer = new FileWriter("IO.txt");
//方式三,在当前文件的内容之后写入文件数据
Writer writer= new FileWriter("IO.txt",true);

流的常用方法：

//写出操作
//方法一，以字符数组的形式写入输出流
char[] datas = "Hello world".toCharArray();
writer.write(datas,0,datas.length);
//方法二，以字符串的形式写入输出流
String msg = "hello,world";
writer.write(msg,0,msg.length());
//方法三，append字符串
writer.append("Hello\r\n").append("world");
writer.flush();

以字节数组为源的流

5.ByteArrayInputStream字节数组输入流

• 从字节数组中读出数据
  （源为字节数组而非文件）
  流的创建：

//创建输入的参数为字节数组而非File对象
byte[] src = "The world is beautiful".getBytes();
InputStream is = new ByteArrayInputStream(src);

流的常用方法： read与FileInputStream相类似

6.ByteArrayOutputStream字节数组输出流

• 实现了将数据写入字节数组的输出流中
  (注意此种流与前几种流有些不同)
  流的创建：（创建不需使用源）

//因在子类中增加了新的方法，所以为了使用子类中的方法，不能使用多态
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//创建一个新的字节数组输出流，具有指定大小的缓冲区容量(以字节为单位)
ByteArrayOutputStream baos = new ByteArrayOutputStream(10);

流的常用方法：

//write方法和FileOutputStream相同

//创建一个新分配的字节数组
byte[] dest = baos.toByteArray();
//返回缓冲区当前的大小
int len = baos.size();

缓冲流

7.BufferedInputStream字节缓冲输入流

流的创建：

InputStream is = new BufferedInputStream(new FileInputStream("IO.txt"));
//可以指定缓冲区大小
InputStream is = new BufferedInputStream(new FileInputStream("IO.txt",1024));

流的常用方法： 与FileInputStream相类似

8.BufferedOutputStream字节缓冲输出流

流的创建：

OutputStream os = new BufferedOutputStream(new FileOutputStream("IO.txt"));
//可以指定缓冲区大小
OutputStream os = new BufferedOutputStream(new FileOutputStream("IO.txt",1024));

流的常用方法： 与FileOutputStream相类似

9.BufferedReader字符缓冲输入流

• 从字符输入流读取文本，缓冲字符
  流的创建：

Reader reader = new BufferedReader(new FileReader("IO.txt"));
//可以指定缓冲区大小
Reader reader = new BufferedReader(new FileReader("IO.txt"),1024);

流的常用方法：

//read与FileReader中read相类似
//readLine()读取一行文字
String line = reader.readLine();

10.BufferedWriter字符缓冲输出流

• 将文本写入字符输出流，缓冲字符
  流的创建：

Writer writer = new BufferedWriter(new FileWriter("IO.txt"));
//可以指定缓冲区大小
Writer writer = new BufferedWriter(new FileWriter("IO.txt"),1024);

流的常用方法：

//write与FileWriter中write相类似
//newLine()换行
writer.newLine();

四、IO小练习

1.复制操作

public class Copy {
    public static void main(String[] args) {
        copy("IO.txt","IO_copy.txt");
    }
    
    private static void copy(String srcPath,String destPath){
        File src = new File(srcPath);
        File dest = new File(destPath);
        try(InputStream is = new FileInputStream(src);
            OutputStream os = new FileOutputStream(dest)){
            byte[] flush = new byte[1024];//缓冲容器
            int len = -1;
            while((len=is.read(flush))!=-1){
                os.write(flush,0,len);
            }
            os.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

补充：字符流底层还是基于字节流操作，自动搜寻了指定的码表。