JavaIO编程（1）

1.文件操作类：

File（java.io.File)。java把电脑中的文件和文件夹（目录)封装成一个File类，我们可以使用File类对文件和文件夹进行操作。

File类本身只是操作文件的，不涉及到文件内容。
在使用File类操作的时候路径的分隔符使用：File.separator。

File类中常用操作方法：

1）构造方法：

File(String pathname)	传递完整文件操作路径
File(String parent, String child)	设置父路径与子文件路径

2）普通方法：

boolean createNewFile()
boolean delete()	删除指定路径的文件
boolean mkdirs()	创建多级目录
boolean exists()	文件或目录是否存在
File getParentFile()	取得当前路径的父路径
boolean isFile()	是否为普通文件
boolean isDirectory()	是否为目录
long length()	取得文件大小，以字节为单位返回
long lastModified()	取得文件的最后一次修改日期时间
String [] list()	列出指定目录中的全部内容
File [] listFiles()	列出所有的路径以File类对象包装

列出目录信息：

import java.io.File;
public class TestList {
	public static void main(String args[]){
		File file = new File("D:" + File.separator + "myeclipse" );
		if(file.isDirectory()){					//判断当前路径是否为目录
			File result []= file.listFiles();
			for(int i=0; i<result.length; i++){
				System.out.println(result[i]);	//调用toString
			}
		}
	}
}

（偷个懒，异常就不写了，嘿嘿）

2.字节流与字符流：

作用：操作文件内容。
字节流：InputStream（输入字节流）、OutputStream(输出字节流）。
字符流：Reader（输入字符流）、Writer（输出字符流）。

流分为输入流与输出流（主要看参考点）。
如：下雨››››››水库，在这里面 下雨（输出）水源，水库就是输入流。
水库›››››屋子，水库（输出）水源，这里水库是输出流，屋子则是输入流。

输出流： 程序 >>> OutputStream >>>文件 （程序输出内容到文件）
输入流： 程序 <<< lnputStream <<<文件 （文件输出内容到程序）

流的基本操作形式：
（1）第一步：通过File类定义一个要操作文件的路径；
（2）第二步：通过字节流或字符流的子类为父类对象实例化；（A a = new B()）
（3）第三步：进行数据的读（输入）、写（输出）操作；
（4）第四步：数据流输入资源操作，资源操作必须关闭。（close()）方法

注意：四个操作流的类（OutputStream、InputStream、Writer、Reader）全部都属于操作类，所以必须使用向上转型来操作。

1）字节输出流：OutputStream

OutputStream类的常用方法：

void write(byte[] b)	输出全部字节
void write(byte[] b, int off, int len)	输出部分字节（从off开始输出指定长度的字节）—（使用较多）
abstract void write(int b)	输出单个字节

因为OutputStream本身是一个抽象类，所以需要一个子类来进行文件操作——FileOutputStream

FileOutputStream类的常用方法：

FileOutputStream(File file)	创建文件将内容输出到指定路径，或如果文件已存在，则使用新的内容覆盖就的内容。
FileOutputStream(File file, boolean append)	如果将布尔参数设置为true，表示追加新的内容到文件中。

文件内容的输出：

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


public class TestOutputStream {
	public static void main(String[] args){
		File file = new File("D:"+ File.separator + "demo");	//第一步：定义要输出文件的路径
		if(!file.getParentFile().exists()){			//文件不存在，则创建
			file.getParentFile().mkdir();			//文件不存在，则创建
		}
		OutputStream output = null;
		try {
			output = new FileOutputStream(file);	//第二步：用OutputStream和子类FileOutputStream进行对象的实例化
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		String str ="AAA";						//字节输出流需要byte类型，所以要将String类对象变为字节数组
		byte data[] =str.getBytes();			//将字符串变为字节数组
		try {
			output.write(data);					//第三步：输出内容
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			output.close();					//第四步：资源关闭
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

以上按照了流的操作步骤进行。

2）字节输入流：InputStream

InputStream常用方法：

int read()	读取单个字节
int read(byte[] b)	将数据读取到字节数组中，同时返回读取长度
int read(byte[] b, int off, int len)	将数据读取到部分字节数组中，同时返回读取的数据长度（从off开始输出指定长度的字节）

区别：InputStream中的read()方法与OutputStream()中的write()方法对应，但前者是为了接收（输入）数据，后者是输出数据。

因为InputStream本身是一个抽象类，所以需要一个子类来进行文件操作——FileInputStream

数据读取操作1：（读取的数据量小于数组大小，并且是将数据一次性读取到字节数组中）

import java.io.*;

public class TestInputStream {
	public static void main(String[] args) throws Exception {
		File file = new File("D:" + File.separator + "demo"+
								File.separator + "test.txt");	//第一步：定义要输出的文件路径
		if(file.exists()){
				InputStream input = new FileInputStream(file); //第二步：向上转型			
			byte data [] = new byte [123];						//准备出一个123的数组
			int len = input.read(data);								//第三步：进行数据读取，将内容保存到字节数组中
			input.close();									//第四步：关闭输入流
			System.out.println("[" +  new String(data,0,len)  +"]");//变为字符串输出
		}
	}
}

数据读取2：（读取单个字节，用while循环，因为循环次数不确定）

```java
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;



public class TestInputStream2 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:" + File.separator + "demo"+
				File.separator + "test.txt");	//第一步：定义要输出的文件路径
		if(file.exists()){
			InputStream input = new FileInputStream(file); //第二步：向上转型	
			byte data [] = new byte [123];					//准备出一个123的数组
			int foot = 0;							//表示字节数组的操作角标
			int temp = 0;							//表示接收每次读取的字节数据
			while( (temp = input.read()) != -1){			//第三步：读取每一个字节
				 data[foot ++] =(byte) temp;				//保存读取的字节到数组之中
			}
			input.close();									//第四步：关闭输入流
			System.out.println("[" +  new String(data,0,foot)  +"]");//变为字符串输出
		}
	}
}

解释：temp=input.read() != -1 .先将read()方法读取的字节内容给temp变量，然后判断读取的temp内容是否是-1

3）字符输出流：Writer

Writer类常用方法：

void write(char[] cbuf)	输出字符数组数据
abstract void write(char[] cbuf, int off, int len)	输出字符数组的一部分
void write(String str)	输出字符串数据

与OutputStream类的定义类似，但是比起OutputStream还多实现了一个Appendable接口。（都是追加操作）

因为Writer本身也是一个抽象类，所以需要一个子类来进行文件操作——FileWriter

使用Writer类实现内容输出：

import java.io.*;

public class TestWriter {
	public static void main(String[] args) throws Exception{
		File file = new File("D:" + File.separator + "demo"+
				File.separator + "test2.txt");	//第一步：定义要输入文件的路径
		if(!file.getParentFile().exists()){
			file.getParentFile().mkdirs();		//如果目录不存在，则创建文件目录
		}
		Writer out = new FileWriter(file);		//第二步
		String str = "今天星期二，今晚不睡觉";			//定义输出内容
		out.write(str);							//第三步：输出字符串数据
		out.close();							//第四步：关闭输出流
	}
}

4）字符输入流：Reader

Reader类常用方法：

int read()	读取单个字符
int read(char[] cbuf)	读取数据到字符数组中，返回读取长度
abstract int read(char[] cbuf, int off, int len)	将数据读取到部分字符数组中，同时返回读取长度

Writer类中存在直接输出字符串的操作， 但Reader类中并没有直接返回字符串的操作。
这是因为输出数据时可以采用追加的模式，所以随着时间的推移，文件可能变得非常庞大，如果Reader类中提供了直接读取全部数据的方式，则有可能造成数据溢出。
（Writer输出的是程序允许的数据量，所以可以直接输出，而Reader因为追加的关系，不确定）

因为Reader本身也是一个抽象类，所以需要一个子类来进行文件操作——FileReader
使用Reader读取数据：

import java.io.*;

public class TestReader {
	public static void main(String[] args) throws Exception{
		File file = new File("D:"+ File.separator +"demo" + 
								File.separator +"test2.txt");	//第一步
		if(file.exists()){
			Reader input = new FileReader(file);				//第二步
			char data [] = new char [123];
			int len =input.read(data);										//第三步
			input.close();										//第四步
			System.out.println(new String(data,0,len));
		}
	}
}	

3.字节流与字符流的区别：

1. 字节：一种计量单位，表示数据量的多少。（Byte）
2. 字符：数字，字母，汉字和各种符号。(String(字符串)、char(字符)）

区别：字节流没有使用到缓冲区，而字符流使用了； 处理各种数据都可以通过字节流完成，而在处理中文的时候使用字符流会更好。

4.转换流：

通过InputStreamReader（字节输入流转换为字符输入流） 、 OutputStreamWriter（字节输出流转换为字符输出流）两个类来实现。
它们的继承关系如下：

java.lang.Object
	 	| -	java.io.Writer
			| -	java.io.OutputStreamWriter
				| - java.io.FileWriter

java.lang.Object
	 	| -	java.io.Reader
			| -	java.io.InputStreamReader
				| - java.io.FileReader

由上可以发现，所有要读取的文件数据都是字节数据，所有的字符都是在内存中处理后形成的。

OutputStreamWriter类的构造方法：

OutputStreamWriter(OutputStream out)

解释：OutputStreamWriter类的构造方法接收OutputStream类的对象，且OutputStreamWriter是Writer的子类，该类对象可以直接向上转型为Writer类对象，这样就可以将接收到的字节输出流转换为字符输出流。
同理，InputStreamReader也是一样。

实现输出流转换：

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class TestOutputStreamWriter {
	public static void main(String args[]) throws Exception{
		File file = new File("D:" + File.separator + "demo.txt" + "demo.txt");
		if(!file.getParentFile().exists()){
			file.getParentFile().mkdirs();		//创建父路径
		}
		OutputStream output = new FileOutputStream(file);  //字节流
		//将OutputStream类对象传递给OutputStreamWriter类的构造方法，向上转型为Writer
		Writer out = new OutputStreamWriter(output);
		out.write("今天星期五，上山打老虎");
		out.flush();
		out.close();
	}
}