File类--输入流和输出流

创建文档对象:可以是物理文档或目录,操作文档或目录的属性(路径、权限、日期和时间等)

通过流来读写文档,流是一组有序的数据串行,以先进先出方式发送信息的信道

很多的信息,都是通过文档来读取的,文档是数据源

对于进程来说,把文档读入到进程中,这是输入,把资料读出去是是输出。

在Java中流的分类:

按流向区分:        1、输出流---->OutputStream和Writer作为基类

              2、输入流---->InputputStream和Reader作为基类                    输入输出流是相对于计算机内存来说的

 

按照处理数据单元划分:    1、字节流---->字节输入流InputputStream  字节输出流OutputStream这两个作为基类  字节流是8位通过字节流,字符流是16位Unicode字符流

               2、字符流---->字符输入流Reader       字符输出流Writer这两个作为基类 

通常使用按处理数据单元划分的多一点。

字节流:  InputStream

            read()            从输入流一个字节一个字节的读,返回的是该字节的整数表示形式,如果到了输入流的末尾,返回-1

            read(byte[ ] a)         从输入流读取若干字节,把这些字节保存到数组a中,返回的是读取到字节数,如果到了输入流的末尾,返回-1

            read(byte[ ] a,int off,int len)    从输入流读取若干字节,把这些字节保存到数组a中,off指的是字节数组中开始保存数据的起始下标,len指读取的字节数                                                                                                     目。返回的是读取到的字节数,如果到了输入流的末尾,返回-1

            close()

            available()  可以从输入流中读取的字节数目

      FileInputStream(子类FileInputStream常用的构造方法)

            new FileInputStream(File file)    这是一个文档类

            new FileInputStream(String path)   这是路径

      OutputStream

            write(int a)

            write(byte [ ] a)

            write(byte [ ] a,int off ,int len)

            close()

            flush()              强制将缓冲区清空

      FileOutputStream

            new FileOutputStream(File file)

            new FileOutputStream(String path)

            new FileOutputStream(String path,boolean append)可以指定覆盖或追加文档内容,设置为true的时候,就是追加

       Reader

            read()            从输入流一个字节一个字节的读,返回的是该字节的整数表示形式,如果到了输入流的末尾,返回-1

            read(byte[ ] a)         从输入流读取若干字节,把这些字节保存到数组a中,返回的是读取到字节数,如果到了输入流的末尾,返回-1

            read(byte[ ] a,int off,int len)    从输入流读取若干字节,把这些字节保存到数组a中,off指的是字节数组中开始保存数据的起始下标,len指读取的字节数                                                                                                     目。返回的是读取到的字节数,如果到了输入流的末尾,返回-1

            close()

       InputStreamReader(是Reader的子类)可以指定字符编码格式

            new InputStreamReader(InputStream in)

            new InputStreamReader(InputStream in, String charsetName)  String charsetName这就是想要的编码格式,流和文档是编码格式化要一致,比如文档                                                                                                                                                       格式是GBK,然后设置的也要是GBK

      FileInputStreamReader(是InputStreamReader的子类,该类只能按照本地平台的字符编码来读取数据,用户不能指定其他的字符编码类型)

            new FileReader(File file)

            new FileReader(String name)

中文乱码:  原因:文档编码格式  和进程环境的编码格式不一致谢

       解决方案:FileReader是无法指定编码格式的,会按照进程的编码格式打印的。可以使用InputStreamReader字符输入流 

BufferedReader      缓冲区输入流类,再将Reader类包装成BufferedReader类,为了提高效率,把文档内容都读到了缓冲区中,然后读取数据的时候,就直接在缓冲区区读取

        readLine()  这个方法,一次将一行的内容读取出来    

        System.getProperty("file.encoding");获得本地平台的字符编码类型

        Writer

            writer(String str)        将str字符串里包含的字符输出到指定的输出流中

            writer(String str,int off,int len)   将str字符串里从off位置开始,长度为len的多个字符输出到输出流中

            close()

            flush()            刷新输出流,清空缓存

     OutputStreamWriter(是Writer的子类)

            OutputStreamWriter(OutputStream out)

            OutputStreamWriter(OutputStream out,String charsetName)

     BufferedWriter

Writer中也有输出的字符的缓冲区输出流,注意缓冲区的内容是字符串了,不再是字节了

缓冲区其实就是一个字节数组,它要积累的一定的数量,才会输入或输出

注意:所有的流都要关了,输出流不仅要关流,还要清空缓冲区的数据

二进制流:就是进行图片、音乐等这样的文档,就是使用二进制流进行读写的

    DataInputStream:是FileInputStream的子类,与FileInputStream结合使用,使用的方法跟InputStream方法一样

            new DataInputStream (InputStream in)

    DataOutputStream:是FileOutputStream的子类,与FileOutputStream结合使用

            new DataOutputStream(OutputStream in)

串行化与反串行化:串行化就是将对象(Java中创建的对象)的状态写入到特定的流中的位置,记得对象所属的类可以完成串行化,要完成串行化的对象,要记得去实现串行化的接口Serializable,才可以进行串行化的操作,对象中的某一个状态不想被串行化,可以在相应的属性中加一个关键字transient。

         串行化,就是把对象放进到流中,这个使用的是ObjectOutputStream,反之则使用ObjectInputStream

    ObjectInputStream

            new ObjectInputStream(FileInputStream fis)     注意:因为是Object对象,所以使用的方法跟InputStream一样,只是是readObject()方法

    ObjectOutputStream

            new ObjectOutputStream(FileOutputStream fis)  注意:反串行化接收到的是Object对象,所以要进行类型转换,使用的方法也是writerObject()方法

使用io的步骤:

  1、引入相关的类

  2、构造文档输入流或输出流或字符输入流或字符输出流

  3、读取或写出文本文档的数据

  4、关闭流对象

案例1:普通的输入和输出

import java.io.File;

import java.io.IOException;

public class TestClass {

   /**  

  * 创建一个文档或者目录  

  * @param file  

   */  

  public void creatFile(File file){  

     if(file.exists()){//判断文档或目录是否存在,存在为true    

      System.out.println("此文档已存在!");   

    }else{   

      try {    

         file.createNewFile();//创建文档     

        System.out.println("文档创建成功!");    

      } catch (IOException e) {     

        e.printStackTrace();   

       }   

    }

   }  

  /**  

  * 获得文档的信息  

  * @param file  

  */ 

  public void getFileInfo(File file){   

    if(file.exists()){//先判断是否有此文档或者目录   

       if(file.isFile()){//判断是否是文档    

         //获得文档的绝对路径     

        String string=file.getPath();//相对路径     

        String a=file.getAbsolutePath();//绝对路径     

        String name=file.getName();//获得文档名     

        System.out.println("相对路径:\t"+string);     

        System.out.println("绝对路径:\t"+a);     

        System.out.println("文档名为:"+name);    

        System.out.println("文档大小为:"+file.length());   

     }    

      if(file.isDirectory()){//判断是否是目录     

        System.out.println("此文档是目录");    

      }   

    }else {    

      System.out.println("此文档不存在!");   

    }  

  }  

  /**  

  * 删除文档  

  * @param file  

  */  

  public void del(File file){   

    if(file.exists()){//先要判断是否有此文档才可以进行删除工作    

      file.delete();    

      System.out.println("删除文档成功!");   

    }else{    

      System.out.println("此文档不存在");   

    }  

  }  

}

public static void main(String[] args) {
    //要去判断是否有这个文档或者目录,如果没有,那么就去创建一个文档
    TestClass testClass=new TestClass();
    File file=new File("E:/练习/text.txt");//这里是要创建的文档
  //  testClass.creatFile(file);//通过调用方法去检查是否有该文档或目录,没有就创建
  //  testClass.getFileInfo(file);
    testClass.del(file);
 }

案例2:输入流和输出流的结合使用

public static void main(String[] args) {

  //出现的问题:1:前面有一堆的字符,然后输入的中文有乱码的问题,解决的方法是FileOutputStream的write方法中,结束的位置是data,不是数组的长度
  //先把要复制的文档输入出来,然后再输出文档出来
  //创建输入流
  FileOutputStream fos=null;
  //创建输出流
  FileInputStream fis=null;
  try {
   //需要复制的原文档
   fis=new FileInputStream("E:/练习/test.txt");
   //复制到的文档,内容进行追加
   fos=new FileOutputStream("E:/练习/text.txt",true);
   //读取的长度
   int data=-1;
   //创建一个数组,去接收文档
   byte [] b=new byte[1024];
   try {
    //通过读取去获得文档内容
    while ((data=fis.read(b))!=-1) {
     //通过输出流将文档写到目标文档中去,长度是读取到的文档内容的长度
     fos.write(b, 0, data);
    }

  /*//这里在循环条件中读取了一次,然后在循环体中又读取了一次,所以读取出来的文档内容是没有第一个字节的
    while((fis.read())!=-1){
     fis.read(b);
     //这里结束的尾部是数组的长度,如果数组没有读取出那么多,就会在文档中尾部输出很多的空格,所以这里要是文档的长度
     fos.write(b,0,b.length);
    }*/
    System.out.println("复制成功!");
   } catch (IOException e) {
    e.printStackTrace();
   }
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  }
 }

案例3:所有文档的输入和输出流的结合使用

public static void main(String[] args) {
  InputStream is=null;//输入流
  InputStreamReader isr=null;
  BufferedInputStream bis=null;
  
  OutputStream os=null;//输出流
  OutputStreamWriter osw=null;
  BufferedOutputStream bos=null;
  try {
   //创建出输入流
   is=new FileInputStream("F:/刘楠梅/hello.txt");
   bis=new BufferedInputStream(is);
   isr=new InputStreamReader(is,"GBK");//因为txt文档默认的编码格式是GBK,所以输入流设置的编码格式也要是GBK
   
   //创建输出流
   os=new FileOutputStream("G:/测试/你好.txt",true);
   bos=new BufferedOutputStream(os);
   osw=new OutputStreamWriter(os,"GBK");
   //设置接收读取的长度
   int len=-1;
   //读取的字符数组
   byte [] b=new byte[1024];
   //循环遍历文档的内容,当内容为-1的时候,跳出循环
   while((len=bis.read(b))!=-1){
    //将文档输出
    bos.write(b);
   }
   //要将输出流强制清空,不然文档不会有内容
   bos.flush();
   System.out.println("完成复制!");
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (UnsupportedEncodingException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }finally{
   try {
    //最后关闭所有使用的流,记得后的先关闭,最先的最后关闭
    osw.close();
    bos.close();
    os.close();
    isr.close();
    bis.close();
    is.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 }

案例4:这是一个字符流的输入

public static void main(String[] args) {
  Reader reader=null;
  try {
   reader=new FileReader("E:/练习/text.txt");
   int data=-1;
   //读取的不再是字节了,而是字符了,所以使用char数组去接收读取出来的内容
   char []b=new char[1024];
   //可以使用StringBuffer类去添加字符串,会比较灵活
   StringBuffer stringBuffer=new StringBuffer();
   try {
    //data是实际读取到的字符数
    while ((data=reader.read(b))!=-1) {
     stringBuffer.append(b);
    }
    System.out.println(stringBuffer);
   } catch (IOException e) {
    e.printStackTrace();
   }
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  }finally{

//记得一定要关闭流
   try {
    reader.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 }

案例5:二进制输入流和输了流的结合使用

public static void main(String[] args) {
  DataInputStream dis=null;
  FileInputStream fis=null;
  DataOutputStream dos=null;
  FileOutputStream fos=null;
  BufferedInputStream bis=null;
  BufferedOutputStream bos=null;
  try {
   fis=new FileInputStream("G:/图/IMG_0054.JPG");//地址
   dis=new DataInputStream(fis);
   bis=new BufferedInputStream(fis);
   fos=new FileOutputStream("E:/视频/myphote.JPG");
   dos=new DataOutputStream(fos);
   bos=new BufferedOutputStream(fos);
   byte [] b=new byte[1024];
   int len=-1;
   while((len=bis.read(b))!=-1){
    bos.write(b);
   }
   System.out.println("写完");
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }finally{
   try {
    bos.close();
    dos.close();
    fos.close();
    bis.close();
    dis.close();
    fis.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 }

案例6:串行化与反串行化

public static void main(String[] args) {
  Student stu=new Student("小红",18,"123456");
  InputStream is=null;
  ObjectInputStream ois=null;
  //这是串行化,是把对象写进流中,是输出
  OutputStream os=null;
  ObjectOutputStream oos=null;
  try {
   //串行化
   os=new FileOutputStream("G:/测试/hello.txt");//输出流
   oos=new ObjectOutputStream(os);
   oos.writeObject(stu);//传入的参数是Object类型
   os.flush();
   is=new FileInputStream("G:/测试/hello.txt");//输入流
   ois=new ObjectInputStream(is);
   Student s=(Student)ois.readObject();
   System.out.println(s.getName()+"\t"+s.getAge()+"\t"+s.getPassword());
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }finally{
   try {
    ois.close();
    is.close();
    oos.close();
    os.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
  
 }

关键词:nbsp 文档 new 输入 file 字节 输出 入流 读取 字符

相关推荐:

Java入门系列-22-IO流

Java 文档流操作.

Java IO流学习总结一:输入输出流

Java 持久化操作之 --io流与串行化

Java——字节(输入/输出)流,字符(输入/输出)流

一、I/O操作(缓存流,数据流,对象流)

JAVA中文档的读写 I/O 输入输出流

JAVA基础——IO流