JAVA基础_io流

1.文件（File）流

• 文件流的数据读写都是基于文件的操作

//导包
import java.io.File;

//创建目录
File f = new File("D:\\test");
f.mkdir();//创建单层目录

File f = new File("D:\\test\\aa\\bb");
f.mkdirs();//创建多层目录

//新建文件几种方式
/*
 * createNewFile() 方法，根据抽象路径创建一个新的空文件，当抽象路径下的文件存在时，创建失败
 * 如果E:/test 目录下没有 1.txt文件，则创建该文件；如果1.txt已经存在，那么文件创建失败
 * 如果没有test目录，则直接抛出异常；
*/

File f = new File("D:\\test\\aa\\tt.txt");//方式1
f.createNewFile();

File f1 = new File("D:/test/aa/tt.txt");//方式2
f1.createNewFile();

File f2 = new File("D:" + File.separator + "test\\aa\\tt.txt");//方式3
f2.createNewFile();

File f3 = new File("D:\\test","aa\\tt.txt");//方式4
f3.createNewFile();
	

文件输入流读取案例：

import java.io.FileInputStream;
/**
* 文件字节输入流FileInputStream
* 
*  在读取文件时，必须保证该文件已存在，否则出异常
*/

public class fileStream {
	public static void main(String[] args) {
		try {
			int len = 0;
			FileInputStream inputStream = new FileInputStream("F:/test/tt.txt");
			byte[] by = new byte[1000]; //设置一个byte数组接收读取的文件的内容
			len =inputStream.read(by); //读取文件字节长度
			if (len != 0) {
                //new String(b,0,len),参数1是缓冲数据的数组，参数2是从数组的那个位置开始转化字符串，参数3是总共转化几个字节
				System.out.println(new String(by,0,len));
			}
			by.clone();//流在使用完毕之后要关闭
			
		} catch (Exception e) {
			e.printStackTrace();
		}
				

	}

}

文件输出流案例：

//实现复制一个文件到指定文件夹下

public class fileStream {
	public static void main(String[] args) {	
		try {
			fileStream.testFileOutputStream("F:/test/test01.txt","F:/test/tt.txt");
            fileStream.testFileOutputStream("F:/test/test01.png","F:/test/tt.png");
		} catch (IOException e1) {
			e1.printStackTrace();
		}
    }

	/**
	 * 文件字节输出流FileOutputStream
	 * @throws IOException 
	 */
	public static void testFileOutputStream(String intPath, String outPath) throws IOException {
		try {
			
			FileOutputStream outputStream = new FileOutputStream(intPath);
			
			//从文件中读取
			FileInputStream inputStream = new FileInputStream(outPath);
			byte[] byte1= new byte[1000];
			int len = inputStream.read(byte1);

			outputStream.write(byte1,0,len); //把数据写入内存
			outputStream.flush();//把内存中的数据刷写到硬盘
			outputStream.close();
            inputStream.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

• 注意：文件字节流非常通用，可以用来操作字符的文档，还可以操作任何的其他类型文件（图片，压缩包等等），因为字节流直接使用二进制

• 文件字符流与文件字节流区别在于创建的临时存放数组，一个是字节数组，一个是字符数组

• 文件字符流创建文件使用的是FileReader和FileWriter,而文件字节流创建使用的是FileInputStream和FileOutputStream

2.缓冲（Buffer）流

• 缓冲流的数据读写都是基于内存的操作
• 缓冲字节流使用的是BufferedInputStream和BufferedOutputStream
• 缓冲字符流使用的是BufferedReader和BufferedWriter
• 缓冲流是先把数据缓冲到内存，然后再内存中做io操作

缓冲流读取输出案例：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test {
	public static void main(String[] args) throws Exception {
		Test.testBufferedInputStream();
		Test.testBufferedOutputStream();
	}
	
	/**
	 * 缓冲字节输入流 BufferedInputStream
	 * @throws Exception 
	 */
	public static void testBufferedInputStream() throws Exception {
		FileInputStream inputStream =new FileInputStream("F:/test/tt.txt");//先从磁盘读取文件到字节流中
		BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
		byte[] b = new byte[1024];
		int len = 0;
		while ((len = bufferedInputStream.read(b)) != -1) {
			System.out.println(new String(b,0,len));
		}
		bufferedInputStream.close();
		inputStream.close();
	}
	
	/**
	 * 缓冲字节输出流 BufferedOutputStream
	 * @throws Exception 
	 */
	public static void testBufferedOutputStream() throws Exception {
		FileOutputStream fileOutputStream = new FileOutputStream("F:/test/tt02.txt");
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
		
		String str = "aaaaabbbbbcccc";
		bufferedOutputStream.write(str.getBytes());
		bufferedOutputStream.close();
		fileOutputStream.close();
	}
}

3.转换流

• 转换输入流InputStreamReader和转换输出流OutputStreamWiter

4.对象（Object）流

• 把一个对象转化为一个数据进行读写
• ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
• 对象流存在原因：因为需要保存对象到硬盘(对象的持久化)和对象的网络传输
• 序列化(Serialize)是将对象转换为二进制流，反序列化(Deserialize)是将二进制流转换为对象

对象序列化案例:

• 先创建可被序列化的对象Person类，被序列化的对象有一个标实版本的静态变量 serialVersionUID

import java.io.Serializable;

/**
 * 创建一个可以序列化与反序列化的对象
 */
public class Person implements Serializable{

	/**
	 * 一个表示序列化版本标识符的静态变量
	 * 用来表明类的不同版本间的兼容性
	 */
	private static final long serialVersionUID = 1L;
	
	public String name;
	public int age;

}

• 再进行对Person类的序列化与反序列化

首先是序列化，如下：

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class serializeTest {

	/**
	 * 序列化与反序列化
	 * 注意：对象的序列化与反序列化使用的类要严格一致，包名，类名，类机构等等所有都要一致
	 */
	public static void main(String[] args) {
		try {
			serializeTest.testSerialize();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	//对象的序列化
	public static void testSerialize() throws Exception{
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("F:/test/test02.txt"));
		Person person = new Person();
		person.name = "WhiteCat";
		person.age = 2;
		
		objectOutputStream.writeObject(person);
		objectOutputStream.flush();
		objectOutputStream.close();
		
	}

}

然后是反序列化，如下

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class serializeTest {

	/**
	 * 序列化与反序列化
	 * 注意：对象的序列化与反序列化使用的类要严格一致，包名，类名，类机构等等所有都要一致
	 */
	public static void main(String[] args) {
		try {
			//serializeTest.testSerialize();
			serializeTest.testDeserialize();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	//对象的序列化
	public static void testSerialize() throws Exception{
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("F:/test/test02.txt"));
		Person person = new Person();
		person.name = "WhiteCat";
		person.age = 2;
		
		objectOutputStream.writeObject(person);
		objectOutputStream.flush();
		objectOutputStream.close();
		
	}
	//对象的反序列化
	public static void testDeserialize() throws Exception{
		ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("F:/test/test02.txt"));
		Person person =(Person)(objectInputStream.readObject());
		System.out.println(person.age);
		System.out.println(person.name);
		
		
		
	}

}