输入、输出流

1.什么是输入、输出流

         在程序运行时，可能需要从外部的存储媒介或其他程序中读入所需要的数据，这就需要使用输入流。输入流的指向称为它的源，程序通过输入流读取源中的数据。另一方面，程序在处理数据后，可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序，这就需要使用输出流，输出流的指向称为它的目的地，程序通过输出流将数据传送到目的地。

2.什么是File类

程序可能经常需要获取磁盘上的有关信息或在磁盘上创建新的文件等，这就需要使用File类。File类对象主要用于获取文件本身的一些信息，例如目录、长度等不涉及对文件的读写，要对文件进行读写，就需要使用输入、输出流。

import java.io.File;
import java.io.IOException;

public class FileDemo {
	public static void main(String[] args) throws IOException {
		function6();

	}

	// 相对路径，绝对路径
	public static void function6() {
		File file = new File("java课件");
		System.out.println(file.getPath());
		System.out.println(file.getAbsolutePath());
		System.out.println(file.getName());
	}

	// 获取文件夹下的子文件
	public static void function5() {
		File file = new File("java课件");
		String[] list = file.list();
		for (String s : list) {
			System.out.println(s);
		}
	}

	public static void function4() {
		File file = new File("新建文本文档.txt");
		System.out.println(file.delete());
	}

	public static void function3() {
		// 创建文件对象
		File file = new File("abcd/abcd/abcd");
		if (!file.exists()) {
			// 创建文件夹
			System.out.println(file.mkdirs());
		}
	}

	public static void function2() throws IOException {
		// 创建文件对象
		File file = new File("abcd.txt");
		if (!file.exists()) {
			// 创建文件
			System.out.println(file.createNewFile());
		}
	}

	// 判断是文件夹或者是文件
	public static void function1() {
		// 创建文件对象
		File file = new File("新建文本文档.txt");
		// 判断是否是文件夹
		System.out.println(file.isDirectory());
		// 判断它是不是文件
		System.out.println(file.isFile());
	}

	private static void function() {
		// 创建文件对象
		File file = new File("新建文本文档.txt");
		// 判断文件存不存在
		System.out.println(file.exists());
	}
}

3.文件字节输入、输出流（FileInputStream、FileOutputStream）

文件字节输入、输出流是输入、输出流的一个分类，主要用于简单的读取、输入操作,字节流是以字节为单位读取文件，该类的实例方法都是从InputStream、OutputStream类继承来的。

构造器：

FileInputStream(String name)和FileInputStream(File file)

FileOutputStream(String name)和FileOutputStream(File file)

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

public class Example {
	public static void main(String[] args) {
		function1();
		function2();
	}
	public static void function1() {
		File file = new File("./aa.txt");
		// 创建文件输出流
		FileOutputStream fileOutputStream=null;
		try {
			fileOutputStream = new FileOutputStream(file, true);
			byte[] b = { 97, 98, 99 };
			fileOutputStream.write(b, 0, 2);//写入b对象从索引0-2
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				//关闭流
				if (fileOutputStream != null) {
					fileOutputStream.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
			
	}
	public static void function2() {
		// 创建文件输入流
		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./aa.txt");
			byte[] b = new byte[1024];
			int len = 0;
			while ((len = fileInputStream.read(b)) != -1) {
				String string = new String(b, 0, len);
				System.out.println(string);
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				if (fileInputStream != null) {
					fileInputStream.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

4.文件字符输入、输出流（FileReader、FileWrite）

文件字节输入、输出流的read和write方法使用字节数组读写数据，是以字节为单位处理数据。但对汉字（2字节）进行读取操作时，可能出现"乱码”的情况。这就需要与字节输入、输出流的文件字符输入、输出流来对文件进行操作。FileReader、FileWrite分别是Reader和Writer的子类，与之对应的read和write方法使用字符数组读写数据，即以字符为基本单位处理数据。

构造器：

FileReader(String filename);FileReader(File filename);

FileWriter(String filename);FileWriter(File filename);

FileWriter(String filename,boolean append);FileWriter(File filename,boolean append);

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 将文件a.txt的内容尾家到b.txt
 */
public class Example {
	public static void main(String[] args) {
		File filea = new File("a.txt");//读取文件
		File fileb = new File("b.txt");//写入对象
		char c[] = new char[19];//数组

		try {
			FileWriter out = new FileWriter(fileb,true);//输出流
			FileReader in = new FileReader(filea);//输入流
			int n =-1;
			while((n=in.read(c))!=-1){
				out.write(c,0,n);
			}
			out.flush();
			out.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

5.缓冲流（BufferedReader、BufferedWriter）

当我们用文件字符输入、输出流读取、写入文件是只能单个字符的操作，比较麻烦费时，而用BufferedReader 和BufferWriter类创建的对象称为缓冲输入、输出流，两者增强了读写文件的能力，能够读一行数据进行操作。当用该流创建对象的时候，会相应的创建一个缓存区，用来缓存字符流数据，缓冲流会从缓冲区读取文件数据。

构造器：

BufferedReader(Reader in);

BufferedWriter(Writer out);

import java.io.*;

/**
 * 将文件a.txt的内容复制到b.txt
 */
public class Example {
	public static void main(String[] args) {
		File filea = new File("a.txt");//读取多行文件
		File fileb = new File("b.txt");//写入文件
		try {
			FileWriter out = new FileWriter(fileb,true);//输出流
			BufferedWriter bufferedWriter = new BufferedWriter(out);//缓冲输出流
			FileReader in = new FileReader(filea);//输入流
			BufferedReader bufferedReader = new BufferedReader(in); //缓冲输入流
			String str=null;
			//读取每一行写入
			while((str=bufferedReader.readLine())!=null){
				bufferedWriter.write(str);
				bufferedWriter.newLine();
			}
			bufferedWriter.close();
			out.close();
			bufferedReader.close();
			in.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

6.数据流（DataInputStream、DataOutputStream）

DataInputStream、DataOutputStream类创建的对象称为数据输入、输出流。该类对象能够读取、写入各种基本数据类型。

构造器：

DataInputStream(InputStream in)

DataOutputStream(OutputStream out)

import java.io.*;

public class DataStreamDemo {

	public static void main(String[] args) throws Exception {
		function1();
	}
	public static void function1() throws Exception {
		int a = 100000;
		DataOutputStream dataOutputStream = new DataOutputStream(
				new FileOutputStream("test.txt"));
		dataOutputStream.writeInt(a);//写入整形
		dataOutputStream.writeBoolean(true);//写入布尔型
		dataOutputStream.close();
		DataInputStream dataInputStream = new DataInputStream(
				new FileInputStream("test.txt"));
		System.out.println(dataInputStream.readInt());//读取整形
		System.out.println(dataInputStream.readBoolean());//读取布尔型
	}

}

7.对象流（ObjectInputStream、ObjectOutputStream）

用ObjectInputStream、ObjectOutputStream类创建的对象称为对象输入、输出流。是InputStream和OutputStream类的子类。分别通过readObject()和writeObject()方法读取和写入对象。

构造方法：

ObjectInputStream(InputStream in )

ObjectOutputStream(OutputStream out)

import java.io.*;

public class ObjectStreamDemo {
	public static void main(String[] args) throws Exception, IOException {
		Student student = new Student();
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(
				new FileOutputStream("test.txt"));
		objectOutputStream.writeObject(student);
		ObjectInputStream objectInputStream = new ObjectInputStream(
				new FileInputStream("test.txt"));

		Student s = (Student) objectInputStream.readObject();
		System.out.println(s.name);
		
	}
}

import java.io.Serializable;

public class Student implements Serializable {
	public String name = "张三";
}