12:I/O流

柔情痞子 提交于 2020-02-07 04:39:51

 

1.流是一组有序的数据序列,根据操作的类型,可分为输入流和输出流两种。流提供了一条通道程序,可以使用次通道吧源中的字节序列送到目的地。

2.输入流:程序从执行源的输入流中读取源中的数据,源可以是文件,网络,压缩包或其他数据源。

  • read()方法:从输入流中读取数据的下一个字节。返回0-255范围内的int字节值,如果到达流末尾而没有可用的字节,则返回值位-1。
  • read(byte[] b):从输入流中读入一定长度的字节,并以证书的形式返回字节数。
  • mark(int realimit)方法:在输入流的当前位置放置一个标记,readlimit 参数告知此输入流在标记位置失效之前允许读取的字节数。
  • reset()方法:将输入指针返回到当前所做的标记处
  • skip(long n)方法:跳过输入流上的n个字节并返回实际跳过的字节数。
  • markSupported()方法:如果当前流支持mark()/reset()操作就返回true。
  • colse方法:关闭此输入流并释放与该流关联的所有系统资源。

3.输出流:输出流的执行是数据要达到的目的地,程序通过向输出流中写入数据吧信息传递到目的地。输出流的目标可以是文件,网络,压缩包或其他数据源。

  • write(int b)方法:将指定的字节写入此输出流。
  • write(byte[] b)方法:将b个字节从指定的byte数组写入此输出流。
  • write(byte[] b , int off , int len)方法:将制定byte数组中从偏移量off开始的len个字节写入此输出流。
  • flush()方法:彻底完成输出并清空缓存区。
  • close()方法:关闭输出流。

4.File 类

  • 文件的创建与删除:
    • File file = new File(" d:/1.txt ");
    • File file = new File( String parent ,String child);  // parent:父路径字符串,例如:D:/ 或 D:/doc;child:子路径字符串,例如:a.txt。
    • File file = new File( File f ,String child);  //f:父路径对象。例如,D:/doc/。child:子路径字符串,例如:b.txt。
  • File.createNewFile()方法创建一个word.txt的文件。File.delete() 方法将其删除。
    package file;
    import java.io.File;
    public class FileCreateAndDetele {
        public static void main(String[] args) {
            File file = new File("D:\\zwh\\123.txt");
            if(file.exists()){
                file.delete();
                System.out.println("文件已删除!");
            }else{
                try{
                    file.createNewFile();
                    System.out.println("文件已创建!");
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
  • 获取文件信息:
    package file;
    import java.io.File;
    
    public class GetFileInfo {
        public static void main(String[] args) {
            File file = new File("D:\\zwh\\123.txt");
            if(file.exists()){
                String name = file.getName();                   //获取文件的名称
                System.out.println("获取文件的名称"+name);
                boolean canRead = file.canRead();               //判断文件是否为可读的
                System.out.println("判断文件是否为可读的"+canRead);
                boolean canWrite = file.canWrite();             //判断文件是否可被写入
                System.out.println("判断文件是否可被写入"+canWrite);
                boolean exist = file.exists();                  //判断文件是否存在
                System.out.println("判断文件是否存在"+exist);
                long length = file.length();                    //获取文件长度
                System.out.println("获取文件长度"+length);
                String absolutePath = file.getAbsolutePath();   //获取文件的绝对路径
                System.out.println("获取文件的绝对路径"+absolutePath);
                String parentPath = file.getParent();           //获取文件的父路径
                System.out.println("获取文件的父路径"+parentPath);
                boolean fileFile = file.isFile();               //判断文件是否存在
                System.out.println("判断文件是否存在"+fileFile);
                boolean directory = file.isDirectory();         //判断文件是否为一个目录
                System.out.println("判断文件是否为一个目录"+name);
                boolean hidden = file.isHidden();               //判断文件是否为隐藏文件
                System.out.println("判断文件是否为隐藏文件"+directory);
                long lastModified = file.lastModified();        //获取文件最后修改时间
                System.out.println("获取文件最后修改时间"+lastModified);
            }else{
                System.out.println("该文件不存在!");
            }
        }
    }
    
    输出结果:
    获取文件的名称123.txt
    判断文件是否为可读的true
    判断文件是否可被写入true
    判断文件是否存在true
    获取文件长度0
    获取文件的绝对路径D:\zwh\123.txt
    获取文件的父路径D:\zwh
    判断文件是否存在true
    判断文件是否为一个目录123.txt
    判断文件是否为隐藏文件false
    获取文件最后修改时间1557284138567
  • 文件输入/输出流(FileInputStream 类和FileOutputStream 类):字节流
    • FileOutputStream 类:继承InputStream 类。提供了基本的文件读取能力。
    • FileOutputStream 类:继承OutputStream 类。提供了基本的文件写入能力。
    • FileInputStream 类常用的构造方法:FileInputStream(String name) 和 FileInputStream(File file)。
      package file;
      
      import java.io.File;
      import java.io.FileInputStream;
      import java.io.FileOutputStream;
      
      /**
       * 字节流
       */
      public class FileInputOrOutputStream {                              //创建类
          public static void main(String[] args) {                        //主方法
              File file = new File("D:\\zwh\\123.txt");       //创建文件对象
              try{
                  FileOutputStream  out = new FileOutputStream(file);     //创建FileOutputStream 对象
                  byte buy[] = "我是一个程序员!".getBytes();            //创建byte型数组
                  out.write(buy);                                         //将数组中的信息写入到文件中
                  out.close();                                            //将流关闭
              }catch (Exception e){
                  e.printStackTrace();
              }
      
              try{
                  FileInputStream  in = new FileInputStream(file);                             //创建FileInputStream 类对象
                  byte byt[] = new byte[1024];                                                 //创建byte数组
                  int len = in.read(byt);                                                      //才能够文件中读取信息
                  System.out.println("文件中的信息是:"+ new String(byt,0,len));      //将文件中的信息输出
                  in.close();                                                                  //将流关闭
              }catch (Exception e){
                  e.printStackTrace();
              }
          }
      }
  • FileReader 和 FileWriter 类:
  • FileReader 流顺序地读取文件,只要不关闭流,每次调用read()方法就顺序地读取源中其余的内容,知道源的末尾或流被关闭。优点:使用字符流避免中文乱码。
     1 package file;
     2 
     3 import java.io.*;
     4 
     5 /**
     6  * 字符流
     7  */
     8 public class FileReaderOrWriter {
     9     public static void main(String[] args) {
    10         try{
    11             File fileWrite = new File("D:\\zwh\\write.txt");   //创建文件对象
    12             FileWriter out = new FileWriter(fileWrite);                   //创建文件写的对象FileWriter
    13             String s = "北京合力中税科技发展有限公司!";                   //写入文件的内容
    14             out.write(s);                                                 //写入内容
    15             out.close();
    16         }catch (Exception e){
    17             e.printStackTrace();
    18         }
    19 
    20         try {
    21             File fileReader = new File("D:\\zwh\\read.txt");   //创建文件对象
    22             FileReader in = new FileReader(fileReader);                   //创建文件读的对象FileReader
    23             char byt[] = new char[1024];                                  //创建cahr数组
    24             try {
    25                 int len = in.read(byt);                                                     //
    26                 System.out.println("文件中的信息是:"+ new String(byt,0,len));
    27                 in.close();
    28             } catch (IOException e) {
    29                 e.printStackTrace();
    30             }
    31         } catch (FileNotFoundException e) {
    32             e.printStackTrace();
    33         }
    34     }
    35 }
  • 带缓存的输入输出流:
  • 缓存:是 I/O 的一种性能优化。缓存流为 I/O 流增加了内存缓存区,有了缓存区,使得在流上执行skip(),mark(),和reset()方法都成为了可能。
  • BufferedInputStream 与 BufferedOutputStream 类:
    • BufferedInputStream 类可以对所有 InputStream 类进行缓存区的包装,主要有2个构造方法:
      • BufferedInputStream(InputStream in) 创建一个带有32个字节的缓存流
      • BufferedInputStream(InputStream in , int size) 按指定大小来创建缓存区
    • BufferedOutputStream 类输出信息和OutputStream 输出信息完全一样。不过BufferedOutputStream有一个flush()方法用来将缓存区的数据强制输出完。也有2个构造方法:
      • BufferedOutputStream(OutputStream in)创建一个带有32个字节的缓存流
      • BufferedOutputStream(OutputStream in , int size)按指定大小来创建缓存区
    • 注:flush()方法就是用于即使在缓存区没有满的情况下,也将缓存区的内容强制写入到外设,习惯上称为刷新。fulsh()方法支队事业缓存区的OutputStream类的子类有效。当调用           close()方法时,系统在关闭流之前,也会将缓存区中的信息刷新到磁盘文件中。
  • BufferedReader 与 BufferedWriter 类:
    • BufferedReader 类与 BufferedWriter 类分别继承Reader 类与Writer 类。这2个类太阳具有缓存机制,并可以以行为单位惊醒输入/输出。
  • BufferedReader 类常用的方法:
    • read()方法:读取单个字符。
    • readLine()方法:读取一个文本行,病将其返回为字符串。若无数据刻度,则返回null。
  • BufferedWriter 类中的方法都返回void,常用的方法如下:
    • write(String s , int off , int len)方法:写入字符串的某一部分。
    • flush()方法:刷新该流的缓存。
    • newLine()方法:写入一个行分隔符。
    • 使用BufferedWriter 类的Write()方法时,数据并没有立刻呗写入输出流,而是先进入缓存区中,如果想立刻将缓存区中的数据写入输出流,一定要调用flush()方法。
  • package file;
    
    import java.io.*;
    
    public class BufferedReaderAndWriter {
        public static void main(String[] args) {
            String context[] = {"你好","好久不见","最近好吗?","常联系"};             //定义字符串数组
            File file = new File("D:\\zwh\\brw.txt");
            try {
                FileWriter fileWriter = new FileWriter(file);                           //创建FileWriter 类对象
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);         //创建BufferedWriter 类对象
                for(int i=0;i<context.length;i++){                                      //循环遍历数组
                    bufferedWriter.write(context[i]);                                   //将字符串数组中的元素写入到磁盘文件中
                    bufferedWriter.newLine();                                           //将数组中的单个元素以单行的形式写入文件
                }
                bufferedWriter.close();
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            try {
                FileReader fileReader = new FileReader(file);
                BufferedReader bufferedReader = new BufferedReader(fileReader);
                String s = null;
                int i=0;
                while((s=bufferedReader.readLine()) != null){
                    i++;
                    System.out.println("第"+i+"行:"+s);
                }
                bufferedReader.close();
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
  • 数据输入/输出流(DataInputStream 类与 DateOutputStream 类),构造方法如下
    • DataInputStream(InputStream in):使用制定的基础InputStream创建一个DataInputStream。
    • DateOutputStream(OutputStream out):创建一个新的数据输出流,将数据写入制定基础输出流。
  • DateOutputStream 类提供三种写入字符串的方法:
    • writeBytes(String s)。
    • writeChars(String s)。
    • writeUTF(String s)。
  • DataInputStream 类之提供了一个readUTF()方法。
    package file;
    
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class DataInputOrOutputStream {
        public static void main(String[] args) {
            try{
                FileOutputStream fs = new FileOutputStream("D:\\zwh\\dios.txt");            //创建FileOutputStream对象
                DataOutputStream ds = new DataOutputStream(fs);                                     //创建DataOutputStream对象
                ds.writeUTF("使用writeUTF()方法写入数据;");                               //使用writeUTF()方法写入磁盘文件数据
                ds.writeChars("使用writeChars()方法写入数据");
                ds.writeBytes("使用writeBytes()方法写入数据");
                ds.close();
                fs.close();
    
                FileInputStream fileInputStream = new FileInputStream("D:\\zwh\\dios.txt"); //创建FileInputStream对象
                DataInputStream dataInputStream = new DataInputStream(fileInputStream);             //创建DataInputStream对象
                System.out.println(dataInputStream.readUTF());
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
  • Zip压缩,输入\输出流:
  • 利用ZipOutputStream 类对象,可以将文件压缩为.zip文件。
  • ZipOutputStream 的构造方法为:ZipOutputStream (OutputStream  out),常用方法如下:
    • putNextEntry(ZipEntry e):开始写一个新的ZipEntry,并将流内的位置移至此entry所指数据的开头。
    • write(byte[] b , int  off , int len ):将字节数组写入当前ZIP条目数据。
    • finish():完成写入ZIP输出流的内容,无须关闭它所配合的OutputStream。
    • setComment(String comment):可设置此ZIP文件的注释文字。
    • 例如:给文件压缩称zip文件
      package file;
      
      import java.io.*;
      import java.util.zip.ZipEntry;
      import java.util.zip.ZipOutputStream;
      
      public class MyZip {
          public static void main(String[] args) {
              MyZip myZip = new MyZip();                              //创建MyZip对象
              String zipFileName = "D:\\zwh\\myZip.zip";              //创建需要压缩的文件的文件名
              File fileName = new File("D:\\zwh\\myZip");              //创建需要压缩的文件的文件名
              //myZip.zip("E:/hello.zip",new File("E:/hello"));
              myZip.zip(zipFileName,fileName);
          }
      
      
          private void zip(String zipFileName ,File inputFile){
              try {
                  ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream(zipFileName));
                  zip(zipOutputStream,inputFile,"");
                  System.out.println("压缩中。。。。。。。。。");
                  try {
                      zipOutputStream.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              } catch (FileNotFoundException e) {
                  e.printStackTrace();
              }
          }
      
          private void zip(ZipOutputStream outputStream,File file,String base){
              if(file.isDirectory()){
                  File[] files = file.listFiles();
                  if(base.length() !=0){
                      try {
                          outputStream.putNextEntry(new ZipEntry(base+"/"));
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
                  for (int i=0;i<files.length;i++){
                      zip(outputStream,files[i],base+files[i]);
                  }
              }else{
                  try {
                      outputStream.putNextEntry(new ZipEntry(base));
                      FileInputStream in = new FileInputStream(file);
                      int b;
                      System.out.println(base);
                      while ((b=in.read()) != -1){
                          outputStream.write(b);
                      }
                      in.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
    • 例如:解压文件
      package file;
      
      import java.io.*;
      import java.util.zip.ZipEntry;
      import java.util.zip.ZipFile;
      import java.util.zip.ZipInputStream;
      
      /**
       * 解压
       */
      public class MyJyZip {
          public static void main(String[] args) throws IOException {
              File fileName = new File("D:\\zwh\\my.zip");
              try {
                  ZipFile zipFile = new ZipFile(fileName);
                  ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream(fileName));
                  try {
                      ZipEntry zipEntry = zipInputStream.getNextEntry();
                      while ((zipEntry = zipInputStream.getNextEntry()) != null && !zipEntry.isDirectory()){
                          File tempFile = new File("E:\\" +zipEntry.getName());
                          if(!tempFile.exists()){
                              tempFile.getParentFile().mkdirs();
                              OutputStream outputStream = new FileOutputStream(tempFile);
                              InputStream inputStream = zipFile.getInputStream(zipEntry);
                              int count = 0;
                              while ((count = inputStream.read()) != -1){
                                  outputStream.write(count);
                              }
                              outputStream.close();
                              inputStream.close();
                          }
                          zipInputStream.closeEntry();
                          System.out.println(zipEntry.getName()+"解压成功");
                      }
                      zipInputStream.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              } catch (FileNotFoundException e) {
                  e.printStackTrace();
              }
          }
      }

       

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!