Java基础之IO流（三）

/**
 * 字符转字节，并指定编码
 */
public static void test1() throws IOException {
    // 创建与文件关联的字节输出流对象
    FileOutputStream fos = new FileOutputStream("e:\\e.txt");
    // 创建可以把字符转成字节的转换流对象，并指定编码
    OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
    // 调用转换流，把文字写进去，其实是写到转换流的缓冲区中
    // 写入缓冲区
    osw.write("OutputStreamWriter 是字符流通向字节流的桥梁");
    // 关闭资源
    osw.close();
}

/**
 * 字节转字符，并指定编码
 */
public static void test2() throws IOException {
    // 创建读取文件的字节流对象
    InputStream in = new FileInputStream("e:\\e.txt");
    // 创建转换流对象
    //InputStreamReader isr = new InputStreamReader(in);这样创建对象，会用本地默认码表读取，将会发生错误解码的错误
    InputStreamReader isr = new InputStreamReader(in, "utf-8");
    // 使用转换流去读字节流中的字节
    int ch = 0;
    while ((ch = isr.read()) != -1) {
        System.out.println((char)ch);
    }
    // 关闭资源
    isr.close();
}

public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流

/**
 * 写数据到文件的方法（缓冲流）
 */
public static void test3() throws IOException {
    // 创建基本的字节输出流
    FileOutputStream fileOut = new FileOutputStream("e:\\abc.txt");
    // 使用高效的缓冲流，把基本的流进行封装，实现速度的提升
    BufferedOutputStream out = new BufferedOutputStream(fileOut);
    // 写数据
    out.write("字节缓冲输出流 BufferedOutputStream".getBytes());
    // 关闭流
    out.close();
}

public BufferedInputStream(InputStream in)

/**
 * 从文件中读取数据（缓冲流）
 */
public static void test4() throws IOException {
    // 1. 创建缓冲流对象
    FileInputStream fileIn = new FileInputStream("e:\\abc.txt");
    // 使用高效的缓冲流，把基本的流进行封装，实现速度的提升
    BufferedInputStream in = new BufferedInputStream(fileIn);
    // 2. 读数据
    int ch = -1;
    while ((ch = in.read()) != -1) {
        System.out.println((char)ch);
    }
    // 3. 关闭资源
    in.close();
}

/*
 * 需求：将d:\\test.avi文件进行复制
 * 		采用4种方式复制
 * 	
 * 
 * 数据源： d:\\test.avi
 * 目的地1: d:\\copy1.avi
 * 目的地2: d:\\copy2.avi
 * 目的地3: d:\\copy3.avi
 * 目的地4: d:\\copy4.avi
 * 
 * 实现的步骤：
 * 	1，指定数据源
 * 	2，指定目的地
 * 	3，读数据
 * 	4，写数据
 * 	5，关闭流
 * 
 */
public class CopyAVI {
	public static void main(String[] args) throws IOException {
		//开始计时
		long start = System.currentTimeMillis();
		//方式1： 采用基本的流，一次一个字节的方式复制
		//method1("d:\\test.avi", "d:\\copy1.avi");
		//方式2： 采用基本的流，一个多个字节的方式赋值
		//method2("d:\\test.avi", "d:\\copy2.avi");
		//方式3： 采用高效的流，一次一个字节的方式复制
		//method3("d:\\test.avi", "d:\\copy3.avi");
		//方式4： 采用高效的流，一个多个字节的方式赋值
		method4("d:\\test.avi", "d:\\copy4.avi");
		
		//结束计时
		long end = System.currentTimeMillis();
		//打印耗时多少毫秒
		System.out.println("共耗时 " +(end - start)+ "毫秒");
	}
	
	//方式4： 采用高效的流，一个多个字节的方式赋值
	private static void method4(String src, String dest) throws IOException {
		//1，指定数据源
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));
		 //2，指定目的地
		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));
		 //3，读数据
		byte[] buffer = new byte[1024];
		int len = -1;
		while ( (len = in.read(buffer)) != -1) {
			//4,写数据
			out.write(buffer, 0, len);
		}
		 //5，关闭流
		in.close();
		out.close();
	}

	//方式3： 采用高效的流，一次一个字节的方式复制
	private static void method3(String src, String dest) throws IOException {
		//1，指定数据源
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));
		 //2，指定目的地
		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));
		 //3，读数据
		int ch = -1;
		while ((ch=in.read()) != -1) {
			//4，写数据
			out.write(ch);	
		}		
		 //5，关闭流
		in.close();
		out.close();
	}

	//方式2： 采用基本的流，一个多个字节的方式赋值
	private static void method2(String src, String dest) throws IOException {
		//1，指定数据源
		FileInputStream in = new FileInputStream(src);
		//2，指定目的地
		FileOutputStream out = new FileOutputStream(dest);
		//3，读数据
		byte[] buffer = new byte[1024];
		int len = -1;
		while ( (len=in.read(buffer)) != -1) {
			//4，写数据
			out.write(buffer, 0, len);
		}
		//5，关闭流
		in.close();
		out.close();
	}

	//方式1： 采用基本的流，一次一个字节的方式复制
	private static void method1(String src, String dest) throws IOException {
		//1，指定数据源
		FileInputStream in = new FileInputStream(src);
		//2，指定目的地
		FileOutputStream out = new FileOutputStream(dest);
		//3，读数据
		int ch = -1;
		while (( ch=in.read()) != -1) {
			//4，写数据
			out.write(ch);
		}
		//5，关闭流
		in.close();
		out.close();
	}
}

/**
 * BufferedWriter 字符缓冲输出流
 * 方法
 * 	public void newLine()写入一个行分隔符
 *
 * 需求： 通过缓冲输出流写入数据到文件
 * 分析：
 * 	1，创建流对象
 * 	2，写数据
 * 	3，关闭流
 *
 */
public static void test5() throws IOException {
    // 基本字符输出流
    FileWriter fileOut = new FileWriter("file.txt");
    // 把基本的流进行包装
    BufferedWriter out = new BufferedWriter(fileOut);
    // 写数据
    for (int i = 0; i < 5; i++) {
        out.write("hello");
        out.newLine();
    }
    // 关闭资源
    out.close();
}

/**
 * BufferedReader 字符缓冲输入流
 *
 * 方法：
 * 	String readLine()
 *  需求：从文件中读取数据，并显示数据
 */
public static void test6() throws IOException {
    // 创建流
    BufferedReader in = new BufferedReader(new FileReader("file.txt"));
    // 读数据
    //一次读取文本中一行的字符串内容
    String line = null;
    while ((line = in.readLine()) != null) {
        System.out.println(line);
    }
    // 关闭资源
    in.close();
}

/**
 * 采用高效的字符缓冲流，完成文本文件的赋值
 *
 * 数据源： file.txt
 * 目的地： copyFile.txt
 *
 * 分析：
 * 	1，指定数据源， 是数据源中读数据，采用输入流
 * 	2,指定目的地，是把数据写入目的地，采用输出流
 * 	3,读数据
 * 	4，写数据
 * 	5，关闭流
 */
public static void test7() throws IOException {
    // 1. 指定数据源，读取数据采用输入流
    BufferedReader in = new BufferedReader(new FileReader("file.txt"));

    // 2. 指定目的地，写入数据采用输出流
    BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt"));

    // 3. 开始读取数据
    String line = null;
    while ((line = in.readLine()) != null) {
        // 4. 写数据
        out.write(line);
        // 写入换行符号
        out.newLine();
    }