---恢复内容开始---
Java对数据的操作都是通过流的方式，数据的输入和输出是相对内存来说的，将外设的数据读到内存：输入流；将内存的数据写到外设：输出流。
流按操作数据分为两种：字节流，字符流。
输入输出的数据全都是以字节为单位的二进制，字符流后期才出现，字符流出现的目的是让机器识别日常生活文字，编码表(美国ascii，中国GBK)记录了文字和数字的对应关系，从而字节流+编码表=字节流，从硬盘读取字节流之后，先查表，转换成对应的文字，从而形成字符流。(注：国际统一的为unicode（java内置），无论什么字符都用2个字节表示)
字节流的抽象基类(顶层父类)：inputStream，outputStream.(数据载体)
字符流的抽象基类 ：Reader,Writer.
这些子类的后缀都是父类名，前缀是子类实现的功能。
java.lang.Object java.lang.Object
|--java.io.writer (写入字符流的抽象类) |--java.io.writer
|--java.io.OutputStreamWriter(字符流通向字节流的桥梁，转换流) |--BufferedWriter
|--java.io.FileWriter
1.FileWriter：将字符写入到文本文件(和文本编辑器，word等工具一个原理)
public static void main(String[] args) throws IOException{
FileWriter fw = new FileWriter("demo.txt",true); // 如果demo存在，则会覆盖，如果不存在，创建。如果加入 true，那么不会覆盖，会续写。
fw.write("abc"); //abc写入到了临时存储缓冲区中。
fw.flush(); //将数据直接写入到demo。
fw.close(); //关闭流，释放资源。close中调用了flush，flush可省略。
}
IO异常的处理：
public static void main(String[] args){
FileWriter fw = null; //流对象的创建方式，因为一般都会发生异常。
try{
fw = new FileWriter("demo.txt",true);
fw.write("abc");
}
catch (IOException e){
System.out.println(e.toString());
}
finally{
if(fw != null) //如果要创建的路径不存在，比如F盘没有，那么fw这个流就不能创建，如果这里不判断，就会抛出异常。
try{
fw.close();
} catch (IOException e) {throw new RuntimeException("关闭失败")；}
}
}
2.FileReader：读取文本文件中的字符
FileReader fr = new FileReader("demo.txt");
int a = 0;
while((a=fr.read())!=-1)
{
sop(char(a)); //每次读取一个字符，但是以二进制的数字格式输出(0-65535 0x00-0xffff)。如果读取完了，会返回-1
}
/*
也可以以数组的形式来读
char[] buf = new char[3];
int num = fr.read(buf); //num是读取的字符个数
sop(num+":"+new String(buf,0,num)); //这里string里用num可以保证读几个打印几个。
如果存的是abcde五个字符，那么第一次逐个读取abc到内存里的长度为3的数组，然后输出num=3和abc，下次读取时de放到了内存数组的前两位，覆盖了ab所在位置， 第三位读不到但是内存中还是c，所以第二次读取num=2和dec，第三次返回num=0和dec。
while((num=fr.read(buf))!=-1){
sop(new String(buf,0,num)); //buf越大，效率越高
}
*/
例子：复制文本文件 先读再写
public static void main(String[] args) {
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("demo.txt");
fw = new FileWriter("demo123.txt");
char[] buf = new char[1024]; // 读流读出来以后，放到内存中缓冲区，然后进写流，写流flush或close，写入demo123
int ch = 0;
while((ch=fr.read())!=-1)
{
fw.write(buf);
}
}
catch(IOException e){
e.toString();
}
finally{
if(fw!=null )
try{
fw.close();
}
catch( Exception e){
throw new RuntimeException("读写异常");
}
if(fr!=null)
try{
fr.close();
}
catch( Exception e){
throw new RuntimeException("读写异常");
}
}
}
3.字符流的缓冲区BufferedReader，BufferedWriter(其实就是在类里面封装的上面的char数组)
BufferedReader和BufferedWriter，结合流才可以使用，提高流的使用效率。 数据库的连接池
BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符，数组和字符串的高效写入。可以设置大小，但是默认大小一般够用。
方法：行分隔符newline();由line.seperate定义。
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("demo1.txt");
FileReader fr = new FileReader("demo.txt");
BufferedReader bufr = new BufferedReader(fr);
BufferedWriter bufw = new BufferedWriter(fw);
String line = null;
while((line = bufr.readLine())!=null){ //readLine()是BufferedReader特有方法,其中使用了BufferedReader的read方法，将读取到的字符串缓冲并判断换行标记，然后将标记前的字符串返回。
bufw.write(line);
bufw.newLine(); //换行 newLine()是BufferedWriter特有方法
bufw.flush();
}
bufr.close();
bufw.close(); //关掉的是流，不是缓冲区
}
java.lang.Object
|--java.io.OutputStream
|--java.io.FileOutputStream
4.FileOutputStream,FileInputStream,BufferedInputStream,BufferedOutputStream.流只能操作文本文件，而字节流可以操作多种。
private static void copy() {
FileOutputStream fos = null;
FileInputStream fis = null;
try{
fis = new FileInputStream("D:\\cover.jpg");
BufferedInputStream buis = new BufferedInputStream(fis);
fos = new FileOutputStream("E:\\cover.jpg");
BufferedOutputStream buos = new BufferedOutputStream(fos);
int ch = 0;
ry {
while((ch=buis.read(buf))!=-1){
try{
buos.write(buf);
}
catch(IOException e){
System.out.println("失败");
}
} catch (IOException e) {
e.printStackTrace();
}
catch (FileNotFoundException e) {
e.printStackTrace();
}finally{
try {
if(fis==null)
fis.close();
if(fos==null)
fos.close();
System.out.println("复制成功");
} catch (IOException e) {
e.printStackTrace();
}
}
5.字节流和字符流之间的转换 InputStreamReader,OutputStreamWriter
InputStreamReader将字节流转换成字符流(读取的还是字节流，但是它拿着字节去查表去了，返回的是字符的ASCII值，一个汉字两个字节，如果不转的话，分别输出两个字节值，转换成字符流，输出一个值) 解码的过程
从 InputStream in = System.in; 上 OutputStream out = System.out;
上 InputStreamReader isr = new InputStreamReader(in); 向 OutputStreamWriter osw = new OutputStreamWriter(out);
向 BufferedReader bufr = new BufferedReader(isr); 下 BufferedWriter bufw = new BufferedWriter(osw);
下 String line = bufr.readLine(); -------------------------> 从 bufw.write(line);
简化写法 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in或者是FileInputStream("demo.txt")));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out或者是FileOutputStream("demo.txt")));
注意点：FileWriter fw = new FileWriter("demo.txt");效果等同于
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("demo.txt"),"GBK");
FileWriter是子类，为操作文件而生，默认GBK，其中封装了转换流功能，虽然看起来是直接操作文本中的字符，但说到底文本还是要从硬盘读取，硬盘中的数据是字节。
6.File类
File f1 = new File("c:\\a.txt"); File f2 = new File("c:\\","a.txt");
File f = new File("c:\\"); File f4 = new File(f,"a.txt");
File f = new File("c:"+File.separator+"睿思"+File.separator+"a.txt"); 分隔符File.separator
具体方法：文件对象的状态获取，创建删除，判断，重命名，获取根目录和容量，目录内容，过滤指定类型文件的过滤器(FilenameFilter接口)等。
7.Properties类(与流相关)
Map
|--HashTable
|--Properties
1.集合中的键和值都是字符串类型。
2.该集合中的数据可以保存到流中，或者从流获取。操作以键值对形式存在的配置文件。
功能：将配置文件以流的形式读出，然后利用properties的方法对其中的键值形式信息进行操作。
1.Properties p = new Properties();
p.setProperty("zhangsan", "22");
FileOutputStream fos = new FileOutputStream("demo.txt");
p.store(fos, "name+age");
fos.close();
2. File file = new File("demo.txt");
if(!file.exists()){
file.createNewFile();
}
FileReader fr = new FileReader(file);
Properties p = new Properties();
p.load(fr);
p.list(System.out);//列出文件内容，测试是否关联成功
p.setProperty("wangwu", "33");
FileWriter fw = new FileWriter(file);
fw.close();
fr.close();
3.记录应用程序打开次数
File confile = new File("confile.txt");
if(!confile.exists()){
confile.createNewFile();
}
FileReader fr = new FileReader(confile);
Properties p = new Properties();
p.load(fr);
String name = p.getProperty("time");
int value = 0;
if(name!=null){
value = Integer.parseInt(name);
}
value++;
p.setProperty("time", "value");
4.返回目录下文件名以.java结尾的文件(附件
public class Test {
public static void main(String[] args) throws IOException {
File dir = new File("c:\\");
FilenameFilter filter = new FilenameFilter(){
public boolean accept(File dir,String name){
return name.endsWith(".java");
}
};
List<File> list = new ArrayList<File>();
getFiles(dir,filter,list);
File destFile = new File(dir,"javalist.txt");
write2File(list,destFile);
}
public static void getFiles(File dir,FilenameFilter filter,List<File> list){
File[] files = dir.listFiles();
for(File file : files){
if(file.isDirectory()){
getFiles(file,filter,list);
}
else{
if(filter.accept(dir, file.getName()));{
list.add(file);
}
}
}
}
public static void write2File(List<File> list,File destFile){
BufferedWriter bufw = null;
try {
bufw = new BufferedWriter(new FileWriter(destFile));
for(File file:list){
bufw.write(file.getAbsolutePath());
bufw.newLine();
bufw.flush();
}
} catch (IOException e) {
throw new RuntimeException();
}
finally{
if(bufw!=null){
try{
bufw.close();
}catch(IOException e){
throw new RuntimeException("关闭失败");
}
}
}
}
}
8.打印流 PrintStream PrintWriter
可以对多种数据类型值进行打印，并保持数据的表示形式。不抛IOException。想保证数据形式原样时，用print方法。
PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用
PrintWriter类。
构造函数接受三种类型值：字符串路径，File对象，字节输出流
PrintStream out = new PrintStream("print.txt");
out.print(97);
out.close();
9.序列流SequenceInputStream
public static void main(String[] args) throws IOException {
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>(); al.add(new FileInputStream("demo1.txt"));al.add(new FileInputStream("demo2.txt"));al.add(new FileInputStream("demo3.txt")); Enumeration<FileInputStream> en = Collection.enumeration(al); //迭代器 SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("demo.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}