Java基础系列——IO流

---恢复内容开始---

Java对数据的操作都是通过流的方式，数据的输入和输出是相对内存来说的，将外设的数据读到内存：输入流；将内存的数据写到外设：输出流。

流按操作数据分为两种：字节流，字符流。

输入输出的数据全都是以字节为单位的二进制，字符流后期才出现，字符流出现的目的是让机器识别日常生活文字，编码表(美国ascii，中国GBK)记录了文字和数字的对应关系，从而字节流+编码表=字节流，从硬盘读取字节流之后，先查表，转换成对应的文字，从而形成字符流。(注：国际统一的为unicode（java内置），无论什么字符都用2个字节表示)

字节流的抽象基类(顶层父类)：inputStream，outputStream.(数据载体)

字符流的抽象基类：Reader,Writer.

这些子类的后缀都是父类名，前缀是子类实现的功能。

java.lang.Objectjava.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 |--Properties1.集合中的键和值都是字符串类型。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();    }