java基础21——字节流

1:字符流(掌握)

Reader
		|--InputStreamReader
			|--FileReader
		|--BufferedReader
	Writer
		|--OutputStreamWriter
			|--FileWriter
		|--BufferedWriter

针对文本文件这样的数据操作。
基本的读取和基本的写入，单独使用也是要求掌握的。

掌握：(5种方式)

把c:\\a.txt复制到d:\\b.txt中。
		字符流
			一次一个字符
			FileReader fr=new FileReader("c:\\a.txt");
			FileWriter fw=new FileWriter("d:\\b.txt");
			in ch=0;
			while((ch=fr.read())!=-1){
				fw.write();
			}
			fr.close();
			fw.close();
			一此一个字符数组
			FileReader fr=new FileReader("c:\\a.txt");
			FileWriter fw=new FileWriter("d:\\b.txt");
			char[] chs=new char[1024];
			in len=0;
			while((len=fr.read(chs))!=-1){
				fw.write(chs,0,len);
			}
			fr.close();
			fw.close();
		
		缓冲区流对象（一次一个字节、一次一个数组、、省略）
			BufferedReader br=new BufferedReader(new FileReader("c:\\a.txt"));
			BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\b.txt"));
			String line=null;
			while((line=br.readLine())!=null){
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
			br.close();
			bw.close();

2:字节流(掌握)

InputStream
		|--FileInputStream
		|--BufferedInputStream
	OutputStream
		|--FileOutputStream
		|--BufferedOutputSteam

掌握：(4种方式)

把c:\\a.jpg复制到d:\\b.jpg中。
		字节流
			一次一个字节
			FileInputStream fis=new FileInputStream("c:\\a.jpg");
			FileOutputStream fos=new FileOutputStream("d:\\b.jpg");
			in by=0;
			while((by=fis.read())!=-1){
				fos.write();
			}
			fis.close();
			fos.close();
			一次一个字节数组
			FileInputStream fis=new FileInputStream("c:\\a.jpg");
			FileOutputStream fos=new FileOutputStream("d:\\b.jpg");
			byte[] bys=new byte[1024];
			in len=0;
			while((len=fis.read(bys))!=-1){
				fos.write(bys,0.len);
			}
			fis.close();
			fos.close();
		缓冲区流对象(一次一个字节省略)
			BufferedInputStream bis=new BufferedInputStream(new FileInputStream("c:\\a.jpg"));
			BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("d:\\b.jpg"));
			byte[] bys=new byte[1024];
			in len=0;
			while((len=bis.read(bys))!=-1){
				bos.write(bys,0.len);
			}
			bis.close();
			bos.close();

3:转换流(理解)
InputStreamReader isr = new InputStreamReader(System.in);
InputStreamReader isr = new InputStreamReader(new FileInputStream(...));


OutputStreamWriter osw = new OutputStreamWriter(System.out);
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(...));


4:字符编码(理解)
(1)编码表
字符及其对应的数值组成的一张表。
(2)常见的码表：
ASCII,ISO-8859-1,GB2312,GBK,GB18030,BIG5,UTF-8
(3)编码应用：
A:IO流中(转换流)
B:字符串


最好编码一致。


5:练习题目(掌握)

A:单级目录的复制
	public static void copy(File srcFile) throws IOException{
		File[] arrayFile=srcFile.listFile();
		File toFile=new File("d:\\copy");
		toFile.mkdir();
		BufferedInputStream bis=null;
		BufferedOutputStream bos=null;
		byte[] bys=new byte[1024];
		int len=0;
		for(File file:arrayFile){
			bis=new BufferedInputStream(new FileInputStream(file));
			bos=new BufferedOutputStream(new FileOutputStream(toFile,file.getName()));
			while((len=bis.read(bys))!=-1){
				bos.write(bys,0,len);
				bos.flush();
			}
		}
		bis.close();
		bos.close();
	}

package cn.itcast_07;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;

/*
 * System.in 标准的输入流。
 * 		public static final InputStream in
 * 
 * 需求：通过标准的输入流实现键盘录入数据写入文本文件。
 * 
 * 数据源：
 * 		键盘录入 -- 标准输入流 -- System.in -- InputStream
 * 目的地：
 * 		目的地 -- 文本文件 -- FileWriter -- BufferedWriter
 * 
 * 注意：如果数据是键盘录入的，请自己给出结束标记。
 */
public class SystemInDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		InputStream is = System.in; // 右边是子类对象
		// System.out.println(is); // java.io.BufferedInputStream@60e128

		// 封装目的地
		BufferedWriter bw = new BufferedWriter(new FileWriter("is.txt"));

		// 读写
		// 我们现在需要通过is对象读取数据。
		// 由于他是标准的输入流对象，所以，他的读取方式有两种：
		// 一次读取一个字节，一次读取一个字节数组。
		// 那么，我们现在选择哪种方案呢?
		// 而一行到底有多少数据是不明确的，所以，我们选择了一次读取一个字节。
		// 这个时候，又有了一个新的问题，我要的是一行数据，而你只能读取一个字节。
		// 怎么办?通过循环读取即可。
		// 如果通过循环读取，那么，每一次读取到下一个字节的时候，前面的字节数据又丢失了。
		// 为了不让数据丢失，我们要把曾经读取过的数据给临时存储起来。
		// 通过简单的分析，我们最终选择StringBuilder这个容器。
		// 这样的话，我们就只剩下了一个难点，就是什么时候结束呢?
		// 我们又知道遇到"\r\n"才结束。所以我们就可以判断了。
		StringBuilder sb = new StringBuilder();
		int by = 0;
		while (true) {
			by = is.read();

			if (by == '\r') {
				continue;
			}

			if (by == '\n') {
				String s = sb.toString();
				
				sb.delete(0, sb.length()); // 清空数据
				
				if ("over".equals(s)) {
					break;
				}
//				System.out.println(s);
				
				bw.write(s);
				bw.newLine();
				bw.flush();
				
			} else {
				sb.append((char) by);
			}
		}

		// 释放
		bw.close();
		is.close();

	}
}

package cn.itcast_07;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * 如果按照刚才的标准输入流做法，我们也可以实现数据的录入。
 * 但是，这样还要自己写判断，太麻烦。
 * 我们就想能不能有一种方式能够一次读取一行数据呢?
 * 有了。readLine()方法。
 * 而这个方法确实BufferedReader类才有的。
 */
public class SystemInDemo2 {
	public static void main(String[] args) throws IOException {
		// 封装键盘录入
		// InputStream is = System.in;
		// // 注意：这个时候，我们发现一个问题。
		// // 问题是字符缓冲区流对象只能对字符流进行高效的包装
		// // 也就是说，他的功能是针对字符流有效。
		// // 而你现在拥有的是字节流。
		// // 偏偏又想使用这个方法，请问你们说怎么办?
		// // 如果有一个东西可以实现把字节流转换成字符流就好了。
		// // 针对这种情况，java就提供了转换流
		// // InputStreamReader 是字节流通向字符流的桥梁
		// // InputStreamReader(InputStream in)
		// InputStreamReader isr = new InputStreamReader(is);
		// BufferedReader br = new BufferedReader(isr);

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new FileWriter("is2.txt"));

		String line = null;
		while ((line = br.readLine()) != null) {
			if ("886".equals(line)) {
				break;
			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();
	}
}

package cn.itcast_07;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;

/*
 * 需求：我要把一个文本文件的数据显示在控制台。
 * 		public static final PrintStream out:标准输出流
 * 		通过上面这句话，我可以写出这样的代码：
 * 			OutputStream
 * 				|--FilterOutputStream
 * 					|--PrintStream
 * 			OutputStream os = System.out;
 */
public class SystemOutDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		// BufferedReader br = new BufferedReader(new FileReader("is2.txt"));
		// OutputStream os = System.out;
		//
		// String line = null;
		// while ((line = br.readLine()) != null) {
		// os.write(line.getBytes());
		// os.write("\r\n".getBytes());
		// }
		//
		// os.close();
		// br.close();

		// 上面的代码中，"\r\n".getBytes()将来可能有问题。所以，我们需要改进
		// 用一个newLine()方法搞定。
		// 而这个方法是BufferedWriter。
		// 你现在有的输出流是OutputStream
		// 这是一个字节流,最终要用字符高效流
		// 就必须转换。
		// OutputStreamWriter 是字节流通向字符流的桥梁(使用上) 是字符流通向字节流的桥梁(理解上)
		BufferedReader br = new BufferedReader(new FileReader("is2.txt"));
		// OutputStream os = System.out;
		// OutputStreamWriter osw = new OutputStreamWriter(os);
		// BufferedWriter bw = new BufferedWriter(osw);
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				System.out));

		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();
	}
}

B:集合和IO的数据转换(字符流)

package cn.itcast.test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/*
 * 把集合中的字符串数据用IO流写到文本文件。
 * 
 * 数据源：
 * 		集合 -- 存储数据并遍历
 * 目的地：
 * 		文本文件 -- BufferedWriter
 */
public class ArrayListToFile {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		// 创建集合对象
		ArrayList<String> array = new ArrayList<String>();
		// 添加元素
		array.add("hello");
		array.add("world");
		array.add("java");

		// 封装目的地
		BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));

		// 遍历集合
		for (String str : array) {
			bw.write(str);
			bw.newLine();
			bw.flush();

		}
		
		bw.close();
	}
}

package cn.itcast.test;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

/*
 * 把文本文件中的数据通过IO流写到集合中。
 * 
 * 数据源：
 * 		文本文件 -- BufferedReader
 * 目的地：
 * 		集合 -- String
 */
public class FileToArrayList {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		BufferedReader br = new BufferedReader(new FileReader(
				"FileOutputStreamDemo.java"));
		// 封装目的地
		ArrayList<String> array = new ArrayList<String>();

		String line = null;
		while ((line = br.readLine()) != null) {
			array.add(line);
		}

		br.close();

		// 遍历集合
		for (String str : array) {
			System.out.println(str);
		}
	}
}

package cn.itcast.test;

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

/*
 * 复制单级文件夹。
 * 需求：把d:\\datasource这个文件夹的内容复制到当前项目路径下的copy这个文件夹中。
 * 
 * 分析：
 * 		A:封装数据源目录
 * 		B:获取数据源目录下的所有File数组
 * 		C:遍历File数组，获取得到每一个File
 * 		D:复制File
 * 			新的File的路径问题。
 * 			a:创建一个新的文件夹
 * 			b:获取以前的文件名称，和新的文件夹组合成新的路径。
 */
public class CopyDirectory {
	public static void main(String[] args) throws IOException {
		// 封装数据源目录
		File srcFile = new File("d:\\datasource");

		// 给一个判断
		if (!srcFile.exists()) {
			throw new RuntimeException("数据源文件夹不存在");
		}

		// 获取数据源目录下的所有File数组
		File[] fileArray = srcFile.listFiles();

		// 造一个新的文件夹
		File destFile = new File("copy");
		destFile.mkdir();

		// 遍历File数组，获取得到每一个File
		for (File file : fileArray) {
			// file -- d:\\datasource\\cxy.bmp
			// 目的地：-- copy\\cxy.bmp
			String name = file.getName(); // cxy.bmp
			File newFile = new File(destFile, name); // copy\\cxy.bmp
			copy(file, newFile);
		}
	}

	public static void copy(File file, File newFile) throws IOException {
		// 封装数据源
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				file));
		// 封装目的地
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(newFile));

		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}

		bos.close();
		bis.close();
	}
}

package cn.itcast.test;

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

/*
 * 编写一个程序，将d:\java目录下的所有.java文件复制到d:\jad目录下，
 * 并将原来文件的扩展名从.java改为.jad。
 * 
 * 分析：
 * 		A:封装数据源目录
 * 		B:获取数据源目录下的所有File数组(加过滤器)
 * 		C:遍历File数组，获取得到每一个File
 * 		D:复制File
 * 			改名：
 * 				a:先改再复制
 * 				b:先复制再改(思考留作作业)
 */
public class CopyDirectory2 {
	public static void main(String[] args) throws IOException {
		// 封装数据源目录
		File srcFile = new File("d:\\java");

		// 获取数据源目录下的所有File数组(加过滤器)
		File[] fileArray = srcFile.listFiles(new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				return new File(dir, name).isFile() && name.endsWith(".java");
			}
		});

		// 造新目录
		File destFile = new File("d:\\jad");
		if (!destFile.exists()) {
			destFile.mkdir();
		}

		// 遍历File数组，获取得到每一个File
		for (File file : fileArray) {
			// file -- d:\\java\\ConstDemo.java
			// 目的地：-- d:\\jad\\ConstDemo.jad
			String oldName = file.getName(); // ConstDemo.java
			String newName = oldName.replace(".java", ".jad"); // ConstDemo.jad
			File newFile = new File(destFile, newName);
			CopyDirectory.copy(file, newFile);
		}
	}
}

package cn.itcast.test;

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

/*
 * 复制多级目录：把d盘目录下的source目录(还有目录和文件)内容拷贝到e盘目录下。
 * 分析：
 *		A：封装目录为File对象
 *      B：判断File对象是目录还是文件
 * 			如果是目录，在目的地创建同名目录。
 *			如果是文件，就复制。
 */
public class IOTest {
	public static void main(String[] args) throws IOException {
		File source = new File("d:\\source");
		File target = new File("e:\\");
		copyDir(source, target);
	}

	// 拷贝目录
	private static void copyDir(File source, File target) throws IOException {
		// 判断source
		if (source.isDirectory()) {
			// 是目录
			// 在target下创建同名目录
			File dir = new File(target, source.getName());
			dir.mkdirs();
			// 遍历source下所有的子文件，将每个子文件作为source，将新创建的目录作为target进行递归。
			File[] files = source.listFiles();
			for (File file : files) {
				copyDir(file, dir);
			}
		} else {
			// 是文件
			// 在target目录下创建同名文件，然后用流实现文件拷贝。
			File file = new File(target, source.getName());
			file.createNewFile();
			copyFile(source, file);
		}
	}

	// 拷贝文件
	private static void copyFile(File source, File file) throws IOException {
		// 创建流对象
		InputStream is = null;
		OutputStream os = null;
		try {
			is = new FileInputStream(source);
			os = new FileOutputStream(file);

			// 基本读写操作
			byte[] bys = new byte[1024];
			int len = 0;
			while ((len = is.read(bys)) != -1) {
				os.write(bys, 0, len);
			}
		} finally {
			if (os != null) {
				os.close();
			}
			if (is != null) {
				is.close();
			}
		}
	}

}