Java基础系列——IO流

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

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();
    }